temskwk.pas

Do your applications look a little boring? Would you like to get spectacular yet easy to use visual

  begin
    if Mask[k] <> $FF then
      Work[k] := 0;
    if Mask[k+1] <> $FF then
      Work[k+1] := 0;
    if Mask[k+2] <> $FF then
      Work[k+2] := 0;
    if Mask[k+3] <> $FF then
      Work[k+3] := 0;
    Inc(k, 4);
  end;
end;

procedure DecMask2Rect(Work, Mask: PByteArray; k, UpdateRowLenght,
  UpdateGap: Longint);
var
  Limit: Longint;
begin
  while k < 0 do
  begin
    Limit := k + UpdateRowLenght;
    while k < Limit do
    begin
      if Mask[k] <> $FF then
        Work[k] := 0;
      Inc(k);
    end;
    Inc(k, UpdateGap);
  end;
end;

procedure DoDecMask2(Mask1, Mask2: Pointer;
  ScanLineSize, Width, DecValue: Longint; DecAll:Boolean;
  UpdateRect, UnUpdateRect: TRect);
var
  UpdParams: TTEUpdParams;
  Mode: Longint;
begin
  Mode := GiveMeTheUpdMode(Width, 0, 8, UpdateRect, UnUpdateRect, pf8bit);
  GiveMeTheUpdParams(Mode, UpdParams, ScanLineSize, UpdateRect, UnUpdateRect,
    pf8bit);

  case Mode of
    1: if DecAll
       then DecMask2(
              PByteArray(PChar(Mask1) - UpdParams.Start1),
              PByteArray(PChar(Mask2) - UpdParams.Start1),
              -UpdParams.Lenght1)
       else DecMask2Value(
              PByteArray(PChar(Mask1) - UpdParams.Start1),
              PByteArray(PChar(Mask2) - UpdParams.Start1),
              -UpdParams.Lenght1,
              DecValue);
    2: if DecAll
       then DecMask2Rect(
              PByteArray(PChar(Mask1) - UpdParams.Start1),
              PByteArray(PChar(Mask2) - UpdParams.Start1),
              -UpdParams.Lenght1,
              UpdParams.RowLenght1,
              UpdParams.Gap1)
       else DecMask2ValueRect(
              PByteArray(PChar(Mask1) - UpdParams.Start1),
              PByteArray(PChar(Mask2) - UpdParams.Start1),
              -UpdParams.Lenght1,
              DecValue,
              UpdParams.RowLenght1,
              UpdParams.Gap1);
    3: if DecAll
       then
       begin
         DecMask2Rect(
           PByteArray(PChar(Mask1) - UpdParams.Start1),
           PByteArray(PChar(Mask2) - UpdParams.Start1),
           -UpdParams.Lenght1,
           UpdParams.RowLenght1,
           UpdParams.Gap1);
         DecMask2Rect(
           PByteArray(PChar(Mask1) - UpdParams.Start2),
           PByteArray(PChar(Mask2) - UpdParams.Start2),
           -UpdParams.Lenght2,
           UpdParams.RowLenght2,
           UpdParams.Gap2);
         DecMask2Rect(
           PByteArray(PChar(Mask1) - UpdParams.Start3),
           PByteArray(PChar(Mask2) - UpdParams.Start3),
           -UpdParams.Lenght3,
           UpdParams.RowLenght3,
           UpdParams.Gap3);
         DecMask2Rect(
           PByteArray(PChar(Mask1) - UpdParams.Start4),
           PByteArray(PChar(Mask2) - UpdParams.Start4),
           -UpdParams.Lenght4,
           UpdParams.RowLenght4,
           UpdParams.Gap4);
       end
       else
       begin
         DecMask2ValueRect(
           PByteArray(PChar(Mask1) - UpdParams.Start1),
           PByteArray(PChar(Mask2) - UpdParams.Start1),
           -UpdParams.Lenght1,
           DecValue,
           UpdParams.RowLenght1,
           UpdParams.Gap1);
         DecMask2ValueRect(
           PByteArray(PChar(Mask1) - UpdParams.Start2),
           PByteArray(PChar(Mask2) - UpdParams.Start2),
           -UpdParams.Lenght2,
           DecValue,
           UpdParams.RowLenght2,
           UpdParams.Gap2);
         DecMask2ValueRect(
           PByteArray(PChar(Mask1) - UpdParams.Start3),
           PByteArray(PChar(Mask2) - UpdParams.Start3),
           -UpdParams.Lenght3,
           DecValue,
           UpdParams.RowLenght3,
           UpdParams.Gap3);
         DecMask2ValueRect(
           PByteArray(PChar(Mask1) - UpdParams.Start4),
           PByteArray(PChar(Mask2) - UpdParams.Start4),
           -UpdParams.Lenght4,
           DecValue,
           UpdParams.RowLenght4,
           UpdParams.Gap4);
        end;
  end;
