Changeset 494 for GraphicTest/Packages/bgrabitmap/bgradithering.pas

Timestamp:

Dec 22, 2016, 8:49:19 PM (8 years ago)

Author:

chronos

Message:

• Modified: Updated BGRABitmap package.

File:

• GraphicTest/Packages/bgrabitmap/bgradithering.pas (modified) (17 diffs)

GraphicTest/Packages/bgrabitmap/bgradithering.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, BGRAFilters, BGRAPalette, BGRABitmapTypes;
+  Classes, SysUtils, BGRAFilterType, BGRAPalette, BGRABitmapTypes;
 
 type
+  TOutputPixelProc = procedure(X,Y: NativeInt; AColorIndex: NativeInt; AColor: TBGRAPixel) of object;
 
   { TDitheringTask }
@@ -17 +18 @@
     FIgnoreAlpha: boolean;
     FPalette: TBGRACustomApproxPalette;
+    FCurrentOutputScanline: PBGRAPixel;
+    FCurrentOutputY: NativeInt;
+    FOutputPixel : TOutputPixelProc;
+    FDrawMode: TDrawMode;
+    procedure OutputPixel(X,Y: NativeInt; {%H-}AColorIndex: NativeInt; AColor: TBGRAPixel); virtual;
+    procedure ApproximateColor(const AColor: TBGRAPixel; out AApproxColor: TBGRAPixel; out AIndex: integer);
   public
+    constructor Create(ASource: IBGRAScanner; APalette: TBGRACustomApproxPalette; ADestination: TBGRACustomBitmap; AIgnoreAlpha: boolean; ABounds: TRect); overload;
     constructor Create(bmp: TBGRACustomBitmap; APalette: TBGRACustomApproxPalette; AInPlace: boolean; AIgnoreAlpha: boolean; ABounds: TRect); overload;
     constructor Create(bmp: TBGRACustomBitmap; APalette: TBGRACustomApproxPalette; AInPlace: boolean; AIgnoreAlpha: boolean); overload;
+    property OnOutputPixel: TOutputPixelProc read FOutputPixel write FOutputPixel;
+    property DrawMode: TDrawMode read FDrawMode write FDrawMode;
   end;
 
@@ -34 +44 @@
   protected
     procedure DoExecute; override;
