Category : C Source Code
Archive   : FRAC151S.ZIP
Filename : TGASUBS.C

 
Output of file : TGASUBS.C contained in archive : FRAC151S.ZIP

/* tsubs.c */

#define TARGA_DATA

#include "targa.h"

/*******************************************************************/

void
VCenterDisplay( nLines )
int nLines;
{
int lines;
int top, bottom;
long color;

lines = nLines >> 1; /* half value of last line 0..x */
top = 140 - (lines >> 1);
bottom = top + lines;
SetVBorder( top, bottom );
SetVertShift( 255 - lines ); /* skip lines we're not using */

if( targa->boardType == 16 )
color = (12 << 10) | (12 << 5) | 12;
else
color = (80 << 16) | (80 << 8) | 80;
SetBorderColor( (long *)&color );
}


/*****************************************************************/

void
SetDispReg(reg, value)
int reg, value;
{
targa->DisplayRegister[reg] = value;

TSetMode(targa->mode&MSK_REGWRITE); /* select Index Register write */
OUTPORTB(DRREG, reg); /* select sync register */
/*
* Set Mask register to write value to
* display register and to set Bit 9 in the DR
*/
TSetMode( ((targa->mode|(~MSK_REGWRITE)) /* turn on write bit */
& MSK_BIT9 ) /* turn off Bit 9 */
| (value&0x0100)>>1); /* set bit 9 for value */
OUTPORTB(DRREG, value); /* select sync register */
return;
}

/*****************************************************************/

#define WAITCOUNT 20000

int
VWait()
{
int rasterreg, GiveUp;

rasterreg = RASTERREG;

GiveUp= WAITCOUNT;
/*
* If beyond bottom of frame wait for next field
*/
if ( GetLine(rasterreg) == 0 ) {
while ( (GiveUp>0) && (GetLine(rasterreg)==0) ) GiveUp--;
}
/*
* Wait for the bottom of the border
*/
while ( (GiveUp>0) && (GetLine(rasterreg) >0) ) GiveUp--;

if ( GiveUp > 0 ) return(0);
else return(-1);
}


/*****************************************************************/

void
SetVBorder(top, bottom)
int top, bottom;
{
/* top border */
if ( top < MIN_TOP ) top=MIN_TOP;
SetDispReg(TOPBORDER,top);
/* bottom border */
if ( bottom > MAX_BOTTOM ) bottom=MAX_BOTTOM;
SetDispReg(BOTTOMBORDER,bottom);

SetDispReg(DR10,top);
SetDispReg(DR11,bottom);
}


/*****************************************************************/

