show.c

epson 13506 driver code

/*
**===========================================================================
**  SHOW.C - Source to the SHOW demo program. This program sets all
**           available display modes and draws a pattern in each.
**---------------------------------------------------------------------------
**  Copyright (c) 1997, 2001 Epson Research and Development, Inc.
**  All Rights Reserved.
**===========================================================================
*/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>

#if !defined(__GNUC__)

#pragma warning(disable:4032)  // disable warning: formal parameter 1 has different type when promoted
#include <conio.h>

#elif !defined(strcmpi)
#define strcmpi stricmp
#endif


#if defined(INTEL_W32) || defined(INTEL_DOS)

#ifndef __GNUC__
#include <conio.h>
#endif


#include <time.h>
#endif


#if defined(__GNUC__) && defined(INTEL_DOS)
#include <conio.h>
#endif

#include "hal.h"
#include "appcfg.h"
#include "assert.h"

/*-----------------------------------------------------------------------*/

/*
** The following definitions are for CalcDisplaySurfaceCombination()
*/
enum
   {
   SURFACE_NONE = -1,
   SURFACE_LCD0_CRTTV1 = 0,
   SURFACE_LCD0,
   SURFACE_CRTTV0,
   SURFACE_LCDCRTTV0,

   MAX_SURFACE_COMBINATIONS
   };

/*============================ global variables ===========================*/

/****************************/
char szVersion[] = "2.04";
/****************************/

/*-----------------------------------------------------------------------*/

static const char Revision[] = "SHOW.C=$Revision: 24 $";

/*-----------------------------------------------------------------------*/

int gnAutoRun;
int gnUseVertical;
int gnContinualScrnRead;
int gnContinualScrnWrite;
int gnInitRegisters;
int gnShowGrid;
int gnUpdateDisplayMemory;
int LcdOrientation;
int ShowAllBppModes;
int SelectedLcdBppMode;
int DisplaySurfaceCombination;

int Orientation[MAX_DISP_SURFACE];

int NumberOfSurfaces;
int CommonMemoryBlockForAllDisplays;
unsigned SurfaceDisplayMode[MAX_DISP_SURFACE];

char szModeFailed[] = "ERROR: Not enough memory for %s in %d bits-per-pixel.\n";

/*=============================== functions ===============================*/

void DisplayCopyright( void );
void DisplayUsage( void );

int ShowOneMode( int surface, int BitsPerPixel, char *str );
void UpdateScreen( unsigned BitsPerPixel );

unsigned GetNextColor( unsigned Color, unsigned Bpp );
int CalcDisplaySurfaceCombination(void);

/*================================== code =================================*/

void DisplayResolution(void)
{
   unsigned x, y;
   unsigned regDisplayMode;

   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_LCD0:
         seGetLcdResolution(&x, &y);
         printf("LCD: %d * %d * %d Bpp\n", x, y, seGetLcdBitsPerPixel());
         break;

      case SURFACE_CRTTV0:
         seGetCrtResolution(&x, &y);
         printf("CRT/TV: %d * %d * %d Bpp\n", x, y, seGetCrtBitsPerPixel());
         break;

      case SURFACE_LCD0_CRTTV1:
      case SURFACE_LCDCRTTV0:
         seGetLcdResolution(&x, &y);
         printf("LCD: %d * %d * %d Bpp\n", x, y, seGetLcdBitsPerPixel());
         
         seGetCrtResolution(&x, &y);
         printf("CRT/TV: %d * %d * %d Bpp\n", x, y, seGetCrtBitsPerPixel());
         break;
      }
}

/*-------------------------------------------------------------------------*/

DWORD SetBitsPerPixel(int surface, unsigned bpp)
{
   unsigned regDisplayMode;

   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_LCD0:
         if (surface == 0)
            return seSetLcdBitsPerPixel(bpp);
         break;

      case SURFACE_CRTTV0:
         if (surface == 0)
            {
            if (regDisplayMode & TV)
               return seSetTvBitsPerPixel(bpp);
            else
               return seSetCrtBitsPerPixel(bpp);
            }
         break;

      case SURFACE_LCD0_CRTTV1:
         if (surface == 0)
            return seSetLcdBitsPerPixel(bpp);
         else if (surface == 1)
            {
            if (regDisplayMode & TV)
               return seSetTvBitsPerPixel(bpp);
            else
               return seSetCrtBitsPerPixel(bpp);
            }
         break;

      case SURFACE_LCDCRTTV0:
         if (surface == 0)
            return seSetLcdCrtBitsPerPixel(bpp);
         break;
      }

#ifdef INTEL_DOS
   return -1;
#else
   return 0;
#endif
}

/*-------------------------------------------------------------------------*/

void DisplaySurfaceHelp(void)
{
   printf("\n"
          "   ds=   | Surface 0    Surface 1\n"
          "---------------------------------\n"
          "    0    | LCD          ---\n"
          "    1    | CRT          ---\n"
          "    2    | TV           ---\n"
          "    3    | LCD & CRT    ---\n"
          "    4    | LCD & TV     ---\n"
          "    5    | LCD          CRT\n"
          "    6    | LCD          TV\n");
}

/*-------------------------------------------------------------------------*/

void ShowActiveDisplaySurface(void)
{
   /*
   ** "Display Surface: 0=LCD, 1=CRT"
   */
   printf("Display Surface: 0=");

   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_LCD0_CRTTV1:
         printf("LCD, 1=CRT/TV\n");
         break;

      case SURFACE_LCD0:
         printf("LCD\n");
         break;

      case SURFACE_CRTTV0:
         printf("CRT/TV\n");
         break;

      case SURFACE_LCDCRTTV0:
         printf("LCD and CRT/TV\n");
         break;

      default:
         printf("NONE\n");
         break;
      }
}