+  end;
+
+  { TDitheringToIndexedImage }
+
+  TDitheringToIndexedImage = class
+  protected
+    FBitOrder: TRawImageBitOrder;
+    FByteOrder: TRawImageByteOrder;
+    FBitsPerPixel: integer;
+    FLineOrder: TRawImageLineOrder;
+    FPalette: TBGRACustomApproxPalette;
+    FIgnoreAlpha: boolean;
+    FTransparentColorIndex: NativeInt;
+
+    //following variables are used during dithering
+    FCurrentScanlineSize: PtrInt;
+    FCurrentData: PByte;
+    FCurrentOutputY: NativeInt;
+    FCurrentOutputScanline: PByte;
+    FCurrentBitOrderMask: NativeInt;
+    FCurrentMaxY: NativeInt;
+
+    procedure SetPalette(AValue: TBGRACustomApproxPalette);
+    procedure SetIgnoreAlpha(AValue: boolean);
+    procedure SetLineOrder(AValue: TRawImageLineOrder);
+    procedure SetBitOrder(AValue: TRawImageBitOrder); virtual;
+    procedure SetBitsPerPixel(AValue: integer); virtual;
+    procedure SetByteOrder(AValue: TRawImageByteOrder); virtual;
+    procedure OutputPixelSubByte(X,Y: NativeInt; AColorIndex: NativeInt; {%H-}AColor: TBGRAPixel); virtual;
+    procedure OutputPixelFullByte(X,Y: NativeInt; AColorIndex: NativeInt; {%H-}AColor: TBGRAPixel); virtual;
+    function GetScanline(Y: NativeInt): Pointer; virtual;
+    function GetTransparentColorIndex: integer;
+    procedure SetTransparentColorIndex(AValue: integer);
+  public
+    constructor Create(APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABitsPerPixelForIndices: integer); //use platform byte order
+    constructor Create(APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABitsPerPixelForIndices: integer; AByteOrder: TRawImageByteOrder); //maybe necessary if larger than 8 bits per pixel
+
+    function DitherImage(AAlgorithm: TDitheringAlgorithm; AImage: TBGRACustomBitmap): Pointer; overload; //use minimum scanline size
+    function DitherImage(AAlgorithm: TDitheringAlgorithm; AImage: TBGRACustomBitmap; AScanlineSize: PtrInt): Pointer; overload;
+    procedure DitherImageTo(AAlgorithm: TDitheringAlgorithm; AImage: TBGRACustomBitmap; AData: Pointer); overload; //use minimum scanline size
+    procedure DitherImageTo(AAlgorithm: TDitheringAlgorithm; AImage: TBGRACustomBitmap; AData: Pointer; AScanlineSize: PtrInt); overload;
+    function ComputeMinimumScanlineSize(AWidthInPixels: integer): PtrInt;
+    function AllocateSpaceForIndexedData(AImage: TBGRACustomBitmap; AScanlineSize: PtrInt): pointer;
+
+    //optional customization of format
+    property BitsPerPixel: integer read FBitsPerPixel write SetBitsPerPixel;
+    property BitOrder: TRawImageBitOrder read FBitOrder write SetBitOrder;
+    property ByteOrder: TRawImageByteOrder read FByteOrder write SetByteOrder;
+    property LineOrder: TRawImageLineOrder read FLineOrder write SetLineOrder;
+
+    property Palette: TBGRACustomApproxPalette read FPalette write SetPalette;
+    property IgnoreAlpha: boolean read FIgnoreAlpha write SetIgnoreAlpha;
+
+    //when there is no transparent color in the palette, or that IgnoreAlpha is set to True,
+    //this allows to define the index for the fully transparent color
+    property DefaultTransparentColorIndex: integer read GetTransparentColorIndex write SetTransparentColorIndex;
   end;
 
@@ -40 +106 @@
 function CreateDitheringTask(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; APalette: TBGRACustomApproxPalette;
   AIgnoreAlpha: boolean; ABounds: TRect): TDitheringTask; overload;
+function CreateDitheringTask(AAlgorithm: TDitheringAlgorithm; ASource: IBGRAScanner; ADestination: TBGRACustomBitmap; ABounds: TRect): TDitheringTask; overload;
+function CreateDitheringTask(AAlgorithm: TDitheringAlgorithm; ASource: IBGRAScanner; ADestination: TBGRACustomBitmap; APalette: TBGRACustomApproxPalette;
+    AIgnoreAlpha: boolean; ABounds: TRect): TDitheringTask; overload;
+
+function DitherImageTo16Bit(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap): TBGRACustomBitmap;
 
 implementation
+
+uses BGRABlend;
 
 function AbsRGBADiff(const c1, c2: TExpandedPixel): NativeInt;
@@ -68 +141 @@
 end;
 