void
SetRGBorCV(type)
int type;
{
/* set the contrast level */
targa->RGBorCV = type;
targa->VCRCon = ( targa->VCRCon & MSK_RGBORCV ) |
(targa->RGBorCV< OUTPORTB(VCRCON, targa->VCRCon );
return;
}

/*****************************************************************/

void
SetVCRorCamera(type)
int type;
{
targa->VCRorCamera = type&1;
targa->VCRCon = ( targa->VCRCon & MSK_VCRORCAMERA ) |
(targa->VCRorCamera< OUTPORTB(VCRCON, targa->VCRCon );

}


/*****************************************************************/

void
SetBorderColor(color)
long *color;
{
targa->BorderColor = *color;
OUTPORTB(BORDER, (int)(0x0000ffffL&(*color)));
OUTPORTB((BORDER+2), (int)(*(color)>>16));

return;
}

/*****************************************************************/

void
SetMask(mask)
int mask;
{
/* mask to valid values and output to mode register */
targa->Mask = mask;
OUTPORTB(MASKREG, mask);
return;
}


/*****************************************************************/

void
SetVertShift(preshift)
int preshift;
{
/* set the Vertical Preshift count level */
targa->VertShift = preshift;
OUTPORTB(VERTPAN, preshift);
return;
}


/*****************************************************************/

static long black =0L;

void
SetOverscan(mode)
int mode;
{
int temp;
long tempColor;

targa->ovrscnOn = mode;
if ( mode == 0 ) {
INPORTB(UNDERREG); /* select underscan mode */
SetHBorder( (DEF_LEFT+targa->xOffset),
(DEF_RIGHT+targa->xOffset));
SetDispReg(4,352);
SetDispReg(5,1);
SetBorderColor(&targa->BorderColor);
}
else {
INPORTB(OVERREG); /* select overrscan mode */
SetDispReg(0,64); /* Set four of the display registers */
SetDispReg(1,363); /* to values required for Overscan */
SetDispReg(4,363);
SetDispReg(5,17);
tempColor = targa->BorderColor;
SetBorderColor(&black);
targa->BorderColor = tempColor;
}
}


/*****************************************************************/

void
SetInterlace(type)
int type;
{
int pageMode;

pageMode= GetPageMode();
targa->InterlaceMode= type & MSK_INTERLACE;
SetDispReg(INTREG, targa->InterlaceMode);
/*
* SET THE INTERLACE BIT TO MATCH THE INTERLACE MODE AND
* SCREEN RESOLUTION - SCREEN PAGE
*/
if ( ( targa->InterlaceMode >= 2 ) &&
( pageMode> 1 ) &&
( (pageMode&1) != 0 ) ) TSetMode(targa->mode|(~MSK_IBIT) );
else TSetMode(targa->mode& MSK_IBIT);
return;
}


/*****************************************************************/

void
SetBlndReg(value)
int value;
{
/* set the Vertical Preshift count level */
if ( targa->boardType == 32 ) {
targa->VCRCon = (targa->VCRCon&0xfe) | value;
OUTPORTB(BLNDREG, value);
}
return;
}


/*****************************************************************/

void
TSetMode(mode)
int mode; /* Mode Register Value */
{
/* mask to valid values and output to mode register */
OUTPORTB(MODEREG, mode );
targa->mode = mode;
}


/*****************************************************************/

void
SetContrast(level)
int level;
{
/* set the contrast level */
targa->Contrast = level &((~MSK_CONTRAST)>>SHF_CONTRAST);
targa->VCRCon = ( targa->VCRCon & MSK_CONTRAST ) |
(targa->Contrast< OUTPORTB(VCRCON, targa->VCRCon );
return;
}


/*****************************************************************/

void
SetHue(level)
int level;
{
/* set the hue level - Mask to valid value */
targa->Hue = level&((~MSK_HUE)>>SHF_HUE);
/* mask to valid range */
targa->SatHue = (targa->SatHue&MSK_HUE) |
(targa->Hue< OUTPORTB(SATHUE, targa->SatHue );
return;
}


/*****************************************************************/

void
SetSaturation(level)
int level;
{
/* set the saturation level */

targa->Saturation= level&( (~MSK_SATURATION)>>SHF_SATURATION);
targa->SatHue = (targa->SatHue&MSK_SATURATION) |
(targa->Saturation< OUTPORTB(SATHUE , targa->SatHue );
return;
}


/*****************************************************************/

int
GetPageMode()
{
return(targa->PageMode);
}


/*************************************************************/

void
SetPageMode(pageMode)
int pageMode;
{

pageMode &= 0x07;
targa->PageMode = pageMode;
VWait();
TSetMode( (targa->mode)&(MSK_RES) |((pageMode< if ( ( targa->DisplayRegister[20] >= 2 ) &&
( pageMode> 1 ) &&
( (pageMode&1) != 0 ) ) TSetMode(targa->mode|(~MSK_IBIT) );
else
TSetMode(targa->mode& MSK_IBIT);
return;
}


/*****************************************************************/

void
SetHBorder(left, right)
int left, right; /* left & right border positions */
{
SetDispReg(LEFTBORDER, left); /* set horizontal left border */
SetDispReg(RIGHTBORDER,right); /* set horizontal right border */
/*
* Set DR 8 and 9 since they
* default to tracking DR0 and DR 1
*/
SetDispReg(DR8,left);
SetDispReg(DR9,left);

return;
}


/*****************************************************************/

void
SetGenlock(OnOrOff)
int OnOrOff;
{
TSetMode( (targa->mode)&(MSK_GENLOCK)
|((OnOrOff< }


/*****************************************************************/
/* was asm, TC fast enough on AT */

int
GetLine( port )
int port;
{
int cnt;
int val1, val2;

val1 = INPORTB( port );
for( cnt = 0; cnt < 20; cnt++ ) {
val2 = INPORTB( port );
if( val1 == val2 )
break;
val1 = val2;
}
return( val1 );
}

/**********************************************************************
TFIND
**********************************************************************/

/*****************************************************************
FindTarga : seek and find the first targa

Usage:
int ret=0;
ret = FindTarga(type, ioBase, memLoc)
int *type; targa type (8, 16, 24, 32)
int *ioBase; io base location
int *memLoc; memory base location

ret = 0 if no targa is found or the TARGA is an invalid type
and the arguments are not changed
*****************************************************************/

#define IOPOSSIBLE 16
#define MEMPOSSIBLE 8

static unsigned ioPossible[] = {
0x220, 0x230, 0x200, 0x210, 0x240,
0x250, 0x260, 0x270, 0x220, 0x290,
0x2a0, 0x2b0, 0x2c0, 0x2d0, 0x2e0,
0x2f0
};

static unsigned memPossible[] = {
0xa000, 0xd000, 0x8000, 0x9000,
0xc000, 0xe000, 0xf000, 0xb000
};


int
FindTarga(type, ioBase, memLoc)
int *type; /* targa type (8, 16, 24, 32) */
int *ioBase; /* io base location */
int *memLoc; /* memory base location */
{
int i;
int j;

int huntType; /* type we hunt for */
int targaFound;
int firstFound;
int tmpMemLoc;
int tmpIoBase;
int tmpType;
int possMemLoc;
int possIoBase;
int possType;

/*
* Find its I/O Space by searching for raster counter.
*
* Look for the finger print of an I/O port register that
* cycles between 0 and 242 and its companion which is always
* flipping between 0 and 1
*/

targaFound = FALSE;
firstFound = TRUE;
huntType = *type;

targaFound = FALSE;
for(i = 0; i < IOPOSSIBLE; i++){ /* look for matching type */
if(CheckRCounter(ioPossible[i]) == 0){
continue;
}
else{
possIoBase = ioPossible[i];
}

/*
* find the memory address
*
* Look for a memory segment that responds
* to the memory segment.
*/

for(j = 0; (j < MEMPOSSIBLE) &&
(CheckMemLoc(possIoBase, memPossible[j]) == 0); j++);
if(j == MEMPOSSIBLE){
continue;
}
else{
possMemLoc = memPossible[j];
}

/*
* See if this is a TARGA 8, M8, 16, 24, 32
*/
if ( (possType = FindBoardType(possIoBase, possMemLoc))== -1 )
continue;

targaFound = TRUE;

if(firstFound){
tmpMemLoc = possMemLoc;
tmpIoBase = possIoBase;
tmpType = possType;
firstFound = FALSE;
}

if((possType == huntType) && targaFound) {
*memLoc = possMemLoc;
*ioBase = possIoBase;
*type = possType;
return(1);
}
}

if(targaFound) {
if(possType != huntType){
*memLoc = tmpMemLoc;
*ioBase = tmpIoBase;
*type = tmpType;
}
}

if(targaFound)
return(1);
else
return(0);
}


/*****************************************************************
CheckRCounter -- See if raster counter at this base IO address

usage: ret = CheckRCounter(ioBase)
unsigned ioBase;

ret == 0 if not at this address
1 if fingerprint found

*****************************************************************/

#define LINES 1000 /* Pulled out of the air */

#define CHANGES 20 /* This is the number of valid changes */

int
CheckRCounter(ioBase)
unsigned ioBase;
{
int i; /* array index */
int changes; /* number of valid transitions */
int new; /* temporary variable */
int old; /* last valid raster value */
int rasterReg; /* value of the raster Register */

old = 0; /* insure that we don't blow out when starting */
changes = 0; /* zero change counter */
rasterReg = ioBase + (signed)0xC00 ; /* add offset to I/O base */

/*
* Read LINES raster values and check if each is valid wrt
* previous value. Quit and return 0 if invalid
*/

for (i=0; i if ((new = INPORTB(rasterReg)) > old ){
if(new > 243){ return(0);} /* return if illegal */
old = new;
changes++;
}
else if(new != old){ /* if new is less than old */
if(new != 0) {
/* This is only valid if new == 0 */
return(0);
}
/* quit otherwise */
old = 0;
changes++;
}
}
if(changes > CHANGES)
return(1);
else
return(0);
}


/*****************************************************************

CheckMemLoc -- See if specified Memory Segment is associated with
the specified IO space

usage: ret = CheckMemLoc(ioBase,memAddr)

ret = 0 if not valid memory
1 i valid memory/IO pair
*****************************************************************/

CheckMemLoc(ioBase,memAddr)
unsigned ioBase; /* previously determine ioSpace */
unsigned memAddr; /* proposed memory segment */
{
int modeReg, maskReg;
int saveValue, temp;
int loop;

modeReg = ioBase + (signed)0xC00;
maskReg = ioBase + (signed)0x800;
OUTPORTB(modeReg, (signed)0x01); /* Select display memory */
OUTPORTW(maskReg, (signed)0x0000); /* clear the mask for valid read */

PEEK(0, memAddr, &saveValue, 2 );

/* loop and see if this is real or just junk on the bus
* assume open bus if junk
*/


for(loop = 0; loop<20; loop++){

PEEK(0, memAddr, &temp, 2 );
if(saveValue != temp){
OUTPORTB(modeReg, 0); /* Deselect display memory */
return(0);
}
}

/*
* if savevalue is -1 then we can't check using mask w/o
* first writing out new value
*/

if(saveValue == (signed)0xFFFF){
disable();

temp=0;
POKE(0, memAddr, &temp,2);

/* If write did not work , enable ints, and fail */

PEEK(0, memAddr, &temp, 2 );
if( temp != 0){
enable();
OUTPORTB(modeReg, 0); /* Deselect display memory */
return(0);
}
}

/* set mask and see if it returns 0xffff */

temp = (signed)0xffff;
OUTPORTW(maskReg, temp);

PEEK(0, memAddr, &temp, 2 );
if(temp == (signed)0xFFFF) loop=1;
else loop=0;

OUTPORTW(maskReg,0);

if(saveValue == (signed)0xFFFF){
POKE(0, memAddr, &saveValue, 2);
enable();
}

OUTPORTB(modeReg, 0); /* Deselect display memory */
return(loop);
}


/*****************************************************************
FindBoardType - find out what type o board is assoicated with
the TARGA located at a specied IO amd memory
space

Usage: ret = FindBoardType(ioBase,memAddr);

unsigned ioBase; TARGA's base io address
unsigned memAddr; TARGA's memory space

ret = 8 , 16, 24, 32 ---- Targa type
-1 Unknown or invalid board
********************************************************************/

FindBoardType(ioBase,memAddr)
unsigned ioBase;
unsigned memAddr;
{
int modeReg, maskReg;
int saveVal1, saveVal2;
int test1, test2;
int type, temp;


modeReg = ioBase + (signed)0xC00;
maskReg = ioBase + (signed)0x800;
OUTPORTB(modeReg, 0x01); /* Select display memory */
OUTPORTW(maskReg, 0x0000); /* clear the mask for valid read */

PEEK(0, memAddr, &saveVal1, 2 );
PEEK(2, memAddr, &saveVal2, 2 );

/* write ff's to the first four bytes */

temp =(signed)0xffff;
POKE(0, memAddr, &temp, 2);
POKE(2, memAddr, &temp, 2);

OUTPORTW(maskReg, (signed)0x7FFe); /* set write to known pattern */
temp =0;
POKE(0, memAddr, &temp, 2); /* and determine is 8, 16, 24, or 32 */
POKE(2, memAddr, &temp, 2); /* from pattern read */

OUTPORTW(maskReg, 0);
PEEK(0, memAddr, &test1, 2 );

type = -1;
if(test1 == (signed)0x7ffe) type = TYPE_16;
if(test1 == (signed)0xfffc){
PEEK(2, memAddr, &test2, 2 );
if(test2 == (signed)0x7fff) type = TYPE_32;
if(test2 == (signed)0xffff) type = TYPE_24;
}

OUTPORTW(maskReg, 0x0000); /* clear the mask for valid read */
POKE(0, memAddr, &saveVal1, 2);
POKE(2, memAddr, &saveVal2, 2);
OUTPORTB(modeReg, 0); /* Deselect display memory */
return(type);
}

/**********************************************************************
TINIT
**********************************************************************/

GraphInit( board )
int board;
{
int cnt;
int bottom, top;
int mode, tBoard;

board = board;

memset( &tstructure, 0, sizeof(tstructure) );
targa = &tstructure;

targa->boardType = -1; /* assume the resident board */

targa->xOffset = 0; targa->yOffset = 0; /* default to no offset */
targa->LinesPerField= DEF_ROWS/2; /* number of lines per field */
targa->AlwaysGenLock = DEF_GENLOCK; /* default to genlock off */
targa->PageMode = 0;
targa->InterlaceMode = DEF_INT; /* Defalut: Interlace Mode 0 */
targa->Contrast= DEF_CONTRAST;
targa->Saturation = DEF_SATURATION;
targa->Hue = DEF_HUE;
targa->RGBorCV = CV; /* default to Composite video */
targa->VCRorCamera = CAMERA;
targa->PanXOrig = 0; targa->PanYOrig=0;
targa->PageUpper= 0xffff; /* set the bank flags to illega& values */
targa->PageLower= 0xffff; /* so that they will be set the first time */
targa->ovrscnAvail = 0; /* Assume no Overscan option */
targa->ovrscnOn = 0;
targa->iobase = TIOBASE;
targa->memloc = TSEG;

targa->boardType = TYPE_16; /* default to looking for a 16 */
for( cnt = 0; ;cnt++ ) {
if( FindTarga(&targa->boardType, &targa->iobase, &targa->memloc) )
break; /* if multiple, first card only */
else if( cnt == 5 )
return( -1 ); /* not found */
}

if ( targa->boardType == TYPE_16 ) {
targa->MaxBanks = 16;
targa->BytesPerPixel = 2;
}
if ( targa->boardType == TYPE_24 ) {
targa->MaxBanks = 32;
targa->BytesPerPixel = 3;
}
if ( targa->boardType == TYPE_32 ) {
targa->MaxBanks = 32;
targa->BytesPerPixel = 4;
}

/****** Compute # of rows per 32K bank ********/
targa->RowsPerBank = 512/(targa->MaxBanks);
targa->AddressShift = targa->MaxBanks>>4;

/* if initializing CVA: set these before we quit */
SetSaturation(targa->Saturation);
SetHue(targa->Hue);
SetContrast( targa->Contrast);

/* Set Genlock bit if always genlocked */
/* Set before flipping and jerking screen */
TSetMode( (targa->AlwaysGenLock<
SetBlndReg(0); /* disable blend mode on TARGA 32 */

SetInterlace(targa->InterlaceMode);
SetFixedRegisters();
SetOverscan( 0 );

top = 140 - (targa->LinesPerField / 2);
bottom = top + targa->LinesPerField;
SetVBorder(top,bottom);
SetVertShift(256-targa->LinesPerField);

SetMask(DEF_MASK);
SetRGBorCV (targa->RGBorCV );
SetVCRorCamera(targa->VCRorCamera);

/* See if the raster register is working correctly and
return error flag if its not */
if ( VWait() == -1)
return(-1);
else
return(0);
}


/**************************************************************/
void
GraphEnd()
{
TSetMode( (targa->mode)&MSK_MSEL ); /* disable memory */
return;
}


/**************************************************************/
/* Set the registers which have required values */

#define FIXED_REGS 10

static int FixedRegs[] = {
DR6,DR7,DR12,DR13,DR14,DR15,DR16,DR17,DR18,DR19
};

static int FixedValue[] = {
DEF_DR6,DEF_DR7,DEF_DR12,DEF_DR13,DEF_DR14,
DEF_DR15,DEF_DR16,DEF_DR17,DEF_DR18,DEF_DR19
};

SetFixedRegisters()
{
int reg;

for ( reg=0; reg SetDispReg(FixedRegs[reg],FixedValue[reg]);
return(0);
}