end;

function GetApply256BmpMaskSProc(Levels: Integer; Add: Boolean): PByteArray;
{$ifdef TrialLimited}begin Result := nil; end;{$else}
const
  Body1: array[1..72] of Byte = (
    $55,                             
    $8B,$EC,                         
    $57,                             
    $56,                             
    $53,                             
    $83,$7D,$14,$00,                 
    $0F,$84,$B2,$01,$00,$00,         
    $BF,$FF,$00,$00,$00,             
    $83,$EF,$10,                     
    $0F,$6E,$F7,                     
    $0F,$60,$F6,                     
    $0F,$61,$F6,                     
    $0F,$62,$F6,                     
    $8B,$7D,$08,                     
    $0F,$6E,$FF,                     
    $0F,$60,$FF,                     
    $0F,$61,$FF,                     
    $0F,$62,$FF,                     
    $89,$D6,                         
    $89,$CF,                         
    $8B,$5D,$18,                     
    $8B,$4D,$14,                     
    $89,$C2,                         
    $0F,$EF,$C0,                     
    $0F,$60,$F6,                     
    $8B,$45,$10);                    

  Prefetch: array[1..15] of Byte = (
    $0F,$18,$44,$8E,$20,             
    $0F,$18,$44,$8F,$20,             
    $0F,$18,$44,$19,$20);            

  Body2: array[1..351] of Byte = (
    $0F,$6F,$0C,$0B,                 
    $0F,$D8,$CF,                     
    $0F,$DC,$CE,                     
    $0F,$D8,$CE,                     
    $0F,$6F,$E9,                     
    $0F,$6F,$54,$8E,$18,             
    $0F,$6F,$5C,$8F,$18,             
    $0F,$6F,$E2,                     
    $0F,$60,$D0,                     
    $0F,$60,$D8,                     
    $0F,$F9,$D3,                     
    $0F,$68,$C8,                     
    $0F,$71,$F1,$04,                 
    $0F,$69,$C9,                     
    $0F,$6F,$D9,                     
    $0F,$61,$C9,                     
    $0F,$D5,$D1,                     
    $0F,$69,$DB,                     
    $0F,$6F,$4C,$8F,$18,             
    $0F,$68,$E0,                     
    $0F,$68,$C8,                     
    $0F,$F9,$E1,                     
    $0F,$D5,$E3,                     
    $0F,$71,$D2,$08,                 
    $0F,$71,$D4,$08,                 
    $0F,$67,$D4,                     
    $0F,$FC,$54,$8F,$18,             
    $0F,$E7,$54,$8A,$18,             
    $0F,$6F,$54,$8E,$10,             
    $0F,$6F,$5C,$8F,$10,             
    $0F,$6F,$E2,                     
    $0F,$60,$D0,                     
    $0F,$60,$D8,                     
    $0F,$F9,$D3,                     
    $0F,$6F,$CD,                     
    $0F,$68,$C8,                     
    $0F,$71,$F1,$04,                 
    $0F,$61,$C9,                     
    $0F,$6F,$D9,                     
    $0F,$61,$C9,                     
    $0F,$D5,$D1,                     
    $0F,$69,$DB,                     
    $0F,$6F,$4C,$8F,$10,             
    $0F,$68,$E0,                     
    $0F,$68,$C8,                     
    $0F,$F9,$E1,                     
    $0F,$D5,$E3,                     
    $0F,$71,$D2,$08,                 
    $0F,$71,$D4,$08,                 
    $0F,$67,$D4,                     
    $0F,$FC,$54,$8F,$10,             
    $0F,$E7,$54,$8A,$10,             
    $0F,$6F,$54,$8E,$08,             
    $0F,$6F,$5C,$8F,$08,             
    $0F,$6F,$E2,                     
    $0F,$60,$D0,                     
    $0F,$60,$D8,                     
    $0F,$F9,$D3,                     
    $0F,$60,$E8,                     
    $0F,$71,$F5,$04,                 
    $0F,$6F,$CD,                     
    $0F,$69,$C9,                     
    $0F,$6F,$D9,                     
    $0F,$61,$C9,                     
    $0F,$D5,$D1,                     
    $0F,$69,$DB,                     
    $0F,$6F,$4C,$8F,$08,             
    $0F,$68,$E0,                     
    $0F,$68,$C8,                     
    $0F,$F9,$E1,                     
    $0F,$D5,$E3,                     
    $0F,$71,$D2,$08,                 
    $0F,$71,$D4,$08,                 
    $0F,$67,$D4,                     
    $0F,$FC,$54,$8F,$08,             
    $0F,$E7,$54,$8A,$08,             
    $0F,$6F,$14,$8E,                 
    $0F,$6F,$1C,$8F,                 
    $0F,$6F,$E2,                     
    $0F,$6F,$CB,                     
    $0F,$60,$D0,                     
    $0F,$60,$D8,                     
    $0F,$F9,$D3,                     
    $0F,$61,$ED,                     
    $0F,$6F,$DD,                     
    $0F,$61,$ED,                     
    $0F,$D5,$D5,                     
    $0F,$69,$DB,                     
    $0F,$68,$E0,                     
    $0F,$68,$C8,                     
    $0F,$F9,$E1,                     
    $0F,$D5,$E3,                     
    $0F,$71,$D2,$08,                 
    $0F,$71,$D4,$08,                 
    $0F,$67,$D4,                     
    $0F,$FC,$14,$8F,                 
    $0F,$E7,$14,$8A,                 
    $83,$C1,$08,                     
    $74,$15,                         
    $83,$E8,$08,                     
    $0F,$85,$92,$FE,$FF,$FF);        

  Sfence: array[1..3] of Byte = (
    $0F,$AE,$FF);             

  Body3: array[1..19] of Byte = (
    $03,$4D,$08,             
    $0F,$85,$83,$FE,$FF,$FF, 
    $0F,$77,                 
    $5B,                     
    $5E,                     
    $5F,                     
    $5D,                     
    $C2,$14,$00,             
    $90);                    