+function CreateDitheringTask(AAlgorithm: TDitheringAlgorithm;
+  ASource: IBGRAScanner; ADestination: TBGRACustomBitmap; ABounds: TRect
+  ): TDitheringTask;
+begin
+  result := CreateDitheringTask(AAlgorithm, ASource, ADestination, nil, true, ABounds);
+end;
+
+function CreateDitheringTask(AAlgorithm: TDitheringAlgorithm;
+  ASource: IBGRAScanner; ADestination: TBGRACustomBitmap;
+  APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABounds: TRect
+  ): TDitheringTask;
+begin
+  result := nil;
+  case AAlgorithm of
+    daNearestNeighbor: result := TNearestColorTask.Create(ASource, APalette, ADestination, AIgnoreAlpha, ABounds);
+    daFloydSteinberg: result := TFloydSteinbergDitheringTask.Create(ASource, APalette, ADestination, AIgnoreAlpha, ABounds);
+    else raise exception.Create('Unknown algorithm');
+  end;
+end;
+
+function DitherImageTo16Bit(AAlgorithm: TDitheringAlgorithm;
+  ABitmap: TBGRACustomBitmap): TBGRACustomBitmap;
+var
+  palette16bit: TBGRA16BitPalette;
+  dither: TDitheringTask;
+begin
+  palette16bit := TBGRA16BitPalette.Create;
+  dither := CreateDitheringTask(AAlgorithm, ABitmap, palette16bit, false);
+  result := dither.Execute;
+  dither.Free;
+  palette16bit.Free;
+end;
+
+{ TDitheringToIndexedImage }
+
+procedure TDitheringToIndexedImage.SetBitsPerPixel(AValue: integer);
+begin
+  if not (AValue in [1,2,4,8,16,32]) then
+    raise exception.Create('Invalid value for bits per pixel. Allowed values: 1,2,4,8,16,32.');
+  if FBitsPerPixel=AValue then Exit;
+  FBitsPerPixel:=AValue;
+end;
+
+procedure TDitheringToIndexedImage.SetByteOrder(AValue: TRawImageByteOrder);
+begin
+  if FByteOrder=AValue then Exit;
+  FByteOrder:=AValue;
+end;
+
+procedure TDitheringToIndexedImage.OutputPixelSubByte(X, Y: NativeInt;
+  AColorIndex: NativeInt; AColor: TBGRAPixel);
+var p: PByte;
+begin
+  if y <> FCurrentOutputY then
+  begin
+    FCurrentOutputY := y;
+    FCurrentOutputScanline := GetScanline(Y);
+  end;
+  if AColorIndex = -1 then AColorIndex := FTransparentColorIndex;
+  case FBitsPerPixel of
+    1: begin
+         p := FCurrentOutputScanline+(x shr 3);
+         p^ := p^ or ((AColorIndex and 1) shl ((x xor FCurrentBitOrderMask) and 7));
+       end;
+    2: begin
+         p := FCurrentOutputScanline+(x shr 2);
+         p^ := p^ or ((AColorIndex and 1) shl (((x xor FCurrentBitOrderMask) and 3) shl 1));
+       end;
+    4: begin
+         p := FCurrentOutputScanline+(x shr 1);
+         p^ := p^ or ((AColorIndex and 1) shl (((x xor FCurrentBitOrderMask) and 1) shl 2));
+       end;
+  end;
+end;
+
+procedure TDitheringToIndexedImage.OutputPixelFullByte(X, Y: NativeInt;
+  AColorIndex: NativeInt; AColor: TBGRAPixel);
+begin
+  if y <> FCurrentOutputY then
+  begin
+    FCurrentOutputY := y;
+    FCurrentOutputScanline := GetScanline(Y);
+  end;
+  if AColorIndex = -1 then AColorIndex := FTransparentColorIndex;
+  case FBitsPerPixel of
+    8: (FCurrentOutputScanline+x)^ := AColorIndex;
+    16: (PWord(FCurrentOutputScanline)+x)^ := AColorIndex;
+    32: (PDWord(FCurrentOutputScanline)+x)^ := AColorIndex;
+  end;
+end;
+
+function TDitheringToIndexedImage.GetScanline(Y: NativeInt): Pointer;
+begin
+  if FLineOrder = riloTopToBottom then
+    result := FCurrentData + Y*FCurrentScanlineSize
+  else
+    result := FCurrentData + (FCurrentMaxY-Y)*FCurrentScanlineSize
+end;
+
+procedure TDitheringToIndexedImage.SetIgnoreAlpha(AValue: boolean);
+begin
+  if FIgnoreAlpha=AValue then Exit;
+  FIgnoreAlpha:=AValue;
+end;
+
+procedure TDitheringToIndexedImage.SetTransparentColorIndex(AValue: integer);
+begin
+  if FTransparentColorIndex=AValue then Exit;
+  FTransparentColorIndex:=AValue;
+end;
+
+function TDitheringToIndexedImage.GetTransparentColorIndex: integer;
+begin
+  result := FTransparentColorIndex;
+end;
+
+procedure TDitheringToIndexedImage.SetPalette(AValue: TBGRACustomApproxPalette);
+begin
+  if FPalette=AValue then Exit;
+  FPalette:=AValue;
+end;
+
+procedure TDitheringToIndexedImage.SetLineOrder(AValue: TRawImageLineOrder);
+begin
+  if FLineOrder=AValue then Exit;
+  FLineOrder:=AValue;
+end;
+
+procedure TDitheringToIndexedImage.SetBitOrder(AValue: TRawImageBitOrder);
+begin
+  if FBitOrder=AValue then Exit;
+  FBitOrder:=AValue;
+end;
+
+constructor TDitheringToIndexedImage.Create(APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABitsPerPixelForIndices: integer);
+begin
+  BitsPerPixel:= ABitsPerPixelForIndices;
+  BitOrder := riboReversedBits; //convention in BMP format
+  {$IFDEF ENDIAN_LITTLE}
+  ByteOrder:= riboLSBFirst;
+  {$ELSE}
+  ByteOrder:= riboMSBFirst;
+  {$ENDIF}
+  Palette := APalette;
+  IgnoreAlpha:= AIgnoreAlpha;
+end;
+
+constructor TDitheringToIndexedImage.Create(APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABitsPerPixelForIndices: integer;
+  AByteOrder: TRawImageByteOrder);
+begin
+  BitsPerPixel:= ABitsPerPixelForIndices;
+  BitOrder := riboReversedBits; //convention in BMP format
+  ByteOrder:= AByteOrder;
+  Palette := APalette;
+  IgnoreAlpha:= AIgnoreAlpha;
+end;
+
+function TDitheringToIndexedImage.ComputeMinimumScanlineSize(
+  AWidthInPixels: integer): PtrInt;
+begin
+  result := (AWidthInPixels*FBitsPerPixel+7) shr 3;
+end;
+
+function TDitheringToIndexedImage.AllocateSpaceForIndexedData(AImage: TBGRACustomBitmap;
+  AScanlineSize: PtrInt): pointer;
+var size: integer;
+begin
+  size := AScanlineSize * AImage.Height;
+  GetMem(result, size);
+  Fillchar(result^, size, 0);
+end;
+
+function TDitheringToIndexedImage.DitherImage(AAlgorithm: TDitheringAlgorithm;
+  AImage: TBGRACustomBitmap): Pointer;
+begin
+  result := DitherImage(AAlgorithm, AImage, ComputeMinimumScanlineSize(AImage.Width));
+end;
+
+procedure TDitheringToIndexedImage.DitherImageTo(AAlgorithm: TDitheringAlgorithm;
+  AImage: TBGRACustomBitmap; AData: Pointer);
+begin
+  DitherImageTo(AAlgorithm, AImage, AData, ComputeMinimumScanlineSize(AImage.Width));
+end;
+
+function TDitheringToIndexedImage.DitherImage(AAlgorithm: TDitheringAlgorithm;
+  AImage: TBGRACustomBitmap; AScanlineSize: PtrInt): Pointer;
+begin
+  result := AllocateSpaceForIndexedData(AImage, AScanlineSize);
+  DitherImageTo(AAlgorithm, AImage, result, AScanlineSize);
+end;
+
+procedure TDitheringToIndexedImage.DitherImageTo(AAlgorithm: TDitheringAlgorithm;
+  AImage: TBGRACustomBitmap; AData: Pointer; AScanlineSize: PtrInt);
+var ditherTask: TDitheringTask;
+begin
+  FCurrentOutputY := -1;
+  FCurrentOutputScanline := nil;
+  FCurrentData := AData;
+  FCurrentMaxY:= AImage.Height-1;
+  FCurrentScanlineSize:= AScanlineSize;
+
+  ditherTask := CreateDitheringTask(AAlgorithm, AImage, FPalette, FIgnoreAlpha);
+  try
+    ditherTask.Inplace := True; //do not allocate destination
+    if BitsPerPixel >= 8 then
+      ditherTask.OnOutputPixel := @OutputPixelFullByte
+    else
+    begin
+      ditherTask.OnOutputPixel:= @OutputPixelSubByte;
+      if BitOrder = riboBitsInOrder then
+        FCurrentBitOrderMask := 0
+      else
+        FCurrentBitOrderMask := $ff;
+    end;
+    ditherTask.Execute;
+  finally
+    ditherTask.Free;
+  end;
+end;
+
 { TDitheringTask }
