line.c

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

//
// Windows CE Software Graphics Library
// line.c
//
// Copyright (c) 2000 Microsoft Corporation. All rights reserved.
//
// This source file contains the implementation os the software line drawing
// routine.

#include "pch.h"
#include "swg.h"

BOOL
SoftwareLine(
  LINE_PARAM * Parameters
  )
{
  // SoftwareLine
  // This is the fully featured software line drawing routine. It can be called
  // to perform line drawing operations that the hardware cannot do. It
  // supports the following features:
  //
  // - Supports all MIX operations.
  // - Subpixel precision
  // - Cosmetic pens, with width == 1, pen styles, solid colors.
  //
  // Note: this function assume that all surfaces are locked and that if we
  // are rendering to the primary, that the graphics pipe is flushed and
  // stalled.

  // Local variables.

  ULONG  BitsPerPixel = Parameters->Destination->Format->BitsPerPixel;
  LONG   i;
  LONG   PixelsPerUlong = 32 / BitsPerPixel;
  ULONG  Shift;
  ULONG  Pen[32];
  ULONG  PenMask[32];
  ULONG  BaseMask = (2 << (BitsPerPixel - 1)) - 1;
  ULONG  Mask;
  LONG   Stride = Parameters->Destination->Stride;
  LONG   MajorDPtr = 0;
  LONG   MinorDPtr = 0;
  LONG   MajorDPixel = 0;
  LONG   MinorDPixel = 0;
  BYTE * Ptr;
  BYTE * NewPtr;
  LONG   SubPixel;
  ULONG  Cache;
  ULONG  D;
  ULONG  P;
  LONG   RemainingPixels;
  ULONG  Style = Parameters->Style;
  ULONG  StyleState = Parameters->StyleState;
  LONG   Accum = (LONG)(Parameters->dN) + Parameters->Gamma;
  LONG   Axstp = (LONG)(Parameters->dN);
  LONG   Dgstp = (LONG)(Parameters->dN) - (LONG)(Parameters->dM);
  BYTE   RopMark = (BYTE)(Parameters->Mix);
  BYTE   RopSpace = (BYTE)(Parameters->Mix >> 8);
  BYTE   Rop;
  BYTE   P0;
  BYTE   P1;
  BYTE   P2;

  // Check parameters.

  // !TODO!

  if (BitsPerPixel != 24) {

    for (i = 0; i < PixelsPerUlong; i++) {

      Shift = i * BitsPerPixel;
      if (BitsPerPixel < 8) {
        Shift ^= (8 - BitsPerPixel);
      }

      Pen[i] = (Parameters->FillValue & BaseMask) << Shift;
      PenMask[i] = BaseMask << Shift;
    }

    switch (Parameters->Direction) {

    case 0: MajorDPixel =  1; MinorDPtr =  Stride; break;
    case 1: MinorDPixel =  1; MajorDPtr =  Stride; break;
    case 2: MinorDPixel = -1; MajorDPtr =  Stride; break;
    case 3: MajorDPixel = -1; MinorDPtr =  Stride; break;
    case 4: MajorDPixel = -1; MinorDPtr = -Stride; break;
    case 5: MinorDPixel = -1; MajorDPtr = -Stride; break;
    case 6: MinorDPixel =  1; MajorDPtr = -Stride; break;
    case 7: MajorDPixel =  1; MinorDPtr = -Stride; break;
    default:
      return FALSE;
    }

    Ptr = ((BYTE *)Parameters->Destination->Ptr)
          + Parameters->Y * Stride
          + (((Parameters->X * BitsPerPixel) >> 5) << 2);

    SubPixel = Parameters->X % PixelsPerUlong;

    Cache = *(ULONG *)Ptr;

    for (RemainingPixels = Parameters->PixelCount;
         RemainingPixels != 0;
         RemainingPixels--) {

      D = Cache;
      P = Pen[SubPixel];

      if ((Style >> ((StyleState++) & 31)) & 1) {

        Rop = RopSpace;
      }
      else {

        Rop = RopMark;
      }

      switch (Rop) {

      case 1:  D = 0; break;
      case 2:  D = ~(P | D); break;
      case 3:  D = ~P & D; break;
      case 4:  D = ~P; break;
      case 5:  D = P & ~D; break;
      case 6:  D = ~D; break;
      case 7:  D = P ^ D; break;
      case 8:  D = ~( P & D ); break;
      case 9:  D = P & D; break;
      case 10: D = ~( P ^ D ); break;
      case 11: D = D; break;
      case 12: D = ~P | D; break;
      case 13: D = P; break;
      case 14: D = P | ~D; break;
      case 15: D = P | D; break;
      case 16: D = 0xffffffff; break;
      default:
        return FALSE;
      }

      Mask = PenMask[SubPixel];

      Cache = (Cache & ~Mask) | (D & Mask);

      if (RemainingPixels == 1) {

        *(ULONG *)Ptr = Cache;
        break;
      }

      NewPtr = Ptr;
      NewPtr += MajorDPtr;
      SubPixel += MajorDPixel;

      if (Axstp != 0) {

        if (Accum < 0) {
          Accum += Axstp;
        }
        else {
          NewPtr += MinorDPtr;
          SubPixel += MinorDPixel;
          Accum += Dgstp;
        }
      }
      if (SubPixel < 0) {

        NewPtr -= 4;
        SubPixel += PixelsPerUlong;
      }
      else if (SubPixel >= PixelsPerUlong) {

        NewPtr += 4;
        SubPixel -= PixelsPerUlong;
      }

      if (NewPtr != Ptr) {

        *(ULONG *)Ptr = Cache;
        Ptr = NewPtr;
        Cache = *(ULONG *)Ptr;
      }
    }
  }
  else {

    // For 24bpp, we do byte-by-byte accesses rather than try to mundge
    // packed 24bpp pixels directly.

    switch (Parameters->Direction) {

    case 0: MajorDPixel =  3; MinorDPtr =  Stride; break;
    case 1: MinorDPixel =  3; MajorDPtr =  Stride; break;
    case 2: MinorDPixel = -3; MajorDPtr =  Stride; break;
    case 3: MajorDPixel = -3; MinorDPtr =  Stride; break;
    case 4: MajorDPixel = -3; MinorDPtr = -Stride; break;
    case 5: MinorDPixel = -3; MajorDPtr = -Stride; break;
    case 6: MinorDPixel =  3; MajorDPtr = -Stride; break;
    case 7: MajorDPixel =  3; MinorDPtr = -Stride; break;
    default:
      return FALSE;
    } 

    Ptr = ((BYTE *)Parameters->Destination->Ptr)
          + Parameters->Y * Stride
          + Parameters->X * 3;

    P0 = ((BYTE *)&(Parameters->FillValue))[0];
    P1 = ((BYTE *)&(Parameters->FillValue))[1];
    P2 = ((BYTE *)&(Parameters->FillValue))[2];

    for (RemainingPixels = Parameters->PixelCount;
         RemainingPixels != 0;
         RemainingPixels--) {

      if ((Style >> ((StyleState++) & 31)) & 1) {

        Rop = RopSpace;
      }
      else {

        Rop = RopMark;
      }

      switch (Rop) {
      case 1:  Ptr[0] = 0;
               Ptr[1] = 0;
               Ptr[2] = 0;
               break;
      case 2:  Ptr[0] = ~(P0 | Ptr[0]);
               Ptr[1] = ~(P1 | Ptr[1]);
               Ptr[2] = ~(P2 | Ptr[2]);
               break;	
      case 3:  Ptr[0] = ~P0 & Ptr[0];
               Ptr[1] = ~P1 & Ptr[1];
               Ptr[2] = ~P2 & Ptr[2];
               break;	
      case 4:  Ptr[0] = ~P0;
               Ptr[1] = ~P1;
               Ptr[2] = ~P2;
               break;
      case 5:  Ptr[0] = P0 & ~Ptr[0];
               Ptr[1] = P1 & ~Ptr[1];
               Ptr[2] = P2 & ~Ptr[2];
               break;	
      case 6:  Ptr[0] = ~Ptr[0];
               Ptr[1] = ~Ptr[1];
               Ptr[2] = ~Ptr[2];
               break;	
      case 7:  Ptr[0] = P0 ^ Ptr[0];
               Ptr[1] = P1 ^ Ptr[1];
               Ptr[2] = P2 ^ Ptr[2];
               break;		
      case 8:  Ptr[0] = ~(P0 & Ptr[0]);
               Ptr[1] = ~(P1 & Ptr[1]);
               Ptr[2] = ~(P2 & Ptr[2]);
               break;	
      case 9:  Ptr[0] = P0 & Ptr[0];
               Ptr[1] = P1 & Ptr[1];
               Ptr[2] = P2 & Ptr[2];
               break;		
      case 10: Ptr[0] = ~(P0 ^ Ptr[0]);
               Ptr[1] = ~(P1 ^ Ptr[1]);
               Ptr[2] = ~(P2 ^ Ptr[2]);
               break;	
      case 11: Ptr[0] = Ptr[0];
               Ptr[1] = Ptr[1];
               Ptr[2] = Ptr[2];
               break;	
      case 12: Ptr[0] = ~P0 | Ptr[0];
               Ptr[1] = ~P1 | Ptr[1];
               Ptr[2] = ~P2 | Ptr[2];
               break;	
      case 13: Ptr[0] = P0;
               Ptr[1] = P1;
               Ptr[2] = P2;
               break;
      case 14: Ptr[0] = P0 | ~Ptr[0];
               Ptr[1] = P1 | ~Ptr[1];
               Ptr[2] = P2 | ~Ptr[2];
               break;	
      case 15: Ptr[0] = P0 | Ptr[0];
               Ptr[1] = P1 | Ptr[1];
               Ptr[2] = P2 | Ptr[2];
               break;		
      case 16: Ptr[0] = 0xff;
               Ptr[1] = 0xff;
               Ptr[2] = 0xff;
               break;
      default:
        return FALSE;
      }

      Ptr += MajorDPtr;

      if (Axstp != 0) {

        if (Accum < 0) {
          Accum += Axstp;
        }
        else {
          Ptr += MinorDPtr;
          Accum += Dgstp;
        }
      }
    }
  }

  return TRUE;
}