var
  SizeBody1,
  SizePrefetch,
  SizeBody2,
  SizeSfence,
  SizeBody3: Integer;
  Shift: Byte;
begin
  SizeBody1    := SizeOf(Body1);
  SizePrefetch := SizeOf(Prefetch);
  SizeBody2    := SizeOf(Body2);
  SizeSfence   := SizeOf(Sfence);
  SizeBody3    := SizeOf(Body3);

  GetMem(Result, SizeBody1 + SizePrefetch + SizeBody2 + SizeSfence + SizeBody3);
  CopyMemory(@(Result[0]), @Body1, SizeBody1);

  if TEProcessorInfo.SSE
  then
  begin
    CopyMemory(@(Result[SizeBody1]), @Prefetch, SizePrefetch);
    CopyMemory(@(Result[SizeBody1 + SizePrefetch]), @Body2, SizeBody2);
    CopyMemory(@(Result[SizeBody1 + SizePrefetch + SizeBody2]), @Sfence,
      SizeSfence);
    CopyMemory(@(Result[SizeBody1 + SizePrefetch + SizeBody2 + SizeSfence]),
      @Body3, SizeBody3);
  end
  else
  begin
    CopyMemory(@(Result[SizeBody1]), @Body2, SizeBody2);
    CopyMemory(@(Result[SizeBody1 + SizeBody2]), @Body3, SizeBody3);

    PByte(@Result[SizeBody1 +  94])^ := $7F;
    PByte(@Result[SizeBody1 + 179])^ := $7F;
    PByte(@Result[SizeBody1 + 264])^ := $7F;
    PByte(@Result[SizeBody1 + 334])^ := $7F;
    PInteger(@Result[12])^ := PInteger(@Result[12])^ - SizePrefetch - SizeSfence;
    PByte(@Result[SizeBody1 + 341])^ :=
      PByte(@Result[SizeBody1 + 341])^ - SizeSfence;
    PInteger(@Result[SizeBody1 + 347])^ :=
      PInteger(@Result[SizeBody1 + 347])^ + SizePrefetch;
    PInteger(@Result[SizeBody1 + SizeBody2 + 5])^ :=
      PInteger(@Result[SizeBody1 + SizeBody2 + 5])^ + SizePrefetch + SizeSfence;

    SizePrefetch := 0;
  end;

  if Add then
    PByte(@Result[SizeBody1 + SizePrefetch + 5])^ := $DC;
  if Levels <> 16 then
  begin
    PByte(@Result[23])^ := Levels;
    Shift := 0;
    case Levels of
        4: Shift := 6;
        8: Shift := 5;
       32: Shift := 3;
       64: Shift := 2;
      128: Shift := 1;
      256: Shift := 0;
    end;
    PByte(@Result[SizeBody1 + SizePrefetch +  44])^ := Shift;
    PByte(@Result[SizeBody1 + SizePrefetch + 129])^ := Shift;
    PByte(@Result[SizeBody1 + SizePrefetch + 211])^ := Shift;
  end;