+
+procedure TDitheringTask.OutputPixel(X, Y: NativeInt; AColorIndex: NativeInt;
+  AColor: TBGRAPixel);
+begin
+  if Y <> FCurrentOutputY then
+  begin
+    FCurrentOutputY := Y;
+    FCurrentOutputScanline := Destination.ScanLine[y];
+  end;
+  PutPixels(FCurrentOutputScanline+x, @AColor, 1, FDrawMode, 255);
+end;
+
+procedure TDitheringTask.ApproximateColor(const AColor: TBGRAPixel;
+  out AApproxColor: TBGRAPixel; out AIndex: integer);
+begin
+  if FPalette <> nil then
+  begin
+    AIndex := FPalette.FindNearestColorIndex(AColor, FIgnoreAlpha);
+    if AIndex = -1 then
+      AApproxColor := BGRAPixelTransparent
+    else
+      AApproxColor := FPalette.Color[AIndex];
+  end else
+  begin
+    if AColor.alpha = 0 then
+    begin
+      AApproxColor := BGRAPixelTransparent;
+      AIndex := -1;
+    end else
+    begin
+      AApproxColor := AColor;
+      AIndex := 0;
+    end;
+  end;
+end;
+
+constructor TDitheringTask.Create(ASource: IBGRAScanner;
+  APalette: TBGRACustomApproxPalette; ADestination: TBGRACustomBitmap;
+  AIgnoreAlpha: boolean; ABounds: TRect);
+begin
+  FPalette := APalette;
+  SetSource(ASource);
+  FBounds := ABounds;
+  FIgnoreAlpha:= AIgnoreAlpha;
+  FCurrentOutputY := -1;
+  FCurrentOutputScanline:= nil;
+  OnOutputPixel:= @OutputPixel;
+  Destination := ADestination;
+  FDrawMode:= dmSet;
+end;
 
 constructor TDitheringTask.Create(bmp: TBGRACustomBitmap;
@@ -75 +418 @@
 begin
   FPalette := APalette;
-  FSource := bmp;
+  SetSource(bmp);
   FBounds := ABounds;
   FIgnoreAlpha:= AIgnoreAlpha;
-  if AInPlace then Destination := FSource;
+  FCurrentOutputY := -1;
+  FCurrentOutputScanline:= nil;
+  OnOutputPixel:= @OutputPixel;
+  InPlace := AInPlace;
+  FDrawMode:= dmSet;
 end;
 
@@ -85 +432 @@
 begin
   FPalette := APalette;
-  FSource := bmp;
+  SetSource(bmp);
   FBounds := rect(0,0,bmp.Width,bmp.Height);
   FIgnoreAlpha:= AIgnoreAlpha;
-  if AInPlace then Destination := FSource;
+  FCurrentOutputY := -1;
+  FCurrentOutputScanline:= nil;
+  OnOutputPixel:= @OutputPixel;
+  InPlace := AInPlace;
+  FDrawMode:= dmSet;
 end;
 
@@ -125 +476 @@
 
 var
-  p,pNext,pDest: PBGRAPixel;
+  p,pNext: PExpandedPixel;
+  destX,destY: NativeInt;
   orig,cur,approxExp: TExpandedPixel;
   approx: TBGRAPixel;
+  approxIndex: integer;
   curPix,diff: TAccPixel;
   i: NativeInt;
   yWrite: NativeInt;
   tempLine, currentLine, nextLine: TLine;
+
+  nextScan,curScan: PExpandedPixel;
 
   function ClampWordDiv(AValue: NativeInt): Word; inline;
@@ -158 +513 @@
   setlength(currentLine,w);
   setlength(nextLine,w);
+  curScan := nil;
+  nextScan := RequestSourceExpandedScanLine(FBounds.Left, FBounds.Top, FBounds.Right-FBounds.Left);
   for yWrite := 0 to h-1 do
   begin
     if GetShouldStop(yWrite) then break;
-    p := FSource.ScanLine[yWrite+FBounds.Top]+FBounds.Left;
-    pDest := FDestination.ScanLine[yWrite+FBounds.Top]+FBounds.Left;
+    ReleaseSourceExpandedScanLine(curScan);
+    curScan := nextScan;
+    nextScan := nil;
+    p := curScan;
+    destX := FBounds.Left;
+    destY := yWrite+FBounds.Top;
     if yWrite < h-1 then
-      pNext := FSource.ScanLine[yWrite+FBounds.Top+1]+FBounds.Left
-    else
-      pNext := nil;
+      nextScan := RequestSourceExpandedScanLine(FBounds.Left,yWrite+FBounds.Top+1, FBounds.Right-FBounds.Left);
+    pNext := nextScan;
     if odd(yWrite) then
     begin
       inc(p, w);
-      inc(pDest, w);
+      inc(destX, w);
       if pNext<>nil then inc(pNext, w);
       for i := w-1 downto 0 do
       begin
         dec(p);
-        dec(pDest);
+        dec(destX);
         if pNext<>nil then dec(pNext);
         if p^.alpha <> 0 then
         begin
-          orig := GammaExpansion(p^);
+          orig := p^;
           with currentLine[i] do
           begin
@@ -191 +551 @@
             cur.blue := ClampWordDiv(curPix.blue);
           end;
-          approx := FPalette.FindNearestColor(GammaCompression(cur), FIgnoreAlpha);
+          ApproximateColor(GammaCompression(cur), approx, approxIndex);
           approxExp := GammaExpansion(approx);
           diff.alpha := Div16(curPix.alpha - (approxExp.alpha shl ErrorPrecisionShift));
@@ -207 +567 @@
           if i > 0 then
           begin
-            if AbsRGBADiff(GammaExpansion((p-1)^),orig) < MaxColorDiffForDiffusion then
+            if AbsRGBADiff((p-1)^,orig) < MaxColorDiffForDiffusion then
               AddError(currentLine[i-1], diff, 7);
           end;
@@ -214 +574 @@
             if i > 0 then
             begin
-              if AbsRGBADiff(GammaExpansion((pNext-1)^),orig) < MaxColorDiffForDiffusion then
+              if AbsRGBADiff((pNext-1)^,orig) < MaxColorDiffForDiffusion then
                 AddError(nextLine[i-1], diff, 1);
             end;
-            if AbsRGBADiff(GammaExpansion(pNext^),orig) < MaxColorDiffForDiffusion then
+            if AbsRGBADiff(pNext^,orig) < MaxColorDiffForDiffusion then
               AddError(nextLine[i], diff, 5);
             if i < w-1 then
             begin
-              if AbsRGBADiff(GammaExpansion((pNext+1)^),orig) < MaxColorDiffForDiffusion then
+              if AbsRGBADiff((pNext+1)^,orig) < MaxColorDiffForDiffusion then
                 AddError(nextLine[i+1], diff, 3);
             end;
           end;
-          pDest^ := approx;
+          OnOutputPixel(destX,destY,approxIndex,approx);
         end;
       end
@@ -234 +594 @@
       if p^.alpha <> 0 then
       begin
-        orig := GammaExpansion(p^);
+        orig := p^;
         with currentLine[i] do
         begin
@@ -246 +606 @@
           cur.blue := ClampWordDiv(curPix.blue);
         end;
-        approx := FPalette.FindNearestColor(GammaCompression(cur), FIgnoreAlpha);
+        ApproximateColor(GammaCompression(cur), approx, approxIndex);
         approxExp := GammaExpansion(approx);
         diff.alpha := Div16(curPix.alpha - (approxExp.alpha shl ErrorPrecisionShift));
@@ -262 +622 @@
         if i < w-1 then
         begin
-          if AbsRGBADiff(GammaExpansion((p+1)^),orig) < MaxColorDiffForDiffusion then
+          if AbsRGBADiff((p+1)^,orig) < MaxColorDiffForDiffusion then
             AddError(currentLine[i+1], diff, 7);
         end;
-        if nextLine <> nil then
+        if pNext <> nil then
         begin
           if i > 0 then
           begin
-            if AbsRGBADiff(GammaExpansion((pNext-1)^),orig) < MaxColorDiffForDiffusion then
+            if AbsRGBADiff((pNext-1)^,orig) < MaxColorDiffForDiffusion then
               AddError(nextLine[i-1], diff, 3);
           end;
-          if AbsRGBADiff(GammaExpansion(pNext^),orig) < MaxColorDiffForDiffusion then
+          if AbsRGBADiff(pNext^,orig) < MaxColorDiffForDiffusion then
             AddError(nextLine[i], diff, 5);
           if i < w-1 then
           begin
-            if AbsRGBADiff(GammaExpansion((pNext+1)^),orig) < MaxColorDiffForDiffusion then
+            if AbsRGBADiff((pNext+1)^,orig) < MaxColorDiffForDiffusion then
               AddError(nextLine[i+1], diff, 1);
           end;
         end;
-        pDest^ := approx;
+        OnOutputPixel(destX,destY,approxIndex,approx);
       end;
       inc(p);
-      inc(pDest);
+      inc(destX);
       if pNext<>nil then inc(pNext);
     end;
@@ -300 +660 @@
       end;
   end;
-  FDestination.InvalidateBitmap;
+  ReleaseSourceExpandedScanLine(curScan);
+  ReleaseSourceExpandedScanLine(nextScan);
+  Destination.InvalidateBitmap;
 end;
 
@@ -306 +668 @@
 
 procedure TNearestColorTask.DoExecute;
-var yb,xb: integer;
-  psrc,pdest: PBGRAPixel;
+var yb,xb: NativeInt;
+  curScan,psrc: PBGRAPixel;
+  colorIndex: LongInt;
+  colorValue: TBGRAPixel;
 begin
   for yb := FBounds.Top to FBounds.Bottom - 1 do
   begin
     if GetShouldStop(yb) then break;
-    psrc := FSource.ScanLine[yb] + FBounds.Left;
-    pdest := FDestination.ScanLine[yb] + FBounds.Left;
-    for xb := FBounds.Right - FBounds.Left -1 downto 0 do
+    curScan := RequestSourceScanLine(FBounds.Left,yb,FBounds.Right-FBounds.Left);
+    psrc := curScan;
+    for xb := FBounds.Left to FBounds.Right-1 do
     begin
-      pdest^ := FPalette.FindNearestColor(psrc^, FIgnoreAlpha);
-      inc(pdest);
+      ApproximateColor(psrc^, colorValue, colorIndex);
+      OnOutputPixel(xb,yb,colorIndex,colorValue);
       inc(psrc);
     end;
-  end;
-  FDestination.InvalidateBitmap;
+    ReleaseSourceScanLine(curScan);
+  end;
+  Destination.InvalidateBitmap;
 end;