home *** CD-ROM | disk | FTP | other *** search
/ Mega A/V / mega_av.zip / mega_av / GRAPHUTL / FRASR172.ZIP / TARGA.C < prev    next >
C/C++ Source or Header  |  1991-12-03  |  20KB  |  772 lines
  1. /** targa.c **/
  2.  
  3. #ifdef __TURBOC__
  4. #    pragma    warn -par
  5. #endif
  6.  
  7. #define TARGA_DATA
  8.  
  9. #include    <stdio.h>
  10. #include    <stdlib.h>
  11. #include    "targa.h"
  12. #include    "fractint.h"
  13.  
  14.  
  15. /*************    ****************/
  16.  
  17. extern void    helptitle();
  18. extern char far *mapdacbox;
  19.  
  20. /*************    ****************/
  21.  
  22. void    WriteTGA( int x, int y, int index );
  23. int    ReadTGA ( int x, int y );
  24. void    EndTGA    ( void );
  25. void    StartTGA( void );
  26. void    ReopenTGA( void );
  27.  
  28. /*************    ****************/
  29.  
  30. static unsigned _fastcall near Row16Calculate(unsigned,unsigned);
  31. static void    _fastcall near PutPix16(int,int,int);
  32. static unsigned _fastcall near GetPix16(int,int);
  33. static unsigned _fastcall near Row32Calculate(unsigned,unsigned);
  34. static void    _fastcall near PutPix32(int,int,int);
  35. static unsigned _fastcall near GetPix32(int,int);
  36. static void    _fastcall near DoFirstPixel(int,int,int);
  37. static void _fastcall fatalerror(char far *);
  38. static int  GetLine(int);
  39. static void _fastcall near SetDispReg(int,int);
  40. static int  VWait(void);
  41. static void _fastcall SetVBorder(int,int);
  42. static void _fastcall SetBorderColor(long);
  43. static void _fastcall SetVertShift(int);
  44. static void _fastcall SetInterlace(int);
  45. static void _fastcall SetBlndReg(int);
  46. static void _fastcall SetRGBorCV(int);
  47. static void _fastcall SetVCRorCamera(int);
  48. static void _fastcall SetMask(int);
  49. static void _fastcall SetBlndReg(int);
  50. static void _fastcall SetContrast(int);
  51. static void _fastcall SetHue(int);
  52. static void _fastcall SetSaturation(int);
  53. static void _fastcall SetHBorder(int,int);
  54. static void SetFixedRegisters(void);
  55. static void _fastcall VCenterDisplay(int);
  56. static void _fastcall SetOverscan(int);
  57. static void _fastcall near TSetMode(int);
  58. static int  GraphInit(void);
  59. static void GraphEnd(void);
  60.  
  61. /*************    ****************/
  62.  
  63. int         xorTARGA;
  64. unsigned far *tga16 = NULL;  /* [256] */
  65. long     far *tga32;         /* [256] */
  66. static int   last = 0;
  67.  
  68. /*************    ****************/
  69.  
  70. extern int    sxdots,sydots;        /* # of dots on the physical screen */
  71. static int    initialized;
  72.  
  73. /*************    ****************/
  74.  
  75. static void    (near _fastcall *DoPixel) ( int x, int y, int index );
  76. static void    (near _fastcall *PutPixel)( int x, int y, int index );
  77. static unsigned (near _fastcall *GetPixel)( int x, int y );
  78.  
  79. /**************************************************************************/
  80. #ifdef __BORLANDC__
  81. #if(__BORLANDC__ > 2)
  82.    #pragma warn -eff
  83. #endif
  84. #endif
  85.  
  86. static unsigned _fastcall near Row16Calculate( unsigned line, unsigned x1 )
  87. {
  88.     outp( DESTREG, (line >> 5) );
  89.     return( ((line & 31) << 10) | (x1 << 1) ); /* calc the pixel offset */
  90. }
  91.  
  92. /**************************************************************************/
  93.  
  94. static void _fastcall near PutPix16( int x, int y, int index )
  95. {
  96. unsigned far * ip;
  97.  
  98.     /**************/
  99.     ip = MK_FP( MEMSEG, Row16Calculate( y, x ) );
  100.     if( ! xorTARGA )
  101.         *ip = tga16[index];
  102.     else
  103.         *ip = *ip ^ 0x7fff;
  104. }
  105.  
  106. /**************************************************************************/
  107.  
  108. static unsigned _fastcall near GetPix16( int x, int y )
  109. {
  110. register unsigned pixel, index;
  111. unsigned far * ip;
  112.     /**************/
  113.     ip = MK_FP( MEMSEG, Row16Calculate( y, x ) );
  114.     pixel = *ip & 0x7FFF;
  115.     if( pixel == tga16[last] ) return( last );
  116.     for( index = 0; index < 256; index++ )
  117.         if( pixel == tga16[index] ) {
  118.             last = index;
  119.             return( index );
  120.         }
  121.     return( 0 );
  122. }
  123.  
  124. /**************************************************************************/
  125.  
  126. static unsigned _fastcall near Row32Calculate( unsigned line, unsigned x1 )
  127. {
  128.     outp( DESTREG, (line >> 4) );
  129.     return ( ((line & 15) << 11) | (x1 << 2) ); /* calc the pixel offset */
  130. }
  131.  
  132. /**************************************************************************/
  133.  
  134. static void _fastcall near PutPix32( int x, int y, int index )
  135. {
  136. long far * lp;
  137.     lp = MK_FP( MEMSEG, Row32Calculate( y, x ) );
  138.     if( ! xorTARGA )
  139.         *lp = tga32[index];
  140.     else
  141.         *lp = *lp ^ 0x00FFFFFF;
  142. }
  143.  
  144. /**************************************************************************/
  145.  
  146. static unsigned _fastcall near GetPix32( int x, int y )
  147. {
  148. register int index;
  149. long    pixel;
  150. long    far * lp;
  151.  
  152.     lp = MK_FP( MEMSEG, Row32Calculate( y, x ) );
  153.     pixel = *lp & 0x00FFFFFF;
  154.     if( pixel == tga32[last] ) return( last );
  155.     for( index = 0; index < 256; index++ )
  156.         if( pixel == tga32[index] ) {
  157.             last = index;
  158.             return( index );
  159.         }
  160.     return( 0 );
  161. }
  162.  
  163. /**************************************************************************/
  164.  
  165. static void _fastcall near DoFirstPixel( int x, int y, int index )
  166. {
  167. int cnt;
  168.     TSetMode( targa.mode | 1 );
  169.     for( cnt = 0; cnt < targa.MaxBanks; cnt += 2 ) { /* erase */
  170.         outp( DESTREG, cnt );
  171.         outp( SRCREG,  cnt + 1 );
  172.         erasesegment(targa.memloc,0);  /** general.asm **/
  173.     }
  174.     TSetMode( targa.mode & 0xFFFE );
  175.     PutPixel = DoPixel;
  176.     (*PutPixel)( x, y, index );
  177. }
  178.  
  179. #ifdef __BORLANDC__
  180. #if(__BORLANDC__ > 2)
  181.    #pragma warn +eff
  182. #endif
  183. #endif
  184.  
  185. /***************************************************************************/
  186.  
  187. void WriteTGA( int x, int y, int index )
  188. {
  189.     OUTPORTB(MODEREG, targa.mode |= 1 );    /* TSetMode inline for speed */
  190.     (*PutPixel)( x, sydots-y, index&0xFF ); /* fix origin to match EGA/VGA */
  191.     OUTPORTB(MODEREG, targa.mode &= 0xFFFE );
  192. }
  193.  
  194. /***************************************************************************/
  195.  
  196. int ReadTGA( int x, int y )
  197. {
  198. int val;
  199.     OUTPORTB(MODEREG, targa.mode |= 1 );    /* TSetMode inline for speed */
  200.     val = (*GetPixel)( x, sydots-y );
  201.     OUTPORTB(MODEREG, targa.mode &= 0xFFFE );
  202.     return( val );
  203. }
  204.  
  205. /***************************************************************************/
  206.  
  207. void EndTGA( void )
  208. {
  209.     if( initialized ) {
  210.         GraphEnd();
  211.         initialized = 0;
  212.     }
  213. }
  214.  
  215. /***************************************************************************/
  216.  
  217. void StartTGA()
  218. {
  219. int    i;
  220. static char far couldntfind[]={"Could not find Targa card"};
  221. static char far noenvvar[]={"TARGA enviroment variable missing"};
  222. static char far insuffmem[]={"Insufficient memory for Targa"};
  223.  
  224.     /****************/
  225.     if( initialized ) return;
  226.     initialized = 1;
  227.  
  228.     /****************/
  229.     /* note that video.asm has already set the regualar video adapter */
  230.     /* to text mode (ax in Targa table entries is 3);          */
  231.     /* that's necessary because TARGA can live at 0xA000, we DO NOT   */
  232.     /* want to have an EGA/VGA in graphics mode!!              */
  233.     ReopenTGA(); /* clear text screen and display message */
  234.  
  235.     /****************/
  236.     /*** look for and activate card ***/
  237.     if ((i = GraphInit()))
  238.         fatalerror((i == -1) ? couldntfind : noenvvar);
  239.  
  240.     VCenterDisplay( sydots + 1 );
  241.  
  242.     if (tga16 == NULL)
  243.         if ( (tga16 = (unsigned far *)farmemalloc(512L)) == NULL
  244.           || (tga32 = (long     far *)farmemalloc(1024L)) == NULL)
  245.         fatalerror(insuffmem);
  246.  
  247.     SetTgaColors();
  248.  
  249.     if( targa.boardType == 16 ) {
  250.         GetPixel = GetPix16;
  251.         DoPixel = PutPix16;
  252.     }
  253.     else {
  254.         GetPixel = GetPix32;
  255.         DoPixel = PutPix32;
  256.     }
  257.     PutPixel = DoFirstPixel;    /* on first pixel --> erase */
  258.  
  259.     if( sydots == 482 ) SetOverscan( 1 );
  260.  
  261.     TSetMode( targa.mode & 0xFFFE );
  262.  
  263.     /****************/
  264.     if (mapdacbox == NULL && SetColorPaletteName("default") != 0)
  265.         exit( 1 ); /* stopmsg has already been issued */
  266.  
  267. }
  268.  
  269. void ReopenTGA()
  270. {
  271. static char far runningontarga[]={"Running On TrueVision TARGA Card"};
  272.     helptitle();
  273.     putstring(2,20,7,runningontarga);
  274.     movecursor(6,0); /* in case of brutal exit */
  275. }
  276.  
  277. static void _fastcall fatalerror(char far *msg)
  278. {
  279. static char far abortmsg[]={"...aborting!"};
  280.     putstring(4,20,15,msg);
  281.     putstring(5,20,15,abortmsg);
  282.     movecursor(8,0);
  283.     exit(1);
  284. }
  285.  
  286.  
  287.  
  288. /***  the rest of this module used to be separate, in tgasubs.c,  ***/
  289. /***  has now been merged into a single source              ***/
  290.  
  291. /*******************************************************************/
  292.  
  293. static void _fastcall VCenterDisplay( int nLines )
  294. {
  295. int    lines;
  296. int top, bottom;
  297. long color;
  298.  
  299.     lines  = nLines >> 1;        /* half value of last line 0..x */
  300.     top    = 140 - (lines >> 1);
  301.     bottom = top + lines;
  302.     SetVBorder( top, bottom );
  303.     SetVertShift( 255 - lines );    /* skip lines we're not using */
  304.  
  305.     if( targa.boardType == 16 )
  306.         color = (12 << 10) | (12 << 5) | 12;
  307.     else
  308.         color = (80 << 16) | (80 << 8) | 80;
  309.     SetBorderColor( color );
  310. }
  311.  
  312.  
  313. /*****************************************************************/
  314.  
  315. static void _fastcall near SetDispReg(int reg, int value)
  316. {
  317.     targa.DisplayRegister[reg] = value;
  318.  
  319.     TSetMode(targa.mode&MSK_REGWRITE);  /* select Index Register write */
  320.     OUTPORTB(DRREG, reg);    /* select sync register */
  321.     /*
  322.      *        Set Mask register to write value to
  323.      *        display register and to set Bit 9 in the DR
  324.      */
  325.     TSetMode( ((targa.mode|(~MSK_REGWRITE))     /* turn on write bit */
  326.                    & MSK_BIT9       )     /* turn off Bit 9 */
  327.                | ((value&0x0100)>>1)); /* set bit 9 for value */
  328.     OUTPORTB(DRREG, value); /* select sync register */
  329.  }
  330.  
  331. /*****************************************************************/
  332.  
  333. #define   WAITCOUNT  60000
  334.  
  335. static int VWait()
  336. {
  337. int    rasterreg;
  338. unsigned GiveUp;
  339.  
  340.     rasterreg = RASTERREG;
  341.  
  342.     /*
  343.      *    If beyond bottom of frame wait for next field
  344.      */
  345.     GiveUp= WAITCOUNT;
  346.     while ( (--GiveUp) && (GetLine(rasterreg) == 0) ) { }
  347.     if (GiveUp) {
  348.        /*
  349.         *       Wait for the bottom of the border
  350.         */
  351.        GiveUp= WAITCOUNT;
  352.        while ( (--GiveUp) && (GetLine(rasterreg) > 0) ) { }
  353.        }
  354.  
  355.     return ( ( GiveUp ) ? 0 : -1);
  356. }
  357.  
  358.  
  359. /*****************************************************************/
  360.  
  361. static void _fastcall SetVBorder(int top, int bottom)
  362. {
  363.     /* top border */
  364.     if ( top < MIN_TOP ) top=MIN_TOP;
  365.     SetDispReg(TOPBORDER,top);
  366.     /* bottom border */
  367.     if ( bottom > MAX_BOTTOM ) bottom=MAX_BOTTOM;
  368.     SetDispReg(BOTTOMBORDER,bottom);
  369.  
  370.     SetDispReg(DR10,top);
  371.     SetDispReg(DR11,bottom);
  372. }
  373.  
  374.  
  375. /*****************************************************************/
  376.  
  377. static void _fastcall SetRGBorCV(int type)
  378. {
  379.     /*  set the contrast level */
  380.     targa.RGBorCV = type;
  381.     targa.VCRCon = ( targa.VCRCon  & MSK_RGBORCV ) |
  382.                     (targa.RGBorCV<<SHF_RGBORCV) ;
  383.     OUTPORTB(VCRCON, targa.VCRCon );
  384. }
  385.  
  386. /*****************************************************************/
  387.  
  388. static void _fastcall SetVCRorCamera(int type)
  389. {
  390.     targa.VCRorCamera = type&1;
  391.     targa.VCRCon = ( targa.VCRCon  & MSK_VCRORCAMERA ) |
  392.                     (targa.VCRorCamera<<SHF_VCRORCAMERA) ;
  393.     OUTPORTB(VCRCON, targa.VCRCon );
  394. }
  395.  
  396.  
  397. /*****************************************************************/
  398.  
  399. static void _fastcall SetBorderColor(long color)
  400. {
  401.     targa.BorderColor = color;
  402.     OUTPORTB(BORDER, (int)(0x0000ffffL&(color)));
  403.     OUTPORTB((BORDER+2), (int)((color)>>16));
  404. }
  405.  
  406. /*****************************************************************/
  407.  
  408. static void _fastcall SetMask(int mask)
  409. {
  410.     /* mask to valid values and output to mode register */
  411.     targa.Mask = mask;
  412.     OUTPORTB(MASKREG, mask);
  413. }
  414.  
  415.  
  416. /*****************************************************************/
  417.  
  418. static void _fastcall SetVertShift(int preshift)
  419. {
  420.     /*  set the Vertical Preshift count  level */
  421.     targa.VertShift = preshift;
  422.     OUTPORTB(VERTPAN, preshift);
  423. }
  424.  
  425.  
  426. /*****************************************************************/
  427.  
  428. static void _fastcall SetOverscan(int mode)
  429. {
  430. long tempColor;
  431.  
  432.     targa.ovrscnOn = mode;
  433.     if ( mode == 0 ) {
  434.             INPORTB(UNDERREG);  /*    select underscan mode */
  435.             SetHBorder(    (DEF_LEFT+targa.xOffset),
  436.                         (DEF_RIGHT+targa.xOffset));
  437.             SetDispReg(4,352);
  438.             SetDispReg(5,1);
  439.             SetBorderColor(targa.BorderColor);
  440.     }
  441.     else    {
  442.             INPORTB(OVERREG);   /*    select overrscan mode */
  443.             SetDispReg(0,64);   /*    Set four of the display registers */
  444.             SetDispReg(1,363);  /*    to values required for Overscan */
  445.             SetDispReg(4,363);
  446.             SetDispReg(5,17);
  447.             tempColor = targa.BorderColor;
  448.             SetBorderColor(0L);
  449.             targa.BorderColor = tempColor;
  450.     }
  451. }
  452.  
  453.  
  454. /*****************************************************************/
  455.  
  456. static void _fastcall SetInterlace(int type)
  457. {
  458.     targa.InterlaceMode= type & MSK_INTERLACE;
  459.     SetDispReg(INTREG, targa.InterlaceMode);
  460.     /*
  461.      *    SET THE INTERLACE BIT TO MATCH THE INTERLACE MODE AND
  462.      *    SCREEN RESOLUTION -  SCREEN PAGE
  463.      */
  464.     if ( ( targa.InterlaceMode >= 2 ) &&
  465.          ( targa.PageMode> 1 )    &&
  466.          ( (targa.PageMode&1) != 0 )  )
  467.         TSetMode(targa.mode|(~MSK_IBIT) );
  468.     else
  469.         TSetMode(targa.mode& MSK_IBIT);
  470. }
  471.  
  472.  
  473. /*****************************************************************/
  474.  
  475. static void _fastcall SetBlndReg(int value)
  476. {
  477.     /*  set the Vertical Preshift count  level */
  478.     if ( targa.boardType == 32 ) {
  479.         targa.VCRCon = (targa.VCRCon&0xfe) | value;
  480.         OUTPORTB(BLNDREG, value);
  481.         }
  482. }
  483.  
  484.  
  485. /*****************************************************************/
  486.  
  487. static void _fastcall near TSetMode(int mode)
  488. {
  489.     /* mask to valid values and output to mode register */
  490.     OUTPORTB(MODEREG, mode );
  491.     targa.mode = mode;
  492. }
  493.  
  494.  
  495. /*****************************************************************/
  496.  
  497. static void _fastcall SetContrast(int level)
  498. {
  499.     /*  set the contrast level */
  500.     targa.Contrast = level &((~MSK_CONTRAST)>>SHF_CONTRAST);
  501.     targa.VCRCon = ( targa.VCRCon  & MSK_CONTRAST ) |
  502.             (targa.Contrast<<SHF_CONTRAST) ;
  503.     OUTPORTB(VCRCON, targa.VCRCon );
  504. }
  505.  
  506.  
  507. /*****************************************************************/
  508.  
  509. static void _fastcall SetHue(int level)
  510. {
  511.     /*  set the hue level -  Mask to valid value */
  512.     targa.Hue = level&((~MSK_HUE)>>SHF_HUE);
  513.     /* mask to valid range */
  514.     targa.SatHue = (targa.SatHue&MSK_HUE) | (targa.Hue<<SHF_HUE);
  515.     OUTPORTB(SATHUE, targa.SatHue );
  516. }
  517.  
  518.  
  519. /*****************************************************************/
  520.  
  521. static void _fastcall SetSaturation(int level)
  522. {
  523.     /*  set the saturation level */
  524.     targa.Saturation= level&( (~MSK_SATURATION)>>SHF_SATURATION);
  525.     targa.SatHue =    (targa.SatHue&MSK_SATURATION) |
  526.              (targa.Saturation<<SHF_SATURATION);
  527.     OUTPORTB(SATHUE , targa.SatHue );
  528. }
  529.  
  530.  
  531. /*************************************************************/
  532.  
  533. /*** UNUSED
  534. static void _fastcall SetPageMode(int pageMode)
  535. {
  536.     pageMode &= 0x07;
  537.     targa.PageMode = pageMode;
  538.     VWait();
  539.     TSetMode( (targa.mode)&(MSK_RES) |((pageMode<<SHF_RES)&(~MSK_RES)) ) ;
  540.     if ( ( targa.DisplayRegister[20] >= 2 ) &&
  541.          ( pageMode> 1 )  &&
  542.          ( (pageMode&1) != 0 )      )    TSetMode(targa.mode|(~MSK_IBIT) );
  543.     else
  544.         TSetMode(targa.mode& MSK_IBIT);
  545. }
  546. ***/
  547.  
  548.  
  549. /*****************************************************************/
  550.  
  551. static void _fastcall SetHBorder(int left, int right)
  552. {
  553.     SetDispReg(LEFTBORDER, left);    /* set horizontal left border */
  554.     SetDispReg(RIGHTBORDER,right);    /* set horizontal right border */
  555. /*
  556.  *                    Set DR 8 and 9 since they
  557.  *                    default to tracking DR0 and DR 1
  558.  */
  559.     SetDispReg(DR8,left);
  560.     SetDispReg(DR9,left);
  561. }
  562.  
  563.  
  564. /*****************************************************************/
  565.  
  566. /*** UNUSED
  567. static void _fastcall SetGenlock(int OnOrOff)
  568. {
  569.     TSetMode( (targa.mode)&(MSK_GENLOCK)
  570.             |((OnOrOff<<SHF_GENLOCK)&(~MSK_GENLOCK)) );
  571. }
  572. ***/
  573.  
  574.  
  575. /*****************************************************************/
  576. /* was asm, TC fast enough on AT */
  577.  
  578. static int GetLine( int port )
  579. {
  580. int cnt;
  581. int val1, val2;
  582.  
  583.     val1 = INPORTB( port );
  584.     for( cnt = 0; cnt < 20; cnt++ ) {
  585.         val2 = INPORTB( port );
  586.         if( val1 == val2 )
  587.             break;
  588.         val1 = val2;
  589.     }
  590.     return( val1 );
  591. }
  592.  
  593.  
  594. /**********************************************************************
  595.               TINIT
  596. **********************************************************************/
  597.  
  598. static int GraphInit()
  599. {
  600. int i;
  601. int bottom, top;
  602. char *envptr;
  603. unsigned switches, got_switches;
  604.  
  605.     memset( &targa, 0, sizeof(targa) );
  606.  
  607.     targa.boardType = TYPE_16;        /* default to T16 */
  608.     targa.xOffset = 0;  targa.yOffset = 0;    /* default to no offset */
  609.     targa.LinesPerField= DEF_ROWS/2;    /*  number of lines per field */
  610.     targa.AlwaysGenLock = DEF_GENLOCK;    /* default to genlock off */
  611.     targa.PageMode = 0;
  612.     targa.InterlaceMode = DEF_INT;        /* Defalut:  Interlace Mode 0 */
  613.     targa.Contrast= DEF_CONTRAST;
  614.     targa.Saturation = DEF_SATURATION;
  615.     targa.Hue = DEF_HUE;
  616.     targa.RGBorCV = CV;            /* default to Composite video */
  617.     targa.VCRorCamera = CAMERA;
  618.     targa.PanXOrig = 0; targa.PanYOrig=0;
  619.     targa.PageUpper= 0xffff;        /* set the bank flags to illega& values */
  620.     targa.PageLower= 0xffff;        /* so that they will be set the first time */
  621.     targa.ovrscnAvail = 0;            /* Assume no Overscan option */
  622.     targa.ovrscnOn = 0;
  623.  
  624.     if ((envptr = getenv("TARGA")) == NULL)
  625.        return(-2);
  626.     switches = got_switches = 0;
  627.     while (*envptr) {
  628.        if (*envptr != ' ') ++got_switches;
  629.        if (*envptr >= '2' && *envptr <= '8')
  630.           switches |= (1 << ('8' - *envptr));
  631.        ++envptr;
  632.        }
  633.     if (got_switches == 0) { /* all blanks, use default */
  634.        targa.memloc = 0xA000;
  635.        targa.iobase = 0x220;
  636.        }
  637.     else {
  638.        targa.memloc = 0x8000 + ((switches & 0x70) << 8);
  639.        targa.iobase = 0x200  + ((switches & 0x0f) << 4);
  640.        }
  641.  
  642.     if ((envptr = getenv("TARGASET"))) {
  643.        while(1) { /* parse next parameter */
  644.           while (*envptr == ' ' || *envptr == ',') ++envptr;
  645.           if (*envptr == 0) break;
  646.           if (*envptr >= 'a' && *envptr <= 'z') *envptr -= ('a'-'A');
  647.           i = atoi(envptr+1);
  648.           switch (*envptr) {
  649.          case 'T':
  650.             if (i == 16) targa.boardType = TYPE_16;
  651.             if (i == 24) targa.boardType = TYPE_24;
  652.             if (i == 32) targa.boardType = TYPE_32;
  653.             break;
  654.          /* case 'E' not done, meaning not clear */
  655.          case 'X':
  656.             targa.xOffset = i;
  657.             break;
  658.          case 'Y':
  659.             targa.yOffset = i;
  660.             break;
  661.          case 'I':
  662.             targa.InterlaceMode = i;
  663.             break;
  664.          /* case 'N' not done, I don't know how to handle it */
  665.          case 'R':
  666.             targa.RGBorCV = RGB;
  667.             break;
  668.          case 'B':
  669.             targa.VCRorCamera = CAMERA;
  670.             break;
  671.          case 'V':
  672.             targa.VCRorCamera = VCR;
  673.             break;
  674.          case 'G':
  675.             targa.AlwaysGenLock = 1;
  676.             break;
  677.          case 'C':
  678.             targa.Contrast = i * 31 / 100;
  679.             break;
  680.          case 'S':
  681.             targa.Saturation = i * 7 / 100;
  682.             break;
  683.          case 'H':
  684.             targa.Hue = i * 31 / 100;
  685.             break;
  686.          /* note: 'A' and 'O' defined but apply only to type M8 */
  687.          /* case 'P' not handled cause I don't know how */
  688.          }
  689.           while (*(++envptr) >= '0' && *envptr <= '9') { }
  690.           }
  691.        }
  692.  
  693.     if ( targa.boardType == TYPE_16 ) {
  694.         targa.MaxBanks = 16;
  695.         targa.BytesPerPixel = 2;
  696.     }
  697.     if ( targa.boardType == TYPE_24 ) {
  698.         targa.MaxBanks = 32;
  699.         targa.BytesPerPixel = 3;
  700.     }
  701.     if ( targa.boardType == TYPE_32 ) {
  702.         targa.MaxBanks = 32;
  703.         targa.BytesPerPixel = 4;
  704.     }
  705.  
  706.     /****** Compute # of rows per 32K bank    ********/
  707.     targa.RowsPerBank = 512/(targa.MaxBanks);
  708.     targa.AddressShift =  targa.MaxBanks>>4;
  709.  
  710.     /*    if initializing CVA:  set these before we quit    */
  711.     SetSaturation(targa.Saturation);
  712.     SetHue(targa.Hue);
  713.     SetContrast( targa.Contrast);
  714.  
  715.     /*    Set Genlock bit if always genlocked */
  716.     /*    Set before flipping and jerking screen */
  717.     TSetMode( (targa.AlwaysGenLock<<SHF_GENLOCK) | DEF_MODE);
  718.  
  719.     SetBlndReg(0);        /*  disable blend mode on TARGA 32 */
  720.  
  721.     SetInterlace(targa.InterlaceMode);
  722.     SetFixedRegisters();
  723.     SetOverscan( 0 );
  724.  
  725.     top    = 140 - (targa.LinesPerField / 2);
  726.     bottom = top + targa.LinesPerField;
  727.     SetVBorder(top,bottom);
  728.     SetVertShift(256-targa.LinesPerField);
  729.  
  730.     SetMask(DEF_MASK);
  731.     SetRGBorCV (targa.RGBorCV );
  732.     SetVCRorCamera(targa.VCRorCamera);
  733.  
  734.     /*    See if the raster register is working correctly and
  735.         return error flag if its not         */
  736.     return (( VWait() == -1) ? -1 : 0);
  737.  
  738. }
  739.  
  740.  
  741. /**************************************************************/
  742.  
  743. static void GraphEnd()
  744. {
  745.     TSetMode( (targa.mode)&MSK_MSEL );     /*  disable memory */
  746. }
  747.  
  748.  
  749. /**************************************************************/
  750. /* Set the registers which have required values */
  751.  
  752. #define FIXED_REGS    10
  753.  
  754. static int FixedRegs[] = {
  755.     DR6,DR7,DR12,DR13,DR14,DR15,DR16,DR17,DR18,DR19
  756. };
  757.  
  758. static int FixedValue[] = {
  759.     DEF_DR6,DEF_DR7,DEF_DR12,DEF_DR13,DEF_DR14,
  760.     DEF_DR15,DEF_DR16,DEF_DR17,DEF_DR18,DEF_DR19
  761. };
  762.  
  763. static void SetFixedRegisters()
  764. {
  765. int reg;
  766.  
  767.     for ( reg=0; reg<FIXED_REGS; reg++)
  768.         SetDispReg(FixedRegs[reg],FixedValue[reg]);
  769. }
  770.  
  771.  
  772.