end;
{$endif TrialLimited}

procedure Apply256BmpMaskS(
  Apply256BmpMaskSSubProc, Apply256BmpMaskSAddProc: TApply256BmpMaskSProc;
  Work, Dst, Src, Mask: Pointer;
  ScanLineSize, MaskScanLineSize, Width, Height, Dif: Integer;
  UpdateRect, UnUpdateRect: TRect);
var
  Mode: Longint;
  UpdParBmp,
  UpdParMsk: TTEUpdParams;
  Apply256BmpMaskSProc: TApply256BmpMaskSProc;
begin
  Mode := GiveMeTheUpdMode(Width, 0, 8, UpdateRect, UnUpdateRect, pf8bit);
  GiveMeTheUpdParams(Mode, UpdParBmp, ScanLineSize, UpdateRect, UnUpdateRect,
    pf32bit);
  GiveMeTheUpdParams(Mode, UpdParMsk, MaskScanLineSize, UpdateRect,
    UnUpdateRect, pf8bit);

  if Dif >= 0
  then Apply256BmpMaskSProc := Apply256BmpMaskSSubProc
  else
  begin
    Dif := -Dif;
    Apply256BmpMaskSProc := Apply256BmpMaskSAddProc;
  end;

  case Mode of
    1,
    2:
      begin
        Apply256BmpMaskSProc(
          PChar(Work) - UpdParBmp.Start1,
          PChar(Dst ) - UpdParBmp.Start1,
          PChar(Src ) - UpdParBmp.Start1,
          PChar(Mask) - UpdParMsk.Start1,
          -UpdParMsk.Lenght1,
          UpdParMsk.RowLenght1,
          UpdParMsk.Gap1,
          Dif);
      end;
    3:
      begin
        Apply256BmpMaskSProc(
          PChar(Work) - UpdParBmp.Start1,
          PChar(Dst ) - UpdParBmp.Start1,
          PChar(Src ) - UpdParBmp.Start1,
          PChar(Mask) - UpdParMsk.Start1,
          -UpdParMsk.Lenght1,
          UpdParMsk.RowLenght1,
          UpdParMsk.Gap1,
          Dif);
        Apply256BmpMaskSProc(
          PChar(Work) - UpdParBmp.Start2,
          PChar(Dst ) - UpdParBmp.Start2,
          PChar(Src ) - UpdParBmp.Start2,
          PChar(Mask) - UpdParMsk.Start2,
          -UpdParMsk.Lenght2,
          UpdParMsk.RowLenght2,
          UpdParMsk.Gap2,
          Dif);
        Apply256BmpMaskSProc(
          PChar(Work) - UpdParBmp.Start3,
          PChar(Dst ) - UpdParBmp.Start3,
          PChar(Src ) - UpdParBmp.Start3,
          PChar(Mask) - UpdParMsk.Start3,
          -UpdParMsk.Lenght3,
          UpdParMsk.RowLenght3,
          UpdParMsk.Gap3,
          Dif);
        Apply256BmpMaskSProc(
          PChar(Work) - UpdParBmp.Start4,
          PChar(Dst ) - UpdParBmp.Start4,
          PChar(Src ) - UpdParBmp.Start4,
          PChar(Mask) - UpdParMsk.Start4,
          -UpdParMsk.Lenght4,
          UpdParMsk.RowLenght4,
          UpdParMsk.Gap4,
          Dif);
      end;
  end;
end;

end.