2463 lines
69 KiB
ObjectPascal
2463 lines
69 KiB
ObjectPascal
(* This file holds all the BITBLT, Line draw, HW cursor and clock
|
|
functions *)
|
|
|
|
{Wait for WD engine ready}
|
|
procedure WD_wait;
|
|
begin
|
|
if cv.version=WD_90c33 then
|
|
repeat until (inp($23CE) and 15)=0
|
|
else begin {c31,c24}
|
|
outpw($23C0,$1001);
|
|
repeat until (inpw($23C2) and $800)=0;
|
|
end;
|
|
end;
|
|
|
|
procedure WD_outl(index:word;l:longint);
|
|
begin
|
|
outpw($23C2,index+(l and $FFF));
|
|
outpw($23C2,index+$1000+(l shr 12));
|
|
end;
|
|
|
|
procedure setHWcurmap(VAR map:CursorType);
|
|
var x,y,z,w,lbank,x0,y0:word;
|
|
l,curadr:longint;
|
|
bm:array[0..127] of byte;
|
|
mp:record
|
|
case integer of
|
|
0:(b:array[0..2047] of byte);
|
|
1:(w:array[0..1023] of word);
|
|
2:(l:array[0..511] of longint);
|
|
end;
|
|
|
|
procedure copyCurMap(bytes:word);
|
|
var x,y:word;
|
|
l:longint;
|
|
begin
|
|
l:=curadr;
|
|
if memmode=_PL4 then l:=l shr 2;
|
|
setbank(l shr 16);
|
|
if memmode=_PL4 then
|
|
begin
|
|
wrinx(GRC,3,0);
|
|
clrinx(GRC,5,$3);
|
|
wrinx(GRC,8,$FF);
|
|
for x:=0 to bytes-1 do
|
|
begin
|
|
wrinx(SEQ,2,1 shl (x and 3));
|
|
y0:=mem[SegA000:l];
|
|
mem[SegA000:l]:=mp.b[x];
|
|
if (x and 3)=3 then inc(l);
|
|
end;
|
|
end
|
|
else move(mp,mem[SegA000:l],bytes);
|
|
end;
|
|
|
|
function al_packmap(map:byte):word;
|
|
var i,j:word;
|
|
begin
|
|
j:=0;
|
|
for i:=0 to 7 do
|
|
begin
|
|
j:=j shl 2+2;
|
|
if ((map shr i) and 1)>0 then dec(j);
|
|
end;
|
|
al_packmap:=j;
|
|
end;
|
|
|
|
function al_packmap2(map:byte):longint;
|
|
var i:word;
|
|
j:longint;
|
|
begin
|
|
j:=0;
|
|
for i:=0 to 7 do
|
|
begin
|
|
j:=j shl 4+$A;
|
|
if ((map shr i) and 1)>0 then dec(j,5);
|
|
end;
|
|
al_packmap2:=j;
|
|
end;
|
|
|
|
function pack8to16(w:word):word;
|
|
var x,i:word;
|
|
begin
|
|
i:=0;
|
|
for x:=0 to 7 do
|
|
begin
|
|
i:=i shl 2;
|
|
if ((w shl x) and 128)>0 then inc(i,3);
|
|
end;
|
|
pack8to16:=i;
|
|
end;
|
|
|
|
function swapb(b:word):word;
|
|
var i,j:word;
|
|
begin
|
|
j:=0;
|
|
for i:=0 to 7 do
|
|
if ((b shr i) and 1)>0 then inc(j,128 shr i);
|
|
swapb:=j;
|
|
end;
|
|
|
|
function swapl(l:longint):longint;
|
|
var
|
|
x,y:array[0..3] of byte;
|
|
begin
|
|
swapl:=(l and $FF0000FF)+((l shl 8) and $FF0000)
|
|
+((l shr 8) and $FF00)
|
|
end;
|
|
|
|
begin
|
|
curadr:=cv.mm*longint(1024)-2048;
|
|
{ if memmode=_pl4 then curadr:=curadr shr 2;}
|
|
|
|
move(map,mp,128);
|
|
move(map,bm,128);
|
|
if dacHWcursor then
|
|
case cv.dactype of
|
|
_dacBT484,_dacBt485:
|
|
begin
|
|
outp(setDACpage(dacSTDwrInx),$80);
|
|
for x:=0 to 127 do outp(setDACpage(dacBTcMap),not mp.b[x]);
|
|
outp(setDACpage(dacSTDwrInx),0);
|
|
for x:=0 to 127 do outp(setDACpage(dacBTcMap),mp.b[x]);
|
|
modreg(setDACpage(dacBTcmd2),3,2);
|
|
end;
|
|
_dacTVP3010,_dacTVP3020,_dacTVP3025:
|
|
begin
|
|
fillchar(mp,1024,$AA);
|
|
y:=124;
|
|
for x:=127 downto 0 do {repack from 32x32x1 to 64x64x2 map}
|
|
begin
|
|
mp.w[y+x]:=swap(pack8to16(bm[x])) or $AAAA;
|
|
if (x and 3)=0 then dec(y,4);
|
|
end;
|
|
|
|
wrDACreg(dacTVPindex,6);
|
|
modDACreg(dacTVPdata,$C0,$40); {TVP302x mode & MS-Win cursor}
|
|
wrDACreg(dacTVPindex,8);
|
|
wrDACreg(dacTVPdata,0);
|
|
wrDACreg(dacTVPindex,9);
|
|
wrDACreg(dacTVPdata,0);
|
|
wrDACreg(dacTVPindex,$A); {Select Cursor RAm index}
|
|
for x:=0 to $3FF do wrDACreg(dacTVPdata,mp.b[x]);
|
|
wrDACreg(dacTVPindex,4);
|
|
wrDACreg(dacTVPdata,0);
|
|
wrDACreg(dacTVPindex,5);
|
|
wrDACreg(dacTVPdata,0);
|
|
end;
|
|
_dacTVP3026:
|
|
begin
|
|
fillchar(mp,1024,$AA);
|
|
y:=124;
|
|
for x:=127 downto 0 do {repack from 32x32x1 to 64x64x2 map}
|
|
begin
|
|
mp.w[y+x]:=swap(pack8to16(bm[x])) or $AAAA;
|
|
if (x and 3)=0 then dec(y,4);
|
|
end;
|
|
|
|
wrDACreg(dacTVP6index,6);
|
|
modDACreg(dacTVP6data,$C0,$40); {TVP302x mode & MS-Win cursor}
|
|
wrDACreg(dacTVP6index,8);
|
|
wrDACreg(dacTVP6data,0);
|
|
wrDACreg(dacTVP6index,9);
|
|
wrDACreg(dacTVP6data,0);
|
|
wrDACreg(dacTVP6index,$A); {Select Cursor RAm index}
|
|
for x:=0 to $3FF do wrDACreg(dacTVP6data,mp.b[x]);
|
|
wrDACreg(dacTVP6index,4);
|
|
wrDACreg(dacTVP6data,0);
|
|
wrDACreg(dacTVP6index,5);
|
|
wrDACreg(dacTVP6data,0);
|
|
end;
|
|
end
|
|
else
|
|
case cv.chip of
|
|
__AGX:begin
|
|
wrinx(cv.IOadr+10,$36,0);
|
|
wrinx(cv.IOadr+10,$32,32);
|
|
wrinx(cv.IOadr+10,$35,32);
|
|
x:=((cv.mm shr 1)-1) xor $1DF;
|
|
wrinx(cv.IOadr+10,$6E,x);
|
|
modinx(cv.IOadr+10,$6F,3,hi(x));
|
|
wrinx2(cv.IOadr+10,$60,512);
|
|
y:=128;
|
|
for x:=127 downto 0 do
|
|
begin
|
|
mp.w[x+y]:=pack8to16(swapb(bm[x])) xor $AAAA;
|
|
if (x and 3)=0 then dec(y,4);
|
|
end;
|
|
for x:=0 to 511 do wrinx(cv.IOadr+10,$6A,mp.b[x]);
|
|
wrinx(cv.IOadr+10,$36,1);
|
|
end;
|
|
__ALG:begin
|
|
x0:=0;
|
|
fillchar(mp,1024,$AA);
|
|
if memmode<=_p8 then
|
|
begin
|
|
y:=0;
|
|
for x:=0 to 127 do
|
|
begin
|
|
mp.w[y+x]:=al_packmap(bm[x]);
|
|
if (x and 3)=3 then inc(y,4);
|
|
end;
|
|
end
|
|
else
|
|
for x:=0 to 127 do {Double size for 64k mode}
|
|
mp.l[x]:=al_packmap2(bm[x]);
|
|
curadr:=(cv.mm-1)*longint(1024);
|
|
CopyCurMap(1024);
|
|
w:=cv.mm-1{curadr shr 10};
|
|
if cv.version=ALG_2101 then
|
|
begin
|
|
wrinx2(crtc,$27,w);
|
|
end
|
|
else begin
|
|
outpw($82C8,w);
|
|
end;
|
|
x:=inp(crtc+6); {force ATTR to address mode}
|
|
x:=inp($3C0);
|
|
y:=rdinx($3C0,$31); {Must preserve index 11h and 12h}
|
|
z:=rdinx($3C0,$32);
|
|
wrinx($3C0,$35,$FF); {Foreground index #}
|
|
wrinx($3C0,$36,0);
|
|
wrinx($3C0,$31,y);
|
|
wrinx($3C0,$32,z);
|
|
outp($3C0,x);
|
|
end;
|
|
__Alli:begin
|
|
curadr:=2048;
|
|
for x:=0 to 255 do mp.l[x]:=$55AAFF;
|
|
CopyCurMap(1024);
|
|
if mem[SegA000:$D8]=0 then;
|
|
outpw(SEQ,$1210);
|
|
setinx(SEQ,$1C,8);
|
|
modinx(SEQ,$1B,15,1);
|
|
|
|
memw[SegA000:$7944]:=curadr shr 10;
|
|
memw[SegA000:$794C]:=$2020;
|
|
mem [SegA000:$7940]:=1;
|
|
|
|
clrinx(SEQ,$1B,7);
|
|
clrinx(SEQ,$1C,8);
|
|
end;
|
|
__ARK:begin {Doesn't work yet}
|
|
curadr:=cv.mm*longint(1024)-256;
|
|
for x:=0 to 127 do mp.w[x]:=(bm[x]*$101) xor $FF;
|
|
CopyCurMap(256);
|
|
case colbits[memmode] of
|
|
15,16:x:=1;
|
|
24,32:x:=2;
|
|
else x:=0;
|
|
end;
|
|
wrinx(SEQ,$20,x or 8);
|
|
wrinx(SEQ,$25,$3F);
|
|
wrinx2(SEQ,$2C,$0); {Hotspot}
|
|
end;
|
|
__chips:if cv.version=CT_452 then
|
|
begin
|
|
for x:=255 downto 0 do
|
|
mp.w[x]:=mp.w[x div 4];
|
|
CopyCurMap(512);
|
|
|
|
wrinx(cv.IOadr,$A,0);
|
|
wrinx2m(cv.IOadr,$30,{cv.mm*longint(64)-$20}curadr shr 4);
|
|
wrinx(cv.IOadr,$32,$ff);
|
|
wrinx(cv.IOadr,$37,1);
|
|
wrinx(cv.IOadr,$38,$FF);
|
|
wrinx(cv.IOadr,$39,0);
|
|
wrinx(cv.IOadr,$3A,$FF); {Cursor FG color index}
|
|
end;
|
|
__cir54:begin
|
|
clrinx(SEQ,$12,3);
|
|
wrinx(GRC,11,$24);
|
|
move(mp,mp.b[128],128);
|
|
CopyCurMap(256);
|
|
setHWcurcol($ff0000,$ff);
|
|
wrinx(SEQ,$13,$38); {Cursor at End of Ram -2K}
|
|
end;
|
|
__Mach32:begin
|
|
outp($1AEF,255);
|
|
outpw($1EEE,0);
|
|
fillchar(mp,1024,$AA);
|
|
y:=0;
|
|
for x:=0 to 127 do
|
|
begin
|
|
mp.w[y+x]:=al_packmap(bm[x]);
|
|
if (x and 3)=3 then inc(y,4);
|
|
end;
|
|
|
|
CopyCurMap(1024);
|
|
|
|
l:={(cv.mm*longint(1024)-1024) div 4}curadr shr 2;
|
|
outpw($AEE,l);
|
|
outpw($EEE,(l shr 16) or $8000);
|
|
end;
|
|
__Mach64:begin
|
|
meml[cv.Xseg:$70]:=$200020;
|
|
meml[cv.Xseg:$68]:=curadr shr 3;
|
|
y:=4;
|
|
for x:=0 to 127 do
|
|
begin
|
|
mp.w[y+x]:=al_packmap(bm[x]);
|
|
if (x and 3)=3 then inc(y,4);
|
|
end;
|
|
{for x:=0 to 127 do mp.l[x]:=$55AAFF; }
|
|
CopyCurMap(1024);
|
|
setreg($66EC,$80);
|
|
end;
|
|
__ncr:begin
|
|
w:=curadr shr 6;
|
|
{(cv.mm*longint(16))-4; {256 bytes from the end of Vmem.}
|
|
y:=128;
|
|
for x:=127 downto 0 do
|
|
begin
|
|
mp.b[x+y]:=swapb(mp.b[x]);
|
|
if (x and 3)=0 then dec(y,4);
|
|
end;
|
|
for x:=0 to 31 do
|
|
mp.l[x*2]:=mp.l[x*2+1] xor $FFFFFFFF;
|
|
|
|
wrinx2m(SEQ,$11,$101);
|
|
CopyCurMap(256);
|
|
|
|
wrinx(SEQ,$A,$FF); {Fg color}
|
|
wrinx(SEQ,$B,$0);
|
|
wrinx2m(SEQ,$13,0);
|
|
wrinx2m(SEQ,$15,w);
|
|
wrinx(SEQ,$17,$FF);
|
|
w:=3; {Enable & 32x32}
|
|
if cv.version>=NCR_77c22ep then
|
|
case memmode of
|
|
_P15,_P16:w:=w or $20;
|
|
_P24,_P24b:w:=w or $40;
|
|
_P32,_P32b,_P32c,_P32d:w:=w or $60;
|
|
end;
|
|
wrinx(SEQ,$C,w);
|
|
end;
|
|
__Oak:if cv.Version>=OAK_083 then
|
|
begin
|
|
for x:=0 to 255 do mp.l[x]:=0;
|
|
y:=384;
|
|
for x:=127 downto 0 do
|
|
begin
|
|
mp.b[x+y]:=swapb(bm[x] xor 255);
|
|
if (x and 3)=0 then dec(y,12);
|
|
end;
|
|
|
|
CopyCurMap(1024);
|
|
|
|
wrinx2($3DE,$44,$1f20); {Limit to 32x32}
|
|
l:=curadr shr 3;
|
|
wrinx2($3DE,$47,l);
|
|
wrinx2($3DE,$49,l shr 16);
|
|
wrinx($3DE,$4A,255);
|
|
wrinx($3DE,$4B,254);
|
|
wrinx($3DE,$4C,1);
|
|
end;
|
|
__S3:begin
|
|
wrinx(crtc,$39,$A0);
|
|
if (memmode>_p8) and (cv.Version<=S3_924) then
|
|
begin
|
|
for x:=0 to 127 do
|
|
begin
|
|
y:=pack8to16(bm[x]);
|
|
mp.l[x]:=(longint(lo(y)) shl 24)+(y and $FF00)+$FF00FF;
|
|
end;
|
|
for x:=256 to 511 do mp.w[x]:=$ff;
|
|
end
|
|
else begin
|
|
for x:=0 to 255 do mp.l[x]:=$ffff; {Transparent}
|
|
y:=376;
|
|
for x:=127 downto 0 do
|
|
begin
|
|
mp.b[x+y]:=bm[x];
|
|
mp.b[x+y-2]:=not bm[x];
|
|
if (x and 1)=0 then dec(y,2);
|
|
if (x and 3)=0 then dec(y,8);
|
|
end;
|
|
if memmode=_pk4a then
|
|
for x:=0 to 511 do
|
|
mp.b[x]:=lo((mp.b[x] shl 4)+(mp.b[x] shr 4));
|
|
if (cv.Version=S3_801AB) and ((rdinx(crtc,$58) and $10)=0) then
|
|
for x:=0 to 255 do {What a hack....}
|
|
mp.l[x]:=(mp.l[x] and $FF0000FF)
|
|
+((mp.l[x] shl 8) and $FF0000)
|
|
+((mp.l[x] shr 8) and $FF00);
|
|
end;
|
|
CopyCurMap(1024);
|
|
wrinx(crtc,$39,$A0); {CurMap turns off Ext Regs}
|
|
if cv.Version>S3_924 then wrinx(crtc,$58,x);
|
|
wrinx2(crtc,$4E,0);
|
|
wrinx2m(crtc,$4C,curadr shr 10);
|
|
wrinx(crtc,$39,0);
|
|
end;
|
|
__SiS:begin
|
|
curadr:=cv.mm*longint(1024)-$4000;
|
|
for x:=0 to 255 do mp.l[x]:=$AAAAAAAA;
|
|
y:=124;
|
|
for x:=127 downto 0 do
|
|
begin
|
|
w:=0;
|
|
for z:=7 downto 0 do
|
|
begin
|
|
w:=w shl 2;
|
|
if ((bm[x] shr z) and 1)=0 then inc(w,2);
|
|
end;
|
|
mp.w[x+y]:=swap(w);
|
|
if (x and 3)=0 then dec(y,4);
|
|
end;
|
|
CopyCurMap(1024);
|
|
if (rdinx(SEQ,6) and $20)>0 then {Interlace}
|
|
begin
|
|
inc(curadr,$400);
|
|
CopyCurMap(1024);
|
|
end;
|
|
setinx(SEQ,6,$40);
|
|
wrinx(SEQ,$1C,0);
|
|
wrinx(SEQ,$1F,0);
|
|
end;
|
|
__Tseng:if cv.version>=ET_4W32 then
|
|
begin
|
|
for x:=0 to 255 do mp.l[x]:=$AAAAAAAA;
|
|
y:=384;
|
|
begin
|
|
for x:=127 downto 0 do
|
|
begin
|
|
mp.w[x+y]:=al_packmap(bm[x]);
|
|
if (x and 3)=0 then dec(y,4);
|
|
end;
|
|
CopyCurMap(1024);
|
|
wrinx($217A,$EE,1);
|
|
wrinx2($217A,$EB,2);
|
|
{l:=cv.mm*longint(256)-256;}
|
|
end;
|
|
wrinx3($217A,$E8,curadr shr 2);
|
|
|
|
wrinx($217A,$EF,2);
|
|
wrinx($217A,$ED,0);
|
|
wrinx2($217A,$E2,32);
|
|
wrinx2($217A,$E6,32);
|
|
setinx($217A,$F7,$80);
|
|
end;
|
|
__Trid:begin
|
|
for x:=0 to 31 do
|
|
begin
|
|
mp.l[x*2 ]:=not map[x];
|
|
mp.l[x*2+1]:=map[x];
|
|
end;
|
|
CopyCurMap(256);
|
|
wrinx2(crtc,$44,curadr shr 10);
|
|
wrinx2(crtc,$46,0); {Hotspot = 0,0}
|
|
wrinx(crtc,$50,$80);
|
|
end;
|
|
__WD:begin {WD90c24,31,33}
|
|
WD_wait;
|
|
outp($23C0,2);
|
|
for x:=127 downto 0 do
|
|
mp.w[x]:=mp.b[x] shl 8+$ff; {XOR cursor, how to set
|
|
fore&bkground colors ?}
|
|
|
|
CopyCurMap(256);
|
|
{ l:=cv.mm*longint(256)-64; }
|
|
WD_outl($1000,curadr shr 2);
|
|
|
|
if cv.version=WD_90c33 then w:=$C000
|
|
else w:=$5000;
|
|
outpw($23C2,w);
|
|
if memmode>_p8 then w:=$810 else w:=$860; {Mode 3}
|
|
outpw($23C2,w);
|
|
outpw($23C0,1);
|
|
end;
|
|
__Cirrus,
|
|
__Video7:begin
|
|
for x:=0 to 63 do mp.w[x]:=mp.w[x] xor $FFFF;
|
|
move(map,mp.b[128],128);
|
|
CopyCurMap(256);
|
|
wrinx(SEQ,$94,curadr shr 8);
|
|
modinx(SEQ,$FF,$60,curadr shr 13);
|
|
setinx(SEQ,$A5,$80); {Enable cursor}
|
|
end;
|
|
__xbe,__xga:begin
|
|
wrinx(cv.IOadr+10,$36,0);
|
|
fillchar(mp,1024,$ff);
|
|
wrinx2(cv.IOadr+10,$60,0);
|
|
for x:=0 to 1024 do wrinx(cv.IOadr+10,$6A,mp.b[x]);
|
|
setHWcurcol($ff0000,$ff);
|
|
wrinx(cv.IOadr+10,$32,0);
|
|
wrinx(cv.IOadr+10,$35,0);
|
|
wrinx(cv.IOadr+10,$36,1);
|
|
end;
|
|
end;
|
|
clearDACpage;
|
|
end;
|
|
|
|
procedure setHWcurcol(fgcol,bkcol:longint);
|
|
var fgc,bkc:longint;
|
|
w:word;
|
|
begin
|
|
fgc:=rgb(fgcol shr 16,hi(fgcol),lo(fgcol));
|
|
bkc:=rgb(bkcol shr 16,hi(bkcol),lo(bkcol));
|
|
if dacHWcursor then
|
|
case cv.dactype of
|
|
_dacBt484,_dacBt485:
|
|
begin
|
|
outp(setDACpage(dacBTcwrInx),1);
|
|
w:=setDACpage(dacBTcData);
|
|
outp(w,bkcol shr 16);
|
|
outp(w,hi(bkcol));
|
|
outp(w,lo(bkcol));
|
|
outp(w,fgcol shr 16);
|
|
outp(w,hi(fgcol));
|
|
outp(w,lo(fgcol));
|
|
end;
|
|
_dacTVP3010,_dacTVP3020,_dacTVP3025:
|
|
begin
|
|
wrDACreg(dacTVPindex,$23);
|
|
wrDACreg(dacTVPdata,bkcol shr 16);
|
|
wrDACreg(dacTVPindex,$24);
|
|
wrDACreg(dacTVPdata,hi(bkcol));
|
|
wrDACreg(dacTVPindex,$25);
|
|
wrDACreg(dacTVPdata,lo(bkcol));
|
|
wrDACreg(dacTVPindex,$26);
|
|
wrDACreg(dacTVPdata,fgcol shr 16);
|
|
wrDACreg(dacTVPindex,$27);
|
|
wrDACreg(dacTVPdata,hi(fgcol));
|
|
wrDACreg(dacTVPindex,$28);
|
|
wrDACreg(dacTVPdata,lo(fgcol));
|
|
end;
|
|
_dacTVP3026:
|
|
begin
|
|
wrDACreg(dacTVP6index,$23);
|
|
wrDACreg(dacTVP6data,bkcol shr 16);
|
|
wrDACreg(dacTVP6index,$24);
|
|
wrDACreg(dacTVP6data,hi(bkcol));
|
|
wrDACreg(dacTVP6index,$25);
|
|
wrDACreg(dacTVP6data,lo(bkcol));
|
|
wrDACreg(dacTVP6index,$26);
|
|
wrDACreg(dacTVP6data,fgcol shr 16);
|
|
wrDACreg(dacTVP6index,$27);
|
|
wrDACreg(dacTVP6data,hi(fgcol));
|
|
wrDACreg(dacTVP6index,$28);
|
|
wrDACreg(dacTVP6data,lo(fgcol));
|
|
end;
|
|
end
|
|
else
|
|
case cv.chip of
|
|
__ARK:begin
|
|
if (memmode=_P15) or (memmode=_P16) then
|
|
begin
|
|
fgcol:=rgb(fgcol shr 16,hi(fgcol),lo(fgcol));
|
|
bkcol:=rgb(bkcol shr 16,hi(bkcol),lo(bkcol));
|
|
end;
|
|
wrinx(SEQ,$26,lo(fgcol));
|
|
wrinx(SEQ,$27,hi(fgcol));
|
|
wrinx(SEQ,$28,fgcol shr 16);
|
|
wrinx(SEQ,$29,lo(bkcol));
|
|
wrinx(SEQ,$2A,hi(bkcol));
|
|
wrinx(SEQ,$2B,bkcol shr 16);
|
|
end;
|
|
__cir54:begin
|
|
modinx(SEQ,$12,3,2);
|
|
outp($3C8,$ff);
|
|
outp($3C9,lo(fgcol) shr 2);
|
|
outp($3C9,hi(fgcol) shr 2);
|
|
outp($3C9,fgcol shr 18);
|
|
outp($3C8,0);
|
|
outp($3C9,lo(bkcol) shr 2);
|
|
outp($3C9,hi(bkcol) shr 2);
|
|
outp($3C9,bkcol shr 18);
|
|
modinx(SEQ,$12,3,1);
|
|
end;
|
|
__Mach32:begin
|
|
outp($1AEE,lo(bkcol));
|
|
outp($1AEF,lo(fgcol));
|
|
if memmode>_p8 then
|
|
begin
|
|
outpw($3AEE,bkcol shr 8);
|
|
outpw($3EEE,fgcol shr 8);
|
|
end
|
|
end;
|
|
__Mach64:begin
|
|
meml[cv.Xseg:$60]:=(fgcol shl 8)+lo(fgcol);
|
|
meml[cv.Xseg:$64]:=(bkcol shl 8)+lo(bkcol);
|
|
end;
|
|
__S3:begin
|
|
{ wrinx(crtc,$38,$48); }
|
|
wrinx(crtc,$39,$A0);
|
|
if memmode>_p8 then
|
|
begin
|
|
if rdinx(crtc,$45)=0 then;
|
|
wrinx(crtc,$4A,fgc);
|
|
wrinx(crtc,$4A,fgc shr 8);
|
|
if memmode>=_p24 then wrinx(crtc,$4A,fgc shr 16);
|
|
if rdinx(crtc,$45)=0 then;
|
|
wrinx(crtc,$4B,bkc);
|
|
wrinx(crtc,$4B,bkc shr 8);
|
|
if memmode>=_p24 then wrinx(crtc,$4B,bkc shr 16);
|
|
end
|
|
else begin
|
|
wrinx(crtc,$E,fgcol);
|
|
wrinx(crtc,$F,bkcol);
|
|
end;
|
|
wrinx(crtc,$39,0);
|
|
end;
|
|
__SiS:begin
|
|
wrinx3(SEQ,$14,fgcol);
|
|
wrinx3(SEQ,$17,bkcol);
|
|
end;
|
|
__WD:begin
|
|
outp($23C0,2);
|
|
outpw($23C2,$8000+lo(fgcol));
|
|
outp($23C0,1);
|
|
end;
|
|
__Oak,
|
|
__NCR,
|
|
__AGX,
|
|
__Tseng:(*if cv.version>=ET_4W32 then *)
|
|
begin
|
|
outp($3C8,$FF);
|
|
outp($3C9,lo(fgcol) shr 2);
|
|
outp($3C9,hi(fgcol) shr 2);
|
|
outp($3C9,fgcol shr 18);
|
|
end;
|
|
(* __AGX:; *)
|
|
__xbe,__XGA:begin
|
|
wrinx3m(cv.IOadr+10,$38,fgcol);
|
|
wrinx3m(cv.IOadr+10,$3B,bkcol);
|
|
end;
|
|
end;
|
|
clearDACpage;
|
|
end;
|
|
|
|
procedure HWcuronoff(on:boolean);
|
|
begin
|
|
if dacHWcursor then
|
|
case cv.dactype of
|
|
_dacBt484,_dacBt485:
|
|
modreg(setDACpage(dacBTcmd2),3,2*ord(on));
|
|
_dacTVP3010,_dacTVP3020,_dacTVP3025:
|
|
begin
|
|
wrDACreg(dacTVPindex,6);
|
|
modDACreg(dacTVPdata,$40,$40*ord(on));
|
|
end;
|
|
_dacTVP3026:
|
|
begin
|
|
wrDACreg(dacTVP6index,6);
|
|
modDACreg(dacTVP6data,$40,$40*ord(on));
|
|
end;
|
|
end
|
|
else
|
|
case cv.chip of
|
|
__Alli:begin
|
|
if mem[SegA000:$D8]=0 then;
|
|
outpw(SEQ,$1210);
|
|
setinx(SEQ,$1C,8);
|
|
modinx(SEQ,$1B,7,1);
|
|
|
|
mem[SegA000:$7940]:=ord(on);
|
|
|
|
clrinx(SEQ,$1B,7);
|
|
clrinx(SEQ,$1C,8);
|
|
end;
|
|
__ARK:modinx(SEQ,$20,8,8*ord(on));
|
|
__Mach32:outp($EEF,$80*ord(on));
|
|
__Mach64:modreg($66EC,$80,$80*ord(on));
|
|
__oak:if cv.version>=OAK_083 then
|
|
modinx($3DE,$4C,1,ord(on));
|
|
__S3:begin
|
|
{ wrinx(crtc,$38,$48); }
|
|
wrinx(crtc,$39,$A0);
|
|
modinx(crtc,$45,3,2+ord(on));
|
|
wrinx(crtc,$39,0);
|
|
end;
|
|
__SiS:modinx(SEQ,6,$40,ord(on)*$40);
|
|
__Trid:modinx(crtc,$50,$80,ord(on)*$80);
|
|
__WD:begin
|
|
outp($23C0,2);
|
|
outpw($23C2,ord(on)*$800);
|
|
end;
|
|
__AGX,
|
|
__xbe,__xga:wrinx(cv.IOadr+10,$36,ord(on));
|
|
__Cirrus,
|
|
__Video7:modinx(SEQ,$A5,$80,ord(on)*$80);
|
|
|
|
end;
|
|
clearDACpage;
|
|
end;
|
|
|
|
procedure setHWcurpos(X,Y:word);
|
|
var l:longint;
|
|
w:word;
|
|
begin
|
|
|
|
if extpixfact>1 then x:=x*extpixfact;
|
|
if extlinfact>1 then Y:=Y*extlinfact;
|
|
if dacHWcursor then
|
|
case cv.dactype of
|
|
_dacBt484,_dacBt485:
|
|
begin
|
|
inline($fa);
|
|
outpw(setDACpage(dacBTcurX),x+32);
|
|
outpw(setDACpage(dacBTcurY),y+32);
|
|
inline($fb);
|
|
end;
|
|
_dacTVP3010,_dacTVP3020,_dacTVP3025:
|
|
begin
|
|
wrDACreg(dacTVPindex,0);
|
|
wrDACreg(dacTVPdata,lo(x));
|
|
wrDACreg(dacTVPindex,1);
|
|
wrDACreg(dacTVPdata,hi(x));
|
|
wrDACreg(dacTVPindex,2);
|
|
wrDACreg(dacTVPdata,lo(y));
|
|
wrDACreg(dacTVPindex,3);
|
|
wrDACreg(dacTVPdata,hi(y));
|
|
end;
|
|
_dacTVP3026:
|
|
begin
|
|
wrDACreg(dacTVP6index,0);
|
|
wrDACreg(dacTVP6data,lo(x));
|
|
wrDACreg(dacTVP6index,1);
|
|
wrDACreg(dacTVP6data,hi(x));
|
|
wrDACreg(dacTVP6index,2);
|
|
wrDACreg(dacTVP6data,lo(y));
|
|
wrDACreg(dacTVP6index,3);
|
|
wrDACreg(dacTVP6data,hi(y));
|
|
end;
|
|
end
|
|
else
|
|
case cv.chip of
|
|
__ALG:if cv.version=ALG_2101 then
|
|
begin
|
|
if (rdinx(crtc,$19) and 1)=0 then y:=y*2;
|
|
if ((memmode=_P8) and ((rdinx(GRC,$C) and $10)=0))
|
|
or (memmode>_P8) then x:=x*2;
|
|
wrinx(crtc,$21,x shr 3);
|
|
wrinx(crtc,$23,y shr 1);
|
|
modinx(crtc,$25,$7f,((x and 7) shl 2) + (y shr 9)
|
|
+((y and 1) shl 6) or $20);
|
|
end
|
|
else begin
|
|
clrinx(crtc,$1A,4);
|
|
setinx(GRC,$F,$25);
|
|
outpw($82CA,x);
|
|
outpw($82CC,y);
|
|
clrinx(GRC,$F,1);
|
|
setinx(crtc,$1A,$54);
|
|
end;
|
|
__Alli:begin
|
|
if mem[SegA000:$D8]=0 then;
|
|
outpw(SEQ,$1210);
|
|
setinx(SEQ,$1C,8);
|
|
modinx(SEQ,$1B,15,1);
|
|
|
|
memw[SegA000:$7948]:=x;
|
|
memw[SegA000:$794A]:=y;
|
|
|
|
clrinx(SEQ,$1B,7);
|
|
clrinx(SEQ,$1C,8);
|
|
end;
|
|
__ARK:begin
|
|
wrinx2m(SEQ,$21,x);
|
|
wrinx2m(SEQ,$23,y);
|
|
end;
|
|
__chips:if cv.version=CT_452 then
|
|
begin
|
|
wrinx2m(cv.IOadr,$33,x);
|
|
wrinx2m(cv.IOadr,$35,y);
|
|
end;
|
|
__CIR54:BEGIN
|
|
outpw(SEQ,(x shl 5) or $10);
|
|
outpw(SEQ,(y shl 5) or $11);
|
|
END;
|
|
__Mach32:begin
|
|
outpw($12EE,x);
|
|
outpw($16EE,y);
|
|
end;
|
|
__Mach64:begin
|
|
memw[cv.Xseg:$6C]:=x;
|
|
memw[cv.Xseg:$6E]:=y;
|
|
end;
|
|
__ncr:begin
|
|
wrinx2m(SEQ,$D,x);
|
|
wrinx2m(SEQ,$F,y);
|
|
end;
|
|
__Oak:if cv.Version>=OAK_083 then
|
|
begin
|
|
wrinx2m($3DE,$40,x and $FFFC);
|
|
wrinx2m($3DE,$42,y);
|
|
end;
|
|
__S3:begin
|
|
if (curmode=$13) or (curmode=$D) then x:=x*2
|
|
else if cv.version<S3_864 then
|
|
begin
|
|
if memmode>=_P24 then x:=x*3
|
|
else if (memmode>=_P15) then x:=x*2;
|
|
end
|
|
else if (memmode>=_P32) and (cv.version<S3_732) then x:=x*2;
|
|
wrinx(crtc,$39,$A0);
|
|
wrinx2m(crtc,$46,x);
|
|
wrinx(crtc,$49,y);
|
|
wrinx(crtc,$48,y shr 8); {this byte registers the new
|
|
cursor position - must be last
|
|
byte written}
|
|
setinx(crtc,$45,1);
|
|
wrinx(crtc,$39,0);
|
|
end;
|
|
__SiS:begin
|
|
wrinx2(SEQ,$1A,x);
|
|
if (rdinx(SEQ,6) and $20)>0 then {Interlace}
|
|
begin
|
|
if (y and 1)>0 then y:=y+$2000;
|
|
y:=y shr 1;
|
|
end;
|
|
wrinx2(SEQ,$1D,y);
|
|
end;
|
|
__Trid:begin
|
|
wrinx2(crtc,$40,x);
|
|
wrinx2(crtc,$42,y);
|
|
end;
|
|
__Tseng:if cv.version>=ET_4W32 then
|
|
begin
|
|
if cv.version<ET_4W32p_A then
|
|
case memmode of
|
|
_p15,_p16:x:=x*2;
|
|
_p24:x:=x*3;
|
|
end;
|
|
if (cv.subvers>=$20) and (cv.subvers<$40) then
|
|
begin
|
|
repeat until (inp(crtc+6) and 2)>0;
|
|
repeat w:=inp(crtc+6) until (w and 2)=0;
|
|
wrinx2($217A,$E4,y);
|
|
if (w and $40)=0 then
|
|
begin
|
|
outp($3BF,3);
|
|
outp($3D8,$A0);
|
|
modinx(crtc,$37,$40,$40);
|
|
modinx(crtc,$37,$40,0);
|
|
outp($3D8,$29);
|
|
outp($3BF,1);
|
|
end;
|
|
end
|
|
else wrinx2($217A,$E4,y);
|
|
wrinx2($217A,$E6,32);
|
|
wrinx2($217A,$E0,x);
|
|
wrinx2($217A,$E2,32);
|
|
end;
|
|
(* __AGX:if (inp(cv.IOadr) and 4)>0 then
|
|
begin
|
|
wrinx2(cv.IOadr+10,$30,x);
|
|
wrinx2(cv.IOadr+10,$33,y);
|
|
end; *)
|
|
__WD:begin
|
|
outp($23C0,2);
|
|
if cv.version=WD_90c33 then
|
|
begin
|
|
if (memmode=_p15) or (memmode=_p16) then
|
|
x:=(x*2) div 3;
|
|
outpw($23C2,$D000+x);
|
|
outpw($23C2,$E000+y);
|
|
end
|
|
else begin
|
|
case memmode of
|
|
_p15,_p16:x:=x*2;
|
|
_p24:x:=x*3;
|
|
end;
|
|
outpw($23C2,$6000+x);
|
|
outpw($23C2,$7000+y);
|
|
end;
|
|
end;
|
|
__Cirrus,
|
|
__Video7:begin
|
|
wrinx2m(SEQ,$9C,X);
|
|
wrinx2m(SEQ,$9E,Y);
|
|
end;
|
|
__AGX,__xbe,__XGA:begin
|
|
wrinx2(cv.IOadr+10,$30,x);
|
|
wrinx2(cv.IOadr+10,$33,y);
|
|
end;
|
|
end;
|
|
clearDACpage;
|
|
end;
|
|
|
|
|
|
const
|
|
S3accelmode:byte=0; {0: unknown, 1: Accell, 2: Frame}
|
|
|
|
{If possible sets up the mode for acceleration ad returns true, false if not}
|
|
function S3accelON:boolean;
|
|
begin
|
|
S3accelON:=true;
|
|
if (cv.version>S3_924) and (memmode>_PL4) then
|
|
begin
|
|
wrinx(crtc,$38,$48);
|
|
wrinx(crtc,$39,$A5);
|
|
clrinx(crtc,$58,$14); {Disable Linear adr. & RAC}
|
|
modinx(crtc,$40,9,1);
|
|
clrinx(crtc,$53,$F);
|
|
wrinx(crtc,$54,$A0);
|
|
outpw($BEE8,$E000);
|
|
outpw($AAE8,$FFFF); {Enable all planes - }
|
|
outpw($AEE8,$FFFF);
|
|
if memmode>=_p24 then
|
|
begin
|
|
outpw($BEE8,$E010);
|
|
outpw($AAE8,$FFFF); {Enable all planes - }
|
|
outpw($AEE8,$FFFF);
|
|
end;
|
|
S3accelmode:=1;
|
|
end
|
|
else begin
|
|
wrinx(crtc,$38,$48);
|
|
wrinx(crtc,$39,$A5);
|
|
if (rdinx(crtc,$40) and 1)=0 then S3accelON:=false;
|
|
wrinx(crtc,$39,0);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure S3accelOFF;
|
|
begin
|
|
if (cv.version>S3_924) and (memmode>_PL4) then
|
|
begin
|
|
wrinx(crtc,$38,$48);
|
|
wrinx(crtc,$39,$A5);
|
|
if (rdinx(crtc,$40) and 1)>0 then
|
|
repeat until (inpw($9AE8) and $200)=0;
|
|
clrinx(crtc,$40,1);
|
|
setinx(crtc,$40,8);
|
|
if (memmode>_pl4) and (curmode<>$13) then setinx(crtc,$58,$10);
|
|
wrinx(crtc,$39,$5A);
|
|
wrinx(crtc,$38,$00);
|
|
S3accelmode:=2;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TridOutB(index,val:word);
|
|
begin
|
|
outp(cv.IOadr,index);
|
|
outp(cv.IOadr+2,val);
|
|
end;
|
|
|
|
procedure TridOutW(index,val:word);
|
|
begin
|
|
outp(cv.IOadr,index);
|
|
outpw(cv.IOadr+2,val);
|
|
end;
|
|
|
|
procedure TridOutL(index:word;val:longint);
|
|
begin
|
|
outp(cv.IOadr,index);
|
|
outpw(cv.IOadr+2,val);
|
|
outpw(cv.IOadr+4,val shr 16);
|
|
end;
|
|
|
|
|
|
(* Wait til ALG ready *)
|
|
procedure ALG_wait;
|
|
begin
|
|
if cv.version=ALG_2101 then
|
|
repeat until (inp($82AA) and $F)=0
|
|
else
|
|
repeat until (inp($82BA) and $80)=0;
|
|
end;
|
|
|
|
procedure AL_DstCoor(xst,yst:word);
|
|
var l:longint;
|
|
w:word;
|
|
begin
|
|
l:=yst*longint(pixels)+xst;
|
|
ALG_wait;
|
|
if memmode>_p8 then
|
|
begin
|
|
l:=l*2;
|
|
outpw($828A,pixels*2);
|
|
end
|
|
else outpw($828A,pixels);
|
|
outpw($8286,l);
|
|
outp( $8288,l shr 16);
|
|
outpw($829C,xst);
|
|
outpw($829E,yst);
|
|
end;
|
|
|
|
procedure AL_BlitArea(dx,dy:word);
|
|
begin
|
|
if memmode>_p8 then dx:=dx*2;
|
|
outpw($828C,dx);
|
|
outpw($828E,dy);
|
|
end;
|
|
|
|
procedure AL_SrcCoor(xst,yst:word);
|
|
var l:longint;
|
|
w:word;
|
|
begin
|
|
l:=yst*longint(pixels)+xst;
|
|
if memmode>_p8 then
|
|
begin
|
|
l:=l*2;
|
|
outpw($8284,pixels*2);
|
|
end
|
|
else outpw($8284,pixels);
|
|
outpw($8280,l);
|
|
outp( $8282,l shr 16);
|
|
end;
|
|
|
|
procedure WD_coor(index,x,y:word);
|
|
var l,b:longint;
|
|
begin
|
|
b:=bytes;
|
|
if memmode<=_pl4 then b:=b*8;
|
|
case memmode of
|
|
_p15,_p16:x:=x*2;
|
|
_p24:x:=x*3;
|
|
end;
|
|
l:=b*y+x;
|
|
WD_outl(index,l);
|
|
end;
|
|
|
|
procedure WD_DstCoor(X,Y,dx,dy:word);
|
|
var b:longint;
|
|
begin
|
|
WD_coor($4000,X,Y);
|
|
b:=bytes;
|
|
if memmode<=_pl4 then b:=b*8;
|
|
case memmode of
|
|
_p15,_p16:dx:=dx*2;
|
|
_p24:dx:=dx*3;
|
|
end;
|
|
outpw($23C2,$6000+dx);
|
|
outpw($23C2,$7000+dy);
|
|
outpw($23C2,$8000+b);
|
|
end;
|
|
|
|
procedure P2000_DstCoor(X,Y,dx,dy,dir:word);
|
|
var l:longint;
|
|
begin
|
|
l:=longint(pixels)*y+x;
|
|
if memmode>_p8 then
|
|
begin
|
|
dx:=dx*2;
|
|
l:=l*2;
|
|
wrinx2(GRC,$3A,pixels*2);
|
|
end
|
|
else wrinx2(GRC,$3A,pixels);
|
|
if dir>0 then dy:=dy or $C000;
|
|
wrinx2(GRC,$33,dx);
|
|
wrinx3(GRC,$37,l);
|
|
wrinx2(GRC,$35,dy);
|
|
end;
|
|
|
|
procedure P2000_SrcCoor(X,Y:word);
|
|
var l:longint;
|
|
begin
|
|
l:=longint(pixels)*y+x;
|
|
if memmode>_p8 then l:=l*2;
|
|
if memmode=_pl4 then wrinx(GRC,5,0); {set write mode 0}
|
|
wrinx3(GRC,$30,l);
|
|
wrinx2(GRC,$1E,pixels);
|
|
end;
|
|
|
|
procedure P2000_cmd(cmd:word);
|
|
begin
|
|
wrinx(GRC,$3D,cmd);
|
|
repeat until (rdinx(GRC,$3D) and 1)=0;
|
|
wrinx(GRC,$3D,0);
|
|
end;
|
|
|
|
procedure S3_fill(xst,yst,dx,dy:integer;col:longint);
|
|
begin
|
|
if (pixels>1024) and (memmode>=_p8) and
|
|
(cv.Version>=S3_928) and (cv.Version<S3_864) then {Argh...}
|
|
begin
|
|
yst:=yst*2;
|
|
dy:=dy*2;
|
|
end;
|
|
|
|
repeat until (inp($9AE8) and $FF)=0;
|
|
outpw($82E8,yst);
|
|
outpw($86E8,Xst);
|
|
outpw($96E8,dx);
|
|
outpw($BEE8,$E000);
|
|
outpw($A6E8,col);
|
|
if (memmode>=_p24) then
|
|
begin
|
|
outpw($BEE8,$E010);
|
|
outpw($A6E8,col shr 16);
|
|
end;
|
|
repeat until (inp($9AE8) and $FF)=0;
|
|
outpw($BAE8,$27);
|
|
outpw($BEE8,dy-1);
|
|
outpw($BEE8,$A000);
|
|
outpw($9AE8,$40F1);
|
|
clrinx(crtc,$40,1);
|
|
end;
|
|
|
|
procedure fillrect(xst,yst,dx,dy:word;col:longint);
|
|
const
|
|
masks:array[0..3] of byte=(0,7,3,1);
|
|
maske:array[0..3] of byte=($F8,$FC,$FE,$FF);
|
|
masks4:array[0..7] of byte=(0,$7F,$3F,$1F,$F,7,3,1);
|
|
maske4:array[0..7] of byte=($80,$C0,$E0,$F0,$F8,$FC,$FE,$FF);
|
|
var w,w1:word;
|
|
l:longint;
|
|
begin
|
|
case cv.chip of
|
|
__ALG:begin
|
|
AL_DstCoor(xst,yst);
|
|
AL_BlitArea(dx,dy);
|
|
wrinx(GRC,$D,col);
|
|
outp( $8290,7);
|
|
outp( $8292,$D);
|
|
outp( $82AA,1);
|
|
end;
|
|
__ARK:begin
|
|
repeat until (inp($3CB) and $F)>=7;
|
|
setinx(SEQ,$10,$1C);
|
|
wrinx(SEQ,$13,$00);
|
|
wrinx(SEQ,$14,$C0);
|
|
memw[SegA800:$02]:=0;
|
|
memw[SegA800:$08]:=col;
|
|
memw[SegA800:$18]:=$300;
|
|
memw[SegA800:$1A]:=$FFFF;
|
|
meml[SegA800:$58]:=0;
|
|
meml[SegA800:$5C]:=$FFFFFFFF;
|
|
repeat until (inp($3CB) and $F)>=7;
|
|
memw[SegA800:$70]:=Xst;
|
|
memw[SegA800:$72]:=Yst;
|
|
memw[SegA800:$74]:=dx;
|
|
memw[SegA800:$76]:=dy;
|
|
meml[SegA800:$7C]:=$20400000;
|
|
clrinx(SEQ,$10,$1C);
|
|
end;
|
|
__compaq:begin
|
|
case usebits[memmode] of
|
|
4:col:=(col and 15)*$11111111;
|
|
8:col:=lo(col)*$1010101;
|
|
15,16:col:=(col and $FFFF)*$10001;
|
|
end;
|
|
repeat until (inp($33CE) and 1)=0;
|
|
if (cv.Version=CPQ_AVGA) or (rdinx(GRC,$F)=$A5) then
|
|
begin
|
|
if memmode=_p8 then
|
|
begin
|
|
l:=(yst*bytes+xst) shr 2;
|
|
w:=bytes shr 2;
|
|
outp($33C0,masks[xst and 3]);
|
|
outp($33C1,maske[((xst+dx-1) and 3)]);
|
|
outp($33C8,(-dx) and 3);
|
|
outp($33C9,masks[dx and 3]);
|
|
if ((xst and 3)=0) and ((dx and 3)=0) then inc(dx,4);
|
|
outpw($23C2,(dx +(xst and 3) +3) shr 2);
|
|
end
|
|
else begin
|
|
l:=yst*bytes+(xst shr 3);
|
|
w:=bytes;
|
|
outp($33C0,masks4[xst and 7]);
|
|
outp($33C1,maske4[(xst+dx-1) and 7]);
|
|
outp($33C8,(-dx) and 7);
|
|
outp($33C9,masks4[dx and 7]);
|
|
if ((xst and 7)=0) and ((dx and 7)=0) then inc(dx,8);
|
|
outpw($23C2,(dx +(xst and 7) +7) shr 3);
|
|
end;
|
|
outpw($23C0,l);
|
|
outpw($23CA,w);
|
|
outpw($23CC,w);
|
|
{ outpw($33C0,$ffff); }
|
|
outp($33c7,$c);
|
|
{ outpw($33c8,0); }
|
|
w:=(l shr 2) and $C000;
|
|
w:=w or ((dy shl 4) and $3000);
|
|
outpw($23C4,dy+w);
|
|
{ if (xst and 3)>0 then inc(dx,4);
|
|
if ((xst+dx-1) and 3)>0 then inc(dx,4); }
|
|
outp($33CF,$30);
|
|
end
|
|
else begin
|
|
outpw($63CC,xst);
|
|
outpw($63CE,yst);
|
|
outpw($23C2,dx);
|
|
outpw($23C4,dy);
|
|
outp($33CF,$C0);
|
|
wrinx(GRC,$5A,2);
|
|
end;
|
|
outpw($33CA,col);
|
|
outpw($33CA,col);
|
|
outpw($33CC,col shr 16);
|
|
outpw($33CC,col shr 16);
|
|
outp($33CE,9);
|
|
end;
|
|
__cir54:begin
|
|
repeat until (rdinx(GRC,$31) and 1)=0;
|
|
case memmode of
|
|
_p15,_p16:w:=2;
|
|
_p24:w:=3;
|
|
else w:=1;
|
|
end;
|
|
wrinx(GRC,1,col);
|
|
wrinx(GRC,$11,hi(col));
|
|
wrinx2(GRC,$20,dx*w);
|
|
wrinx2(GRC,$22,dy);
|
|
wrinx3(GRC,$28,Yst*bytes+Xst*w);
|
|
wrinx3(GRC,$2C,cv.mm*longint(1024)-8);
|
|
modinx(GRC,$30,$CF,$C0); {PatternCopy + Color Expand}
|
|
wrinx(GRC,$32,$D);
|
|
wrinx(GRC,$31,2);
|
|
end;
|
|
__Mach32:begin
|
|
repeat until inpw($9AEE)=0;
|
|
outpw($A6E8,col);
|
|
outpw($BAEE,7);
|
|
outpw($CEEE,$3391);
|
|
outpw($82E8,yst);
|
|
outpw($86E8,xst);
|
|
outpw($A6EE,xst);
|
|
outpw($AAEE,xst+dx);
|
|
outpw($AEEE,yst+dy);
|
|
end;
|
|
__Mach64:begin
|
|
repeat until (mem[cv.Xseg:$338] and 1)=0;
|
|
repeat until memw[cv.Xseg:$310]=0;
|
|
write32($2C4,col); {Fill color}
|
|
write32($2D4,$70003); {}
|
|
write32($2C8,$FFFFFFFF); {Write mask}
|
|
write32($2D8,$100); {}
|
|
write32($130,3); {Dest Cntl}
|
|
|
|
write32w($10C,xst,yst); {Dest start X,Y}
|
|
write32w($118,dy,dx); {Size}
|
|
end;
|
|
__NCR:begin
|
|
repeat until (mem[cv.Xseg:$32] and 1)=1;
|
|
write32($50,col);
|
|
write32($4C,col);
|
|
write32($48,0);
|
|
write32($44,0);
|
|
write32($40,pixeladdress(Xst,Yst));
|
|
write32w($3C,dy,dx);
|
|
write32($38,$cc0000);
|
|
write32($34,$C8C0); {Color Expand, Down&Right}
|
|
write32($30,1); {Start}
|
|
end;
|
|
__P2000:begin
|
|
wrinx(GRC,$3E,col);
|
|
P2000_DstCoor(xst,yst,dx,dy,0);
|
|
P2000_cmd($19);
|
|
end;
|
|
__S3:if S3accelON then
|
|
begin
|
|
S3_fill(xst,yst,dx,dy,col);
|
|
if (memmode>_p8) and (cv.version<=S3_924) then
|
|
S3_fill(xst+1024,yst,dx,dy,hi(col));
|
|
S3accelOFF;
|
|
end;
|
|
__SiS:begin
|
|
setinx(SEQ,$B,1);
|
|
while (mem[SegA000:$82AB] and $80)>0 do;
|
|
meml[SegA000:$8284]:=xst*bytes+yst;
|
|
memw[SegA000:$828A]:=bytes;
|
|
memw[SegA000:$828C]:=8;
|
|
memw[SegA000:$828E]:=4;
|
|
mem [SegA000:$8290]:=col;
|
|
mem [SegA000:$8293]:=$F0;
|
|
memw[SegA000:$82AA]:=$30;
|
|
clrinx(SEQ,$B,1);
|
|
end;
|
|
__Trid:if cv.Version>=TR_9200CXr then
|
|
begin
|
|
while (mem [$BFF0:$20] and $20)>0 do;
|
|
mem [$BFF0:$27]:=$F0;
|
|
memw[$BFF0:$2C]:=col;
|
|
memw[$BFF0:$30]:=col;
|
|
memw[$BFF0:$38]:=Xst;
|
|
memw[$BFF0:$3A]:=Yst;
|
|
memw[$BFF0:$40]:=dx-1;
|
|
memw[$BFF0:$42]:=dy-1;
|
|
memw[$BFF0:$28]:=$4000;
|
|
mem [$BFF0:$24]:=1;
|
|
|
|
end;
|
|
__Tseng:if cv.version>=ET_4W32 then
|
|
begin
|
|
case colbits[memmode] of
|
|
8:l:=col*$1010101;
|
|
15,16:begin
|
|
l:=col*$10001;
|
|
dx:=dx*2;
|
|
Xst:=Xst*2;
|
|
end;
|
|
24:begin
|
|
l:=col*$1000001;{Bug!!}
|
|
dx:=dx*3;
|
|
Xst:=Xst*3;
|
|
end;
|
|
32:begin
|
|
l:=col;
|
|
dx:=dx*4;
|
|
Xst:=Xst*4;
|
|
end;
|
|
end;
|
|
write32(0,l);write32(4,l);
|
|
{memL[cv.xseg:0]:=l; {Fill Color}
|
|
{ write32($7F80,cv.mm*longint(1024)-8);
|
|
{meml[cv.xseg:$7F80]:=cv.mm*longint(1024)-4; {Pattern/Color Data}
|
|
mem [cv.xseg:$7F8F]:=0; {Direction}
|
|
memw[cv.xseg:$7F98]:=dx-1;
|
|
memw[cv.xseg:$7F9A]:=dy-1;
|
|
mem [cv.xseg:$7F9C]:=0;
|
|
mem [cv.xseg:$7F9F]:=$F0;
|
|
write32($7FA0,Yst*bytes+Xst);
|
|
{meml[cv.xseg:$7FA0]:=Yst*bytes+Xst;}
|
|
if cv.version<ET_4W32p_a then mem [cv.xseg:$7F31]:=9;
|
|
|
|
end;
|
|
__WD:if cv.Version=WD_90c33 then
|
|
begin
|
|
WD_wait;
|
|
outp($23C0,3);
|
|
outpw($23C2,$2000+lo(col));
|
|
outpw($23C2,$3000+hi(col));
|
|
outp($23C0,1);
|
|
outpw($23C2,$4000+xst);
|
|
outpw($23C2,$5000+yst);
|
|
outpw($23C2,$6000+dx-1);
|
|
outpw($23C2,$7000+dy-1);
|
|
outpw($23C2,$8300);
|
|
outpw($23C2,$210);
|
|
end
|
|
else begin {c24,c31}
|
|
outp($23C0,1);
|
|
outpw($23C2,$1000);
|
|
outpw($23C2,$E0FF);
|
|
outpw($23C2,$9300);
|
|
outpw($23C2,$A000+col);
|
|
{ outpw($23C2,$2000);
|
|
outpw($23C2,$3000); }
|
|
if (memmode<=_pl4) and ((xst and 7)+dx=10) then
|
|
begin
|
|
w1:=1;
|
|
dec(dx);
|
|
end else w1:=0;
|
|
|
|
WD_DstCoor(xst,yst,dx,dy);
|
|
if cv.version=WD_90c33 then w:=$208 else w:=$808;
|
|
if memmode>_pl4 then w:=w+$100;
|
|
outpw($23C2,w);
|
|
WD_wait;
|
|
if w1>0 then
|
|
begin
|
|
WD_DstCoor(xst+dx-1,yst,1,dy);
|
|
{ if cv.version=WD_90c33 then w:=$208 else} w:=$808;
|
|
if memmode>_pl4 then w:=w+$100;
|
|
outpw($23C2,w);
|
|
WD_wait;
|
|
end;
|
|
end;
|
|
__AGX,__xbe,__xga:
|
|
begin
|
|
repeat until (mem[cv.xseg:$11] and $80)=0;
|
|
mem [cv.xseg:$12]:=1;
|
|
mem [cv.xseg:$48]:=3; {Always Src}
|
|
meml[cv.xseg:$58]:=col;
|
|
memw[cv.xseg:$78]:=xst;
|
|
memw[cv.xseg:$7A]:=yst;
|
|
memw[cv.xseg:$60]:=dx-1;
|
|
memw[cv.xseg:$62]:=dy-1;
|
|
meml[cv.xseg:$7C]:=$8118000; {Cmd (Bitblt)}
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure S3_copy(srcX,srcY,dstX,dstY,dx,dy,dir:word);
|
|
begin
|
|
if (pixels>1024) and (memmode>=_p8) and
|
|
(cv.Version>=S3_928) and (cv.Version<S3_864) then {Argh...}
|
|
begin
|
|
srcY:=srcY*2;
|
|
dstY:=dstY*2;
|
|
dY:=dY*2;
|
|
end;
|
|
|
|
repeat until (inp($9AE8) and $FF)=0;
|
|
outpw($BAE8,$67);
|
|
outpw($BEE8,$A000);
|
|
outpw($86E8,SrcX);
|
|
outpw($82E8,SrcY);
|
|
outpw($8EE8,DstX);
|
|
outpw($8AE8,DstY);
|
|
|
|
outpw($96E8,dx-1);
|
|
outpw($BEE8,dy-1);
|
|
repeat until (inp($9AE8) and $FF)=0;
|
|
{ outpw($BEE8,$E040); }
|
|
if dir<>0 then outpw($9AE8,$C013)
|
|
else outpw($9AE8,$C0F3);
|
|
end;
|
|
|
|
procedure copyrect(srcX,srcY,dstX,dstY,dx,dy:word);
|
|
var l:longint;
|
|
w,dir:word;
|
|
i1,i2:integer;
|
|
begin
|
|
if (DstY<SrcY) or ((SrcY=DstY) and (DstX<SrcX)) then dir:=0
|
|
else begin
|
|
dir:=1;
|
|
SrcX:=SrcX+dx-1;
|
|
SrcY:=SrcY+dy-1;
|
|
DstX:=DstX+dx-1;
|
|
DstY:=DstY+dy-1;
|
|
end;
|
|
case cv.chip of
|
|
__ALG:begin
|
|
if dir>0 then
|
|
begin
|
|
SrcX:=SrcX-dx+1;
|
|
DstX:=DstX-dx+1;
|
|
end;
|
|
AL_DstCoor(DstX,DstY);
|
|
AL_BlitArea(dx,dy);
|
|
AL_SrcCoor(SrcX,SrcY);
|
|
w:=7;
|
|
if dir>0 then w:=1;
|
|
outp( $8290,w);
|
|
outpw($8292,w);
|
|
outp( $82AA,2);
|
|
end;
|
|
__compaq:begin
|
|
repeat until (inp($33CE) and 1)=0;
|
|
if (cv.Version=CPQ_AVGA) or (rdinx(GRC,$F)=$A5) then {AVGA}
|
|
begin
|
|
l :=srcy*bytes+srcx;
|
|
w:=256;
|
|
if (dir>0) then w:=$FF00;
|
|
{ begin
|
|
l:=l+(dy-1)*bytes+(dx-1);
|
|
w:=$ff00;
|
|
end; }
|
|
i1:=dsty-srcy;
|
|
i2:=dstx-srcx;
|
|
outpw($23C0,l shr 2);
|
|
outpw($23CC,lo(i1)*256+lo(i2 shr 2));
|
|
outp($23C2,dx shr 2);
|
|
outpw($23CA,w{bytes shr 2});
|
|
outpw($33C0,$FFFF);
|
|
outp($33C7,$C);
|
|
outpw($33C8,0);
|
|
w:=(w and $C00) or ((l shr 4) and $C000);
|
|
w:=w or ((i1 shl 4) and $3000);
|
|
outpw($23C4,dy+w);
|
|
outp($33CF,$30);
|
|
end
|
|
else begin {QVision}
|
|
outpw($63CC,DstX);
|
|
outpw($63CE,DstY);
|
|
outpw($63C0,SrcX);
|
|
outpw($63C2,SrcY);
|
|
outpw($23C2,dx);
|
|
outpw($23C4,dy);
|
|
outpw($23CC,bytes shr 2);
|
|
outp($33CF,$C0);
|
|
wrinx(GRC,$5A,1);
|
|
end;
|
|
outp($33CE,$11+(dir shl 6));
|
|
end;
|
|
__cir54:begin
|
|
repeat until (rdinx(GRC,$31) and 1)=0;
|
|
case memmode of
|
|
_p15,_p16:w:=2;
|
|
_p24:w:=3;
|
|
else w:=1;
|
|
end;
|
|
wrinx2(GRC,$20,dx*w);
|
|
wrinx2(GRC,$22,dy);
|
|
wrinx3(GRC,$28,dstY*bytes+dstX*w);
|
|
wrinx3(GRC,$2C,srcY*bytes+srcX*w);
|
|
wrinx (GRC,$32,$D);
|
|
modinx(GRC,$30,$CF,dir);
|
|
wrinx (GRC,$31,2);
|
|
end;
|
|
__Mach32:begin
|
|
repeat until inpw($9AEE)=0;
|
|
outpw($BAEE,$7);
|
|
outpw($CEEE,$7391);
|
|
outpw($8EE8,SrcX);
|
|
outpw($8AE8,SrcY);
|
|
outpw($B2EE,SrcX);
|
|
outpw($82E8,DstY);
|
|
outpw($86E8,DstX);
|
|
outpw($A6EE,DstX);
|
|
if dir=0 then
|
|
begin
|
|
outpw($C2EE,1);
|
|
outpw($BEEE,SrcX+dx);
|
|
outpw($AAEE,DstX+dx);
|
|
outpw($AEEE,DstY+dy);
|
|
end
|
|
else begin
|
|
outpw($C2EE,0);
|
|
outpw($BEEE,SrcX-dx);
|
|
outpw($AAEE,DstX-dx);
|
|
outpw($AEEE,DstY-dy);
|
|
end;
|
|
end;
|
|
__Mach64:begin
|
|
repeat until (mem[cv.Xseg:$338] and 1)=0;
|
|
repeat until memw[cv.Xseg:$310]=0;
|
|
write32($2D4,$70003); {}
|
|
write32($2C8,$FFFFFFFF); {Write mask}
|
|
write32($2D8,$300); {}
|
|
write32($1B4,0); {Src Cntl}
|
|
|
|
write32w($18C,SrcX,SrcY); {Src start X,Y}
|
|
write32($190,dy); {Src width1}
|
|
if dir=0 then w:=3 else w:=0;
|
|
write32($130,w); {Dest Cntl}
|
|
write32w($10C,DstX,DstY); {Dest start X,Y}
|
|
write32w($118,dy,dx); {Size}
|
|
end;
|
|
__NCR:begin
|
|
repeat until (mem[cv.Xseg:$32] and 1)=1;
|
|
write32($44,pixeladdress(SrcX,SrcY));
|
|
write32($40,pixeladdress(DstX,DstY));
|
|
write32w($3C,dy,dx);
|
|
write32($38,$CC0000);
|
|
w:=$C0C0;
|
|
if dir>0 then w:=$C000;
|
|
write32($34,w); {Copy, Down&Right}
|
|
write32($30,1); {Start}
|
|
end;
|
|
__P2000:begin
|
|
if dir>0 then
|
|
begin
|
|
SrcX:=SrcX-dx+1;
|
|
DstX:=DstX-dx+1;
|
|
end;
|
|
P2000_SrcCoor(SrcX,SrcY);
|
|
P2000_DstCoor(DstX,DstY,dx,dy,dir);
|
|
P2000_Cmd(5);
|
|
end;
|
|
__WD:if cv.Version=WD_90c33 then
|
|
begin
|
|
WD_wait;
|
|
outp($23C0,1);
|
|
outpw($23C2,$2000+SrcX);
|
|
outpw($23C2,$3000+SrcY);
|
|
outpw($23C2,$4000+DstX);
|
|
outpw($23C2,$5000+DstY);
|
|
outpw($23C2,$6000+dx-1);
|
|
outpw($23C2,$7000+dy-1);
|
|
outpw($23C2,$8300);
|
|
if dir>0 then w:=$380 else w:=$200;
|
|
outpw($23C2,w);
|
|
end
|
|
else begin
|
|
WD_wait;
|
|
outpw($23C2,$1000);
|
|
outpw($23C2,$E0FF);
|
|
WD_DstCoor(DstX,DstY,dx,dy);
|
|
WD_Coor($2000,SrcX,SrcY);
|
|
outpw($23C2,$9300);
|
|
w:=$800;
|
|
if memmode>_pl4 then w:=w+$100;
|
|
if dir>0 then w:=w+$400;
|
|
outpw($23C2,w);
|
|
WD_wait;
|
|
end;
|
|
__S3:if S3accelON then
|
|
begin
|
|
S3_copy(SrcX,SrcY,DstX,DstY,dx,dy,dir);
|
|
if (memmode>_p8) and (cv.version<=S3_924) then
|
|
S3_copy(SrcX+1024,SrcY,DstX+1024,DstY,dx,dy,dir);
|
|
S3accelOFF;
|
|
end;
|
|
__Trid:if cv.Version>=TR_9200CXr then
|
|
begin
|
|
while (mem [$BFF0:$20] and $20)>0 do;
|
|
mem [$BFF0:$27]:=$CC;
|
|
memw[$BFF0:$38]:=DstX;
|
|
memw[$BFF0:$3A]:=DstY;
|
|
memw[$BFF0:$3C]:=SrcX;
|
|
memw[$BFF0:$3E]:=SrcY;
|
|
memw[$BFF0:$40]:=dx-1;
|
|
memw[$BFF0:$42]:=dy-1;
|
|
memw[$BFF0:$28]:=0;
|
|
mem [$BFF0:$24]:=1;
|
|
end;
|
|
__Tseng:if cv.version>=ET_4W32 then
|
|
begin
|
|
case colbits[memmode] of
|
|
15,16:begin
|
|
dx:=dx*2;
|
|
SrcX:=SrcX*2;
|
|
DstX:=DstX*2;
|
|
end;
|
|
24:begin
|
|
dx:=dx*3;
|
|
SrcX:=SrcX*3;
|
|
DstX:=DstX*3;
|
|
end;
|
|
32:begin
|
|
dx:=dx*4;
|
|
SrcX:=SrcX*4;
|
|
DstX:=DstX*4;
|
|
end;
|
|
end;
|
|
mem [cv.xseg:$7F9F]:=$CC; {Copy}
|
|
mem [cv.xseg:$7F8F]:=3*dir; {Direction}
|
|
mem [cv.xseg:$7F9C]:=0;
|
|
memw[cv.xseg:$7F98]:=dx-1;
|
|
memw[cv.xseg:$7F9A]:=dy-1;
|
|
write32($7F84,SrcY*bytes+SrcX);
|
|
write32($7FA0,DstY*bytes+DstX);
|
|
if cv.version<ET_4W32p_a then mem[cv.xseg:$7F31]:=9;
|
|
end;
|
|
__AGX,__xbe,__xga:
|
|
begin
|
|
repeat until (mem[cv.xseg:$11] and $80)=0;
|
|
mem [cv.xseg:$48]:=3;
|
|
memw[cv.xseg:$70]:=SrcX;
|
|
memw[cv.xseg:$72]:=SrcY;
|
|
memw[cv.xseg:$78]:=DstX;
|
|
memw[cv.xseg:$7A]:=DstY;
|
|
memw[cv.xseg:$60]:=dx-1;
|
|
memw[cv.xseg:$62]:=dy-1;
|
|
|
|
l:=$28118000;
|
|
if dir>0 then inc(l,6);
|
|
meml[cv.xseg:$7C]:=l; {BitBlt cmd}
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure swp(var i,j:integer);
|
|
var z:integer;
|
|
begin
|
|
z:=i;
|
|
i:=j;
|
|
j:=z;
|
|
end;
|
|
|
|
procedure S3_line(x0,y0,x1,y1:integer;col:longint);
|
|
var w,z:word;
|
|
begin
|
|
if (pixels>1024) and (memmode>=_p8) and
|
|
(cv.Version>=S3_928) and (cv.Version<S3_864) then {Argh...}
|
|
begin {urgh! - is there a better way?}
|
|
y0:=y0*2;
|
|
y1:=y1*2;
|
|
end;
|
|
repeat until (inp($9AE8) and $FF)=0;
|
|
outpw($82E8,Y0);
|
|
outpw($86E8,X0);
|
|
w:=0;z:=0;
|
|
x1:=x1-x0;
|
|
if x1<0 then
|
|
begin
|
|
x1:=-x1;
|
|
w:=w or $20;
|
|
z:=1;
|
|
end;
|
|
y1:=y1-y0;
|
|
if y1<0 then
|
|
begin
|
|
y1:=-y1;
|
|
w:=w or $80;
|
|
end;
|
|
if x1<y1 then
|
|
begin
|
|
swp(x1,y1);
|
|
w:=w or $40;
|
|
end;
|
|
outpw($8AE8,2*y1);
|
|
outpw($8EE8,2*(y1-x1));
|
|
outpw($92E8,2*y1-x1-z);
|
|
outpw($96E8,x1);
|
|
outpw($BEE8,$E000);
|
|
outpw($A6E8,col);
|
|
repeat until (inp($9AE8) and $FF)=0;
|
|
if (memmode>_p16) then
|
|
begin
|
|
outpw($BEE8,$E010);
|
|
outpw($A6E8,col shr 16);
|
|
end;
|
|
outpw($BAE8,$27);
|
|
outpw($BEE8,$A000);
|
|
outpw($9AE8,$2017+w);
|
|
end;
|
|
|
|
|
|
procedure line(x0,y0,x1,y1:integer;col:longint);
|
|
var l:longint;
|
|
z,w:word;
|
|
dx,dy,mi,ma:integer;
|
|
begin
|
|
case cv.chip of
|
|
__ALG:begin
|
|
AL_DstCoor(x0,y0);
|
|
wrinx(GRC,$D,col);
|
|
outpw($82A8,$FFFF);
|
|
w:=0;
|
|
x1:=x1-x0;
|
|
if x1<0 then
|
|
begin
|
|
x1:=-x1;
|
|
w:=w or $100;
|
|
end;
|
|
if memmode>_p8 then x1:=x1*2;
|
|
y1:=y1-y0;
|
|
if y1<0 then
|
|
begin
|
|
y1:=-y1;
|
|
w:=w or $200;
|
|
end;
|
|
if x1<y1 then
|
|
begin
|
|
swp(x1,y1);
|
|
w:=w or $400;
|
|
end;
|
|
outpw($82A2,2*y1);
|
|
outpw($82A6,2*y1-x1);
|
|
outpw($82A4,2*(y1-x1));
|
|
outpw($828E,x1+1);
|
|
outpw($8292,$80D+w);
|
|
outp ($8290,0);
|
|
outp ($82AA,8);
|
|
end;
|
|
__Mach32:begin
|
|
repeat until inpw($9AEE)=0;
|
|
outpw($A6E8,col);
|
|
outpw($A2EE,0);
|
|
{ outpw($BEE8,$A000); }
|
|
outpw($BAE8,$27);
|
|
{ outp ($B6E8,$27); }
|
|
outpw($9AEE,0);
|
|
outpw($FEEE,x0); {Start}
|
|
outpw($FEEE,y0);
|
|
outpw($FEEE,x1); {Stop}
|
|
outpw($FEEE,y1);
|
|
end;
|
|
__Mach64:begin
|
|
repeat until memw[cv.Xseg:$310]=0;
|
|
write32($2C4,col); {Fg Color}
|
|
write32($2D4,$70003);
|
|
write32($2C8,$FFFFFFFF); {Write mask}
|
|
write32($2D8,$100);
|
|
write32w($2A8,pixels-1,0); {Clip left/right}
|
|
write32w($2B4,lins-1,0); {Clip top/bot}
|
|
|
|
|
|
dx:=abs(x0-x1);
|
|
dy:=abs(y0-y1);
|
|
mi:=dx;
|
|
ma:=dy;
|
|
if mi>ma then swp(mi,ma);
|
|
write32w($10C,x0,y0);
|
|
if x1>x0 then w:=1 else w:=0;
|
|
if y0<y1 then inc(w,2);
|
|
if dx<dy then inc(w,4);
|
|
write32($130,w);
|
|
write32($124,2*mi-ma);
|
|
write32($128,2*mi);
|
|
write32($12C,2*(mi-ma));
|
|
write32($120,ma+1);
|
|
|
|
(* case memmode of
|
|
_PK4:l:=$10101;
|
|
_P8,_P24:l:=$20202;
|
|
_P15:l:=$30303;
|
|
_P16:l:=$40404;
|
|
_P32:l:=$60606;
|
|
end;
|
|
meml[cv.Xseg:$2D0]:=l; {Pixel Width}
|
|
meml[cv.Xseg:$308]:=0; {Color Cmp off}
|
|
meml[cv.Xseg:$330]:=3; {GUI trajetory}
|
|
|
|
repeat until memw[cv.Xseg:$310]=0;
|
|
|
|
meml[cv.Xseg:$100]:=(pixels shr 3) shl 22; {} *)
|
|
|
|
|
|
l:=meml[cv.Xseg:$310];
|
|
|
|
end;
|
|
__WD:if cv.Version=WD_90c33 then
|
|
begin
|
|
WD_wait;
|
|
dx:=abs(x0-x1);
|
|
dy:=abs(y0-y1);
|
|
mi:=dx;
|
|
ma:=dy;
|
|
if mi>ma then swp(mi,ma);
|
|
outpw($23C8,2*mi);
|
|
outpw($23CA,2*(mi-ma));
|
|
if x0>x1 then inc(ma);
|
|
outpw($23CC,2*mi-ma);
|
|
outp($23C0,3);
|
|
outpw($23C2,$2000+lo(col));
|
|
outpw($23C2,$3000+hi(col));
|
|
outp($23C0,1);
|
|
WD_wait;
|
|
outpw($23C2,$4000+x0);
|
|
outpw($23C2,$5000+y0);
|
|
outpw($23C2,$6000+ma);
|
|
outpw($23C2,$8300);
|
|
w:=$810;
|
|
if x0>x1 then w:=w+$100;
|
|
if y0>y1 then w:=w+$80;
|
|
if dx<dy then w:=w+$40;
|
|
outpw($23C2,w);
|
|
w:=w;
|
|
end
|
|
else begin
|
|
WD_wait;
|
|
dx:=abs(x0-x1);
|
|
dy:=abs(y0-y1);
|
|
mi:=dx;
|
|
ma:=dy;
|
|
if mi>ma then swp(mi,ma);
|
|
outpw($23C2,$4000+x0);
|
|
outpw($23C2,$5000+y0);
|
|
outpw($23C2,$6000+dx);
|
|
outpw($23C2,$7000+dy);
|
|
outpw($23C2,$9300);
|
|
outpw($23C2,$A000+lo(col));
|
|
outpw($23C8,2*mi);
|
|
outpw($23CA,2*(mi-ma));
|
|
if x0>x1 then inc(ma);
|
|
outpw($23CC,2*mi-ma);
|
|
w:=$1800;
|
|
{ if x0>x1 then inc(w,$100); }
|
|
if y0>y1 then inc(w,$100);
|
|
if dx>dy then inc(w,$200);
|
|
outpw($23C2,w);
|
|
outpw($23C2,$910);
|
|
WD_wait;
|
|
end;
|
|
__S3:if S3accelON then
|
|
begin
|
|
S3_line(x0,y0,x1,y1,col);
|
|
if (memmode>_p8) and (cv.Version<=S3_924) then
|
|
S3_line(x0+1024,y0,x1+1024,y1,hi(col));
|
|
S3accelOFF;
|
|
end;
|
|
__Tseng:if (cv.version>=ET_4W32) {and (x0<>x1) and (y0<>y1)} then
|
|
begin
|
|
case colbits[memmode] of
|
|
8:l:=col*$1010101;
|
|
15,16:begin
|
|
l:=col*$10001;
|
|
X0:=X0*2;
|
|
X1:=X1*2;
|
|
end;
|
|
24:begin
|
|
l:=col*$1000001;{Bug!!}
|
|
X0:=X0*3;
|
|
X1:=X1*3;
|
|
end;
|
|
32:begin
|
|
l:=col;
|
|
X1:=X1*4;
|
|
X0:=X0*4;
|
|
end;
|
|
end;
|
|
write32(0,l);
|
|
{memL[cv.xseg:0]:=l; {Fill Color}
|
|
write32(4,l);
|
|
{memL[cv.xseg:4]:=l; {Fill Color}
|
|
l:=cv.mm*longint(1024)-4; {Pattern/Color Data}
|
|
w:=0;
|
|
y1:=y1-y0;
|
|
x1:=x1-x0;
|
|
if y1=0 then
|
|
begin
|
|
if x1<0 then
|
|
begin
|
|
x1:=-x1;
|
|
inc(x0);
|
|
end;
|
|
dx:=x1-1;
|
|
dy:=0;
|
|
end
|
|
else if x1=0 then
|
|
begin
|
|
if Y1<0 then
|
|
begin
|
|
Y1:=-Y1;
|
|
inc(Y0);
|
|
end;
|
|
dx:=0;
|
|
dy:=y1-1;
|
|
end
|
|
else begin
|
|
w:=$80;
|
|
if Y1<0 then
|
|
begin
|
|
Y1:=-Y1;
|
|
w:=w or $12;
|
|
end;
|
|
if x1<0 then
|
|
begin
|
|
x1:=-X1;
|
|
w:=w or 1;
|
|
inc(l,3);
|
|
end;
|
|
if X1<Y1 then
|
|
begin
|
|
z :=X1;
|
|
X1:=Y1;
|
|
Y1:=z;
|
|
w:=w or 4;
|
|
dx:=Y1-1;
|
|
dy:=$FFF;
|
|
end
|
|
else begin
|
|
dx:=$FFF;
|
|
dy:=Y1-1;
|
|
end;
|
|
memw[cv.xseg:$7FAC]:=X1;
|
|
memw[cv.xseg:$7FAE]:=Y1;
|
|
end;
|
|
write32($7F80,l);
|
|
{meml[cv.xseg:$7F80]:=l; {Pattern/Color Data}
|
|
mem [cv.xseg:$7F8F]:=w; {Direction}
|
|
mem [cv.xseg:$7F9C]:=0;
|
|
mem [cv.xseg:$7F9F]:=$F0;
|
|
memw[cv.xseg:$7F98]:=dx;
|
|
memw[cv.xseg:$7F9A]:=dy;
|
|
write32($7FA0,Y0*bytes+X0);
|
|
{meml[cv.xseg:$7FA0]:=Y0*bytes+X0;}
|
|
end;
|
|
__AGX,__xbe,__xga:
|
|
begin
|
|
repeat until (mem[cv.xseg:$11] and $80)=0;
|
|
dx:=abs(X0-X1);
|
|
dy:=abs(Y0-Y1);
|
|
mi:=dx;
|
|
ma:=dy;
|
|
if mi>ma then swp(mi,ma);
|
|
meml[cv.xseg:$58]:=col;
|
|
mem [cv.xseg:$48]:=3;
|
|
memw[cv.xseg:$78]:=X0;
|
|
memw[cv.xseg:$7A]:=Y0;
|
|
memw[cv.xseg:$24]:=2*mi;
|
|
memw[cv.xseg:$28]:=2*(mi-ma);
|
|
if x0>x1 then inc(ma);
|
|
memw[cv.xseg:$20]:=2*mi-ma;
|
|
memw[cv.xseg:$60]:=ma-1;
|
|
memw[cv.xseg:$62]:=dy-1;
|
|
|
|
l:=$5118000;
|
|
if dy>dx then inc(l,1);
|
|
if Y0>Y1 then inc(l,2);
|
|
if X0>X1 then inc(l,4);
|
|
meml[cv.xseg:$7C]:=l;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
ZwinOfs:longint;
|
|
Zxstep:word;
|
|
|
|
|
|
procedure setZoomWindow(Xs,Ys,Xe,Ye:word);
|
|
begin
|
|
case cv.chip of
|
|
__Tseng:if cv.version=ET_3000 then
|
|
begin
|
|
case memmode of
|
|
_Pl4:Xs:=Xs div 8;
|
|
_pk4:Xs:=Xs shr 1;
|
|
{ _p15,_p16:Xs:=Xs*2;
|
|
_P24:Xs:=Xs*3; }
|
|
end;
|
|
ZwinOfs:=bytes*Ys+Xs;
|
|
wrinx(crtc,$1B,Xs shr 3);
|
|
wrinx(crtc,$1C,Xe shr 3);
|
|
wrinx(crtc,$1D,Ys);
|
|
wrinx(crtc,$1E,Ye);
|
|
wrinx(crtc,$1F,hi(Ye)+(hi(Ys) shl 3));
|
|
end
|
|
else if cv.version>=ET_4W32 then
|
|
begin
|
|
wrinx2($217A,$E0,Xs);
|
|
wrinx2($217A,$E2,Xe-Xs+1);
|
|
wrinx2($217A,$E4,Ys);
|
|
wrinx2($217A,$E6,Ye-Ys+1);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure setZoomAdr(AdrX,AdrY:word);
|
|
var l:longint;
|
|
begin
|
|
case memmode of
|
|
_Pl4:AdrX:=AdrX div 8;
|
|
_pk4:AdrX:=AdrX shr 1;
|
|
_p15,_p16:AdrX:=AdrX*2;
|
|
_P24,_p24b:AdrX:=AdrX*3;
|
|
end;
|
|
l:=(bytes*AdrY+AdrX);
|
|
case cv.chip of
|
|
__Tseng:if cv.version=ET_3000 then
|
|
begin
|
|
l:=(l shr 3)-(ZwinOfs shr 3);
|
|
wrinx2(crtc,$20,l);
|
|
modinx(crtc,$23,4,l shr 14);
|
|
end
|
|
else if cv.version>=ET_4W32 then
|
|
wrinx3($217A,$E8,l);
|
|
end;
|
|
|
|
end;
|
|
|
|
procedure ZoomOnOff(On:boolean);
|
|
begin
|
|
case cv.chip of
|
|
__Tseng:if cv.version=ET_3000 then
|
|
begin
|
|
modinx(SEQ,6,$80,ord(On) shl 7);
|
|
Zxstep:=8;
|
|
end
|
|
else if cv.version>=ET_4W32 then
|
|
begin
|
|
wrinx($217A,$EF,3);
|
|
wrinx2($217A,$EB,bytes div 8);
|
|
modinx($217A,$F7,$80,ord(On) shl 7);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure setZoomFactor(Fx,Fy:word);
|
|
begin
|
|
case cv.chip of
|
|
__Tseng:if cv.version=ET_3000 then modinx(SEQ,6,$77,Fy+(Fx shl 4))
|
|
else if cv.version>=ET_4W32 then
|
|
wrinx($217A,$EE,3+(Fx shl 6)+(Fy shl 4));
|
|
end;
|
|
end;
|
|
|
|
|
|
(* Clock Selection *)
|
|
|
|
procedure setclk(Nbr,divi:word);
|
|
var x:word;
|
|
begin
|
|
|
|
if (cv.flags and FLG_StdVGA)>0 then clrinx(crtc,$11,$80);
|
|
|
|
case cv.chip of
|
|
__AGX:begin
|
|
if (cv.Version=IIT_AGX1x) then x:=$7F else x:=$77;
|
|
if Nbr>15 then
|
|
begin
|
|
modinx(cv.IOadr+10,x,$30,nbr shl 4);
|
|
modinx(cv.IOadr+10,$6F,$70,(nbr shl 2) or $40);
|
|
clrinx(cv.IOadr+10,$70,$80);
|
|
end
|
|
else if Nbr>7 then
|
|
begin
|
|
modinx(cv.IOadr+10,x,$30,nbr shl 4);
|
|
clrinx(cv.IOadr+10,$6F,$70);
|
|
setinx(cv.IOadr+10,$54,$0C);
|
|
clrinx(cv.IOadr+10,$70,$80);
|
|
end
|
|
else begin
|
|
modinx(cv.IOadr+10,$54,$0C,nbr shl 2);
|
|
clrinx(cv.IOadr+10,$6F,$70);
|
|
modinx(cv.IOadr+10,$70,$80,nbr shl 5);
|
|
end;
|
|
modinx(cv.IOadr+10,x,$40,divi shl 6);
|
|
end;
|
|
|
|
__Ahead:begin {Only for the B ??}
|
|
modinx(GRC,$E,$3,nbr shr 2);
|
|
if divi>0 then x:=$F0 else x:=0;
|
|
modinx(GRC,$E,$F0,x);
|
|
end;
|
|
__ALG:begin
|
|
modinx(GRC,$C,$20,Nbr shl 3);
|
|
modinx(GRC,$1F,$4,Nbr shr 1);
|
|
modinx(GRC,$B,3,divi);
|
|
end;
|
|
__ARK:begin
|
|
modinx(SEQ,$11,$C0,nbr shl 4);
|
|
end;
|
|
__ati:begin
|
|
if cv.version=ATI_18800 then
|
|
modinx(cv.IOadr,$B2,64,nbr shl 4)
|
|
else begin
|
|
modinx(cv.IOadr,$B9,2,Nbr shr 1);
|
|
modinx(cv.IOadr,$BE,$10,Nbr shl 1);
|
|
end;
|
|
if cv.version<ATI_GUP_3 then x:=$C0 else x:=$40;
|
|
modinx(cv.IOadr,$B8,x,divi shl 6);
|
|
end;
|
|
__chips:if cv.Version<CT_65520 then
|
|
begin
|
|
if nbr>3 then nbr:=(nbr-4)*4+2;
|
|
outp(crtc+6,(inp($3CA) and $FC)+nbr shr 2);
|
|
end
|
|
else begin
|
|
if Nbr>3 then
|
|
begin
|
|
x:=Nbr-4;
|
|
Nbr:=2;
|
|
end;
|
|
if (rdinx(cv.IOadr,$51) and 4)>0 then {Panel}
|
|
modinx(cv.IOadr,$54,$C3,(nbr+(x shl 2)) shl 2)
|
|
else {CRT}
|
|
outp(crtc+6,inp($3CA) and $FC + (x and 3));
|
|
end;
|
|
__Compaq:outp($3C2,(inp($3CC) and $EF) + ((nbr and 4) shl 2));
|
|
__Genoa:modinx(SEQ,7,1,nbr shr 2);
|
|
__HMC:modinx(SEQ,$E7,$C0,Nbr shl 4);
|
|
__Mach32:modreg($4AEE,$3C,nbr shl 2);
|
|
__Mach64:modreg($4AEC,$7F,(nbr and $F)+((divi and 3) shl 4)+$40);
|
|
__MXIC:modinx(SEQ,$C4,1,Nbr shr 2);
|
|
__NCR:if cv.version=NCR_77c32BLT then
|
|
modinx(SEQ,$1F,$60,Nbr shl 3)
|
|
else modinx(SEQ,$1F,$60,(Nbr shl 4) or $20);
|
|
__oak:begin
|
|
modinx($3DE,$D,$20,Nbr shl 3);
|
|
modinx($3DE,$6,8,nbr);
|
|
end;
|
|
__p2000:modinx(GRC,$14,$30,Nbr shl 2);
|
|
__WD:begin
|
|
modinx(GRC,$C,2,Nbr shr 1);
|
|
if cv.version>WD_90c00 then
|
|
modinx(SEQ,$12,4,nbr shr 1);
|
|
if cv.version=WD_90c24 then
|
|
begin
|
|
wrinx(SEQ,$35,$50); {Unlock clock regs}
|
|
modinx(SEQ,$31,$18,nbr shl 1);
|
|
end;
|
|
end;
|
|
__realtek:modinx(GRC,$C,$20,Nbr shl 3);
|
|
__S3:if nbr<>3 then
|
|
begin
|
|
wrinx(crtc,$38,$48);
|
|
wrinx(crtc,$39,$A5);
|
|
modinx(crtc,$42,$F,Nbr);
|
|
outp($3C2,inp($3CC) or $C);
|
|
wrinx(crtc,$39,$5A);
|
|
wrinx(crtc,$38,$0);
|
|
nbr:=3; {Fool std vga}
|
|
end;
|
|
__SiS:begin
|
|
modinx(SEQ,$7,$F,nbr);
|
|
nbr:=3;
|
|
end;
|
|
__Tseng:if cv.version=ET_3000 then modinx(crtc,$24,2,Nbr shr 1)
|
|
else begin
|
|
outp($3BF,3);
|
|
outp(crtc+4,$A0);
|
|
modinx(crtc,$34,2,Nbr shr 1);
|
|
modinx(crtc,$31,$C0,Nbr shl 3);
|
|
end;
|
|
__Poach,
|
|
__Trid:begin
|
|
wrinx(SEQ,$B,0); {Old mode}
|
|
case cv.version of
|
|
TR_8900C,TR_9000C,TR_8900CL..TR_GUI9430:
|
|
modinx(SEQ,$E,$10,Nbr shl 1);
|
|
end;
|
|
if rdinx(SEQ,$B)=0 then; {New mode}
|
|
modinx(SEQ,$D,1,Nbr shr 2);
|
|
if ((cv.version=TR_9000) or (cv.version=TR_9000i)) then
|
|
modinx(SEQ,$D,$40,nbr shl 3);
|
|
modinx(SEQ,$D,6,divi shr 1);
|
|
end;
|
|
__UMC:modinx(SEQ,7,1,Nbr shr 2);
|
|
__Video7:begin
|
|
modinx(SEQ,$A4,$1C,Nbr shl 2);
|
|
modinx(SEQ,$F8,1,Nbr shr 3);
|
|
end;
|
|
end;
|
|
if (cv.flags and FLG_StdVGA)>0 then
|
|
outp($3C2,(inp($3CC) and $F3)+((Nbr and 3) shl 2));
|
|
end;
|
|
|
|
{Returns the id of the selected clock and the divisor used on it.
|
|
The divisor is in 1/12th, Ie. 12 = /1, 24 = /2, 18 = /1.5
|
|
divid is an ID for the divisor (0,1..)}
|
|
function getclk(var divisor,divid:word):word;
|
|
var x,clknbr:word;
|
|
const
|
|
_1_ = 12;
|
|
_1_5 = 18;
|
|
_2_ = 24;
|
|
_3_ = 36;
|
|
_4_ = 48;
|
|
|
|
triddiv:array[0..3] of word=(_1_,_2_ ,_4_,_1_5);
|
|
atidiv:array[0..3] of word=(_1_,_2_ ,_3_,_4_);
|
|
otidiv:array[0..3] of word=(_1_,_2_ ,_3_,_3_);
|
|
P2000div:array[0..3] of word=(_1_,_4_ ,_2_,_4_);
|
|
RTGdiv:array[0..3] of word=(_1_,_1_5,_2_,_4_);
|
|
ALGdiv:array[0..3] of word=(_1_,_2_ ,_4_,_4_);
|
|
begin
|
|
divisor:=12; {standard no division}
|
|
clknbr:=(inp($3CC) shr 2) and 3;
|
|
divid:=0;
|
|
case cv.chip of
|
|
__AGX:begin
|
|
if (cv.Version=IIT_AGX1x) then x:=$7F else x:=$77;
|
|
if (rdinx(cv.IOadr+10,$6F) and $40)>0 then
|
|
begin
|
|
clknbr:=((rdinx(cv.IOadr+10,x) shr 4) and 3)+16;
|
|
inc(clknbr,(rdinx(cv.IOadr+10,$6F) and $30) shr 2);
|
|
end
|
|
else begin
|
|
clknbr:=(rdinx(cv.IOadr+10,$54) shr 2) and 3;
|
|
if (rdinx(cv.IOadr+10,$70) and $80)>0 then inc(clknbr,4);
|
|
if clknbr=3 then
|
|
clknbr:=((rdinx(cv.IOadr+10,x) shr 4) and 3)+8;
|
|
end;
|
|
if (rdinx(cv.IOadr+10,x) and $40)>0 then
|
|
begin
|
|
divisor:=_2_;
|
|
divid:=1;
|
|
end;
|
|
end;
|
|
__Ahead:begin {Only for the B ??}
|
|
x:=rdinx(GRC,$E);
|
|
if ((x shr clknbr) and $10)>0 then
|
|
begin
|
|
divid:=1;
|
|
divisor:=_2_;
|
|
end;
|
|
inc(clknbr,(x and 3) shl 2)
|
|
end;
|
|
__ALG:begin
|
|
if (rdinx(GRC,$C) and $20)>0 then inc(clknbr,4);
|
|
(* if (rdinx(GRC,$B) and 2)>0 then divisor:=24;*)
|
|
if (rdinx(GRC,$1F) and $4)>0 then inc(clknbr,8);
|
|
divid:=rdinx(GRC,$B) and 3;
|
|
if cv.version=ALG_2101 then divisor:=RTGdiv[divid]
|
|
else divisor:=ALGdiv[divid];
|
|
end;
|
|
__Alli:if clknbr=3 then clknbr:=rgs.xxregs.x[$D8] and $F;
|
|
__ARK:begin
|
|
inc(clknbr,(rdinx(SEQ,$11) and $C0) shr 4);
|
|
end;
|
|
__ati:begin
|
|
if cv.version=ATI_18800 then
|
|
begin
|
|
if (rdinx(cv.IOadr,$B2) and $40)>0 then inc(clknbr,4);
|
|
end
|
|
else begin
|
|
if (rdinx(cv.IOadr,$B9) and 2)>0 then inc(clknbr,4);
|
|
if (rdinx(cv.IOadr,$BE) and $10)>0 then inc(clknbr,8);
|
|
end;
|
|
if cv.version<ATI_GUP_3 then x:=$C0 else x:=$40;
|
|
divid:=(rdinx(cv.IOadr,$B8) and x) shr 6;
|
|
divisor:=atidiv[divid];
|
|
end;
|
|
__chips:if cv.Version<CT_65520 then
|
|
begin
|
|
if clknbr=2 then clknbr:=(inp($3CA) and 3)+4;
|
|
end
|
|
else if cv.Version<CT_64300 then
|
|
begin
|
|
if (rdinx(cv.IOadr,$51) and 4)>0 then {Panel}
|
|
begin
|
|
clknbr:=(rdinx(cv.IOadr,$54) shr 2) and 3;
|
|
x :=(rdinx(cv.IOadr,$54) shr 4) and 3;
|
|
end
|
|
else {CRT}
|
|
x:=inp($3CA) and 3;
|
|
if clknbr>=2 then clknbr:=x+4;
|
|
end;
|
|
__Compaq:begin
|
|
clknbr:=(inp($3CC) shr 2) and 7;
|
|
if rdinx(GRC,$F)<>$A5 then inc(clknbr,8);
|
|
end;
|
|
__Genoa:if (rdinx(SEQ,7) and 1)>0 then inc(clknbr,4);
|
|
__HMC:inc(clknbr,(rdinx(SEQ,$E7) and $C0) shr 4);
|
|
__Mach32:begin
|
|
clknbr:=(inp($4AEE) shr 2) and $F;
|
|
if (inp($4AEE) and $40)>0 then divisor:=_2_;
|
|
end;
|
|
__Mach64:begin
|
|
clknbr:=inp($4AEC);
|
|
divid:=(clknbr shr 4) and 3;
|
|
case divid of
|
|
1:divisor:=_2_;
|
|
2:divisor:=_4_;
|
|
end;
|
|
clknbr:=clknbr and 15;
|
|
end;
|
|
__MXIC:if (rdinx(SEQ,$C4) and 1)>0 then inc(clkNbr,4);
|
|
__NCR:if cv.version=NCR_77c32BLT then
|
|
inc(ClkNbr,(rdinx(SEQ,$1F) and $60) shr 3)
|
|
else if (rdinx(SEQ,$1F) and $40)>0 then inc(ClkNbr,4);
|
|
__oak:begin
|
|
if (rdinx($3DE,$D) and $20)>0 then inc(clknbr,4);
|
|
if cv.Version>=OAK_083 then
|
|
begin
|
|
if (rdinx($3DE,6) and 8)>0 then inc(clknbr,8);
|
|
divisor:=otidiv[rdinx($3DE,$21) and 3];
|
|
{ if (rdinx($3DE,$14) and 1)>0 then divisor:=divisor*3; }
|
|
end;
|
|
end;
|
|
__p2000:begin
|
|
inc(clknbr,(rdinx(GRC,$14) and $30) shr 2);
|
|
divisor:=p2000div[(rdinx(GRC,$14) shr 2) and 3];
|
|
end;
|
|
__WD:begin
|
|
if (rdinx(GRC,$C) and 2)>0 then inc(clknbr,4);
|
|
if cv.version>WD_90c00 then
|
|
if (rdinx(SEQ,$12) and 4)>0 then inc(clknbr,8);
|
|
if cv.version=WD_90c24 then
|
|
clknbr:=(clknbr and 3)+(rgs.seqregs.x[$31] and $18) shr 1;
|
|
end;
|
|
__Realtek:begin
|
|
if (rdinx(GRC,$C) and $20)>0 then inc(clknbr,4);
|
|
divisor:=rtgdiv[rdinx(GRC,$B) and 3];
|
|
end;
|
|
__S3:if clknbr=3 then
|
|
begin
|
|
wrinx(crtc,$38,$48);
|
|
wrinx(crtc,$39,$A5);
|
|
clknbr:=rdinx(crtc,$42) and $F;
|
|
wrinx(crtc,$39,$5A);
|
|
wrinx(crtc,$38,$0);
|
|
end;
|
|
__SiS:if clknbr=3 then clknbr:=rdinx(SEQ,7) and $F;
|
|
__Tseng:if cv.version=ET_3000 then
|
|
begin
|
|
if (rdinx(crtc,$24) and 2)>0 then inc(clknbr,4);
|
|
{ if (rdinx(SEQ,7) and $40)>0 then divisor:=24; }
|
|
end
|
|
else begin
|
|
if (rdinx(crtc,$34) and 2)>0 then inc(clknbr,4);
|
|
inc(clknbr,(rdinx(crtc,$31) and $C0) shr 3);
|
|
case rdinx(SEQ,7) and $42 of
|
|
$40:divisor:=24;
|
|
$42:divisor:=48;
|
|
end;
|
|
end;
|
|
__Poach,
|
|
__Trid:begin
|
|
wrinx(SEQ,$B,0); {Old mode}
|
|
case cv.version of
|
|
TR_8900C,TR_9000C,TR_8900CL..TR_GUI9430:
|
|
if (rdinx(SEQ,$E) and $10)>0 then inc(clknbr,8);
|
|
end;
|
|
if rdinx(SEQ,$B)=0 then; {New mode}
|
|
if (rdinx(SEQ,$D) and 1)>0 then inc(clknbr,4);
|
|
if ((cv.version=TR_9000) or (cv.version=TR_9000i))
|
|
and ((rdinx(SEQ,$D) and $40)>0) then inc(clknbr,8);
|
|
divisor:=triddiv[(rdinx(SEQ,$D) shr 1) and 3];
|
|
end;
|
|
__UMC:begin
|
|
if (rdinx(SEQ,7) and 1)>0 then inc(clkNbr,4);
|
|
if (rdinx(SEQ,9) and $80)>0 then divisor:=24;
|
|
end;
|
|
__Video7:if cv.version>=V7_208A then
|
|
begin
|
|
clknbr:=(rdinx(SEQ,$A4) shr 2) and 7;
|
|
if (rdinx(SEQ,$F8) and 1)>0 then inc(clkNbr,8);
|
|
end;
|
|
end;
|
|
getclk:=clknbr;
|
|
end;
|
|
|
|
function getClockFreq:longint; {Effective pixel clock in kHz}
|
|
const
|
|
wd24clk:array[0..15] of longint=(29979,77408,0,80092,25175,28322
|
|
,65000,36000,39822,50114,42060,44297,31500,35501,75166,50114);
|
|
|
|
var clknbr,divisor,x,reg:word;
|
|
clk,ref:longint;
|
|
begin
|
|
clknbr:=getclk(divisor,x);
|
|
clk:=(cv.clks[clknbr]*12) div divisor;
|
|
ref:=(14318*12) div divisor;
|
|
case cv.clktype of
|
|
clk_unk:;
|
|
clk_ICD2061,clk_ICD2061A:
|
|
if (clknbr and 3)=3 then clk:=0; {Prog clock - Can't read}
|
|
clk_sdac:(*if clknbr=2 then*)
|
|
begin
|
|
clknbr:=(clknbr and 3)*2;
|
|
clk:=(ref*((rgs.dacinxd.x[clknbr] and 127)+2))
|
|
div (((rgs.dacinxd.x[clknbr+1] and 31)+2) shl (rgs.dacinxd.x[clknbr+1] shr 5));
|
|
end;
|
|
clk_STG:begin
|
|
clknbr:=clknbr*2+$20;
|
|
clk:=ref*(rgs.dacinxd.x[clknbr]+2) div
|
|
(((rgs.dacinxd.x[clknbr+1] and $1F)+2)
|
|
shl (rgs.dacinxd.x[clknbr+1] shr 5));
|
|
end;
|
|
clk_TVP302x:case clknbr and 3 of
|
|
0:clk:=(25175*12) div divisor;
|
|
1:clk:=(28322*12) div divisor;
|
|
2,3:clk:=(ref*8*((rgs.dacinxd.x[$41] and 127)+2)) div
|
|
(((rgs.dacinxd.x[$40] and 31)+2) shl (rgs.dacinxd.x[$42] and 3));
|
|
end;
|
|
clk_CHRON:begin
|
|
clknbr:=(clknbr and 15)*2;
|
|
clk:=(ref*(rgs.dacinxd.x[clknbr]+8)) div ((((rgs.dacinxd.x[clknbr+1]
|
|
and 63)+2) shl (rgs.dacinxd.x[clknbr+1] shr 6)));
|
|
end;
|
|
clk_MUSIC:begin
|
|
clknbr:=(clknbr and 7)*2;
|
|
clk:=(ref*((rgs.dacinxd.x[clknbr] and 127)+1)) div
|
|
((((rgs.dacinxd.x[clknbr+1] and 15)+1) shl
|
|
((rgs.dacinxd.x[clknbr+1] shr 4) and 3)));
|
|
end;
|
|
clk_IBM52x:if (rgs.dacinxd.x[$10] and 1)>0 then
|
|
begin
|
|
clknbr:=((clknbr and 7)*2)+$20;
|
|
clk:=(ref*((rgs.dacinxd.x[clknbr] and 63)+65)) div
|
|
((rgs.dacinxd.x[clknbr+1] and $1F) shl
|
|
(3-(rgs.dacinxd.x[clknbr] shr 6)));
|
|
end
|
|
else begin
|
|
(* clknbr:=(clknbr and 15)+$20;
|
|
clk:=(ref*((rgs.dacinxd.x[clknbr] and 63)+65)) div
|
|
((rgs.dacinxd.x[$14] and $1F) shl
|
|
(3-(rgs.dacinxd.x[clknbr] shr 6))); *)
|
|
end;
|
|
else
|
|
case cv.chip of
|
|
__Cir54:if (clknbr=0) and (cv.version<=CL_GD5402) then clk:=25175
|
|
else begin
|
|
clk:=(ref*rgs.seqregs.x[$B+clknbr]) div (rgs.seqregs.x[$1B+clknbr] shr 1);
|
|
if (rgs.seqregs.x[$1B+clknbr] and 1)>0 then clk:=clk div 2;
|
|
case (rgs.seqregs.x[7] and 6) of
|
|
2:clk:=clk div 2;
|
|
4:clk:=clk div 3;
|
|
end;
|
|
end;
|
|
__chips:if (cv.version=CT_64300) and (clknbr>=2) then
|
|
clk:=(ref*2*(rgs.xxregs.x[$31]+2)) div (rgs.xxregs.x[$32]+2);
|
|
__S3:if (cv.Version=S3_732) or (cv.Version=S3_764) then
|
|
case clknbr of
|
|
0:clk:=(25175*12) div divisor;
|
|
1:clk:=(28322*12) div divisor;
|
|
else
|
|
clk:=(ref*((rgs.seqregs.x[$13] and $7F)+2)) div
|
|
(((rgs.seqregs.x[$12] and $1F)+2) shl (rgs.seqregs.x[$12] shr 5));
|
|
end;
|
|
__Trid:if cv.version=TR_GUI9440 then {Not there yet}
|
|
case clknbr and 3 of
|
|
0:clk:=(25175*12) div divisor;
|
|
1:clk:=(28322*12) div divisor;
|
|
2:begin
|
|
clknbr:=(((rgs.dacregs[9] shl 1)+(rgs.dacregs[8] shr 7)) and $1F)+1;
|
|
clk:=((ref*((rgs.dacregs[8] and $7F)+3)) div
|
|
(clknbr shl (rgs.dacregs[9] shr 4)));
|
|
end;
|
|
end;
|
|
__WD:if cv.version=WD_90c24 then
|
|
begin {WD90c24 internal clock}
|
|
if clknbr<>2 then clk:=WD24clk[clknbr]
|
|
else clk:=(rgs.seqregs.x[$32]*longint(447443)) div 1000;
|
|
end;
|
|
end;
|
|
end;
|
|
getClockFreq:=clk;
|
|
end;
|
|
|