/*-----------------------------------------------------------------------*/

int GetSurfaceDisplayMode(int surface)
{
   unsigned regDisplayMode;

   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         return 0;
         break;

      case SURFACE_LCD0:
         if (surface == 0)
            return LCD;
         break;

      case SURFACE_CRTTV0:
         if (surface == 0)
            return regDisplayMode & (CRT | TV);
         break;

      case SURFACE_LCD0_CRTTV1:
         if (surface == 0)
            return LCD;
         else if (surface == 1)
            return regDisplayMode & (CRT | TV);
         break;

      case SURFACE_LCDCRTTV0:
         if (surface == 0)
            return regDisplayMode & (LCD | CRT | TV);
         break;
      }

   return 0;
}

/*-----------------------------------------------------------------------*/

int CalcDisplaySurfaceCombination(void)
{
   unsigned regDisplayMode;

   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   if ((regDisplayMode & LCD) && !(regDisplayMode & (CRT | TV)))
      return SURFACE_LCD0;
   else if (!(regDisplayMode & LCD) && (regDisplayMode & (CRT | TV)))
      return SURFACE_CRTTV0;
   else if ((regDisplayMode & LCD) && (regDisplayMode & (CRT | TV)))
      {
      if (CommonMemoryBlockForAllDisplays)
         return SURFACE_LCDCRTTV0;
      else if ((SurfaceDisplayMode[0] & LCD) && (SurfaceDisplayMode[1] & (CRT | TV)))
         return SURFACE_LCD0_CRTTV1;
      else
         return SURFACE_LCDCRTTV0;
      }

   return SURFACE_NONE;
}

/*-----------------------------------------------------------------------*/

int GetActiveSurfaceNumber(void)
{
   int CurrentDisplayMode;

   CurrentDisplayMode = seGetSurfaceDisplayMode();

   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_LCD0:
         if (CurrentDisplayMode & LCD)
            return 0;
         break;

      case SURFACE_CRTTV0:
         if (CurrentDisplayMode & (CRT | TV))
            return 0;
         break;

      case SURFACE_LCD0_CRTTV1:
         if (CurrentDisplayMode & LCD)
            return 0;
         else if (CurrentDisplayMode & (CRT | TV))
            return 1;
         break;

      case SURFACE_LCDCRTTV0:
         if (CurrentDisplayMode & (LCD | CRT | TV))
            return 0;
         break;
      }

   return -1;
}

/*-----------------------------------------------------------------------*/

int GetSurfaceNumber(unsigned DisplayMode)
{
   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_LCD0:
         if (DisplayMode & LCD)
            return 0;
         break;

      case SURFACE_CRTTV0:
         if (DisplayMode & (CRT | TV))
            return 0;
         break;

      case SURFACE_LCD0_CRTTV1:
         if (DisplayMode & LCD)
            return 0;
         else if (DisplayMode & (CRT | TV))
            return 1;
         break;

      case SURFACE_LCDCRTTV0:
         if (DisplayMode & LCD)
            return 0;
         else if (DisplayMode & (CRT | TV))
            return 1;
         break;
      }

   return -1;
}

/*-----------------------------------------------------------------------*/

void SetActiveSurfaceNumber(int surface)
{
   unsigned regDisplayMode;

   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_LCD0:
         if (surface == 0)
            seSetLcdAsActiveSurface();
         break;

      case SURFACE_CRTTV0:
         if (surface == 0)
            {
            if (regDisplayMode & TV)
               seSetTvAsActiveSurface();
            else
               seSetCrtAsActiveSurface();
            }
         break;

      case SURFACE_LCD0_CRTTV1:
         if (surface == 0)
            seSetLcdAsActiveSurface();
         else if (surface == 1)
            {
            if (regDisplayMode & TV)
               seSetTvAsActiveSurface();
            else
               seSetCrtAsActiveSurface();
            }
         break;

      case SURFACE_LCDCRTTV0:
         if (surface == 0)
            seSetLcdAsActiveSurface();
         else if (surface == 1)
            {
            if (regDisplayMode & TV)
               seSetTvAsActiveSurface();
            else
               seSetCrtAsActiveSurface();
            }
         break;
      }
}

/*-----------------------------------------------------------------------*/

int VirtInit(int surface, DWORD width, DWORD height)
{
   unsigned regDisplayMode;

   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_LCD0:
         if (surface == 0)
            return seLcdVirtInit(width, height);
         break;

      case SURFACE_CRTTV0:
         if (surface == 0)
            {
            if (regDisplayMode & TV)
               return seTvVirtInit(width, height);
            else
               return seCrtVirtInit(width, height);
            }
         break;

      case SURFACE_LCD0_CRTTV1:
         if (surface == 0)
            return seLcdVirtInit(width, height);
         else if (surface == 1)
            {
            if (regDisplayMode & TV)
               return seTvVirtInit(width, height);
            else
               return seCrtVirtInit(width, height);
            }
         break;

      case SURFACE_LCDCRTTV0:
         if ((surface == 0) || (surface == 1))
            return seLcdCrtVirtInit(width, height);
         break;
      }

   return ERR_FAILED;
}

/*-----------------------------------------------------------------------*/

void DisplayLcdOrientation(void)
   {
   printf("LCD Orientation: ");

   switch (LcdOrientation)
      {
      case LANDSCAPE:
      default:
         printf("LANDSCAPE");
         break;

      case ROTATE90:
         printf("SWIVELVIEW 90 DEGREES");
         break;

      case ROTATE180:
         printf("SWIVELVIEW 180 DEGREES");
         break;

      case ROTATE270:
         printf("SWIVELVIEW 270 DEGREES");