//
// AggPas 2.4 RM3 pixel format definition file
//
{ blend_pix_gray_pre }
procedure blend_pix_gray_pre(p : int8u_ptr; cv ,alpha ,cover : unsigned ); overload;
begin
 alpha:=base_mask - alpha;
 cover:=(cover + 1 ) shl (base_shift - 8 );

 p^:=int8u((p^ * alpha + cv * cover ) shr base_shift );

end;

{ blend_pix_gray_pre }
procedure blend_pix_gray_pre(p : int8u_ptr; cv ,alpha : unsigned ); overload;
begin
 p^:=int8u(((p^ * (base_mask - alpha ) ) shr base_shift ) + cv );

end;

{ copy_or_blend_pix_gray_pre }
procedure copy_or_blend_pix_gray_pre(p : int8u_ptr; c : aggclr_ptr; cover : unsigned ); overload;
var
 alpha : unsigned;

begin
 if  c.a <> 0 then
  begin
   alpha:=(c.a * (cover + 1 ) ) shr 8;

   if alpha = base_mask then
    p^:=c.v
   else
    blend_pix_gray_pre(p ,c.v ,alpha ,cover );

  end;

end;

{ copy_or_blend_pix_pre }
procedure copy_or_blend_pix_pre(p : int8u_ptr; c : aggclr_ptr ); overload;
begin
 if c.a <> 0 then
  if c.a = base_mask then
   p^:=c.v
  else
   blend_pix_gray_pre(p ,c.v ,c.a );

end;

{ gray8_pre_blend_pixel }
procedure gray8_pre_blend_pixel(this : pixel_formats_ptr; x ,y : int; c : aggclr_ptr; cover : int8u );
begin
 copy_or_blend_pix_gray_pre(
  int8u_ptr(ptrcomp(this.m_rbuf.row(y ) ) + x * this.m_step + this.m_offset ) ,
  c ,cover );

end;

{ gray8_pre_blend_hline }
procedure gray8_pre_blend_hline(this : pixel_formats_ptr; x ,y : int; len : unsigned; c : aggclr_ptr; cover : int8u );
var
 p : int8u_ptr;

 alpha : unsigned;

begin
 if c.a <> 0 then
  begin
   p:=int8u_ptr(ptrcomp(this.m_rbuf.row(y ) ) + x * this.m_step + this.m_offset );

   alpha:=(c.a * (cover + 1 ) ) shr 8;

   if alpha = base_mask then
    repeat
     p^:=c.v;

     inc(ptrcomp(p ) ,this.m_step );
     dec(len );

    until len = 0
   else
    repeat
     blend_pix_gray_pre(p ,c.v ,alpha ,cover );

     inc(ptrcomp(p ) ,this.m_step );
     dec(len );

    until len = 0;

  end;

end;

{ gray8_pre_blend_vline }
procedure gray8_pre_blend_vline(this : pixel_formats_ptr; x ,y : int; len : unsigned; c : aggclr_ptr; cover : int8u );
var
 p : int8u_ptr;

 alpha : unsigned;

begin
 if c.a <> 0 then
  begin
   p:=int8u_ptr(ptrcomp(this.m_rbuf.row(y ) ) + x * this.m_step + this.m_offset );

   alpha:=(c.a * (cover + 1 ) ) shr 8;

   if alpha = base_mask then
    repeat
     p^:=c.v;
     p :=this.m_rbuf.next_row(p );

     dec(len );

    until len = 0
   else
    repeat
     blend_pix_gray_pre(p ,c.v ,alpha ,cover );

     p:=this.m_rbuf.next_row(p );

     dec(len );

    until len = 0;

  end;

end;

{ gray8_pre_blend_solid_hspan }
procedure gray8_pre_blend_solid_hspan(this : pixel_formats_ptr; x ,y : int; len : unsigned; c : aggclr_ptr; covers : int8u_ptr );
var
 p : int8u_ptr;

 alpha : unsigned;

begin
 if c.a <> 0 then
  begin
   p:=int8u_ptr(ptrcomp(this.m_rbuf.row(y ) ) + x * this.m_step + this.m_offset );

   repeat
    alpha:=(c.a * (covers^ + 1 ) ) shr 8;

    if alpha = base_mask then
     p^:=c.v
    else
     blend_pix_gray_pre(p ,c.v ,alpha ,covers^ );

    inc(ptrcomp(p ) ,this.m_step );
    inc(ptrcomp(covers ) );
    dec(len );

   until len = 0;

  end;

end;

{ gray8_pre_blend_solid_vspan }
procedure gray8_pre_blend_solid_vspan(this : pixel_formats_ptr; x ,y : int; len : unsigned; c : aggclr_ptr; covers : int8u_ptr );
var
 p : int8u_ptr;

 alpha : unsigned;

begin
 if c.a <> 0 then
  begin
   p:=int8u_ptr(ptrcomp(this.m_rbuf.row(y ) ) + x * this.m_step + this.m_offset );

   repeat
    alpha:=(c.a * (covers^ + 1 ) ) shr 8;

    if alpha = base_mask then
     p^:=c.v
    else
     blend_pix_gray_pre(p ,c.v ,alpha ,covers^ );

    p:=this.m_rbuf.next_row(p );

    inc(ptrcomp(covers ) ,sizeof(int8u ) );
    dec(len );

   until len = 0;

  end;

end;

{ gray8_pre_blend_color_hspan }
procedure gray8_pre_blend_color_hspan(this : pixel_formats_ptr; x ,y : int; len : unsigned; colors : aggclr_ptr; covers : int8u_ptr; cover : int8u );
var
 p : int8u_ptr;

begin
 p:=int8u_ptr(ptrcomp(this.m_rbuf.row(y ) ) + x * this.m_step + this.m_offset );

 if covers <> NIL then
  repeat
   copy_or_blend_pix_gray_pre(p ,colors ,covers^ );

   inc(ptrcomp(colors ) ,sizeof(aggclr ) );
   inc(ptrcomp(covers ) ,sizeof(int8u ) );
   inc(ptrcomp(p ) ,this.m_step );
   dec(len );

  until len = 0
 else
  if cover = 255 then
   repeat
    if colors.a = base_mask then
     p^:=colors.v
    else
     copy_or_blend_pix_pre(p ,colors );

    inc(ptrcomp(colors ) ,sizeof(aggclr ) );
    inc(ptrcomp(p ) ,this.m_step );
    dec(len );

   until len = 0
  else
   repeat
    copy_or_blend_pix_gray_pre(p ,colors ,cover );

    inc(ptrcomp(colors ) ,sizeof(aggclr ) );
    inc(ptrcomp(p ) ,this.m_step );
    dec(len );

   until len = 0;

end;

{ gray8_pre_blend_color_vspan }
procedure gray8_pre_blend_color_vspan(this : pixel_formats_ptr; x ,y : int; len : unsigned; colors : aggclr_ptr; covers : int8u_ptr; cover : int8u );
var
 p : int8u_ptr;

begin
 p:=int8u_ptr(ptrcomp(this.m_rbuf.row(y ) ) + x * this.m_step + this.m_offset );

 if covers <> NIL then
  repeat
   copy_or_blend_pix_gray_pre(p ,colors ,covers^ );

   inc(ptrcomp(colors ) ,sizeof(aggclr ) );
   inc(ptrcomp(covers ) ,sizeof(int8u ) );

   p:=this.m_rbuf.next_row(p );

   dec(len );

  until len = 0
 else
  if cover = 255 then
   repeat
    if colors.a = base_mask then
     p^:=colors.v
    else
     copy_or_blend_pix_pre(p ,colors );

    p:=this.m_rbuf.next_row(p );

    inc(ptrcomp(colors ) ,sizeof(aggclr ) );
    dec(len );

   until len = 0

  else
   repeat
    copy_or_blend_pix_gray_pre(p ,colors ,cover );

    inc(ptrcomp(colors ) ,sizeof(aggclr ) );

    p:=this.m_rbuf.next_row(p );

    dec(len );

   until len = 0;

end;

{ gray8_pre_blend_from_color }
procedure gray8_pre_blend_from_color(this : pixel_formats_ptr; from : pixel_formats_ptr; color : aggclr_ptr; xdst ,ydst ,xsrc ,ysrc : int; len : unsigned; cover : int8u );
var
 ppsz : unsigned;

 psrc ,pdst : int8u_ptr;

begin
 ppsz:=from._pix_width;
 psrc:=from.row_ptr(ysrc );

 if psrc <> NIL then
  begin
   pdst:=int8u_ptr(ptrcomp(this.m_rbuf.row_xy(xdst ,ydst ,len ) ) + xdst * this.m_step + this.m_offset );

   repeat
    copy_or_blend_pix_gray_pre(
     pdst ,color ,
     shr_int32(psrc^ * cover + base_mask ,base_shift ) );

    inc(ptrcomp(psrc ) ,ppsz );
    inc(ptrcomp(pdst ) ,this.m_step );
    dec(len );

   until len = 0;

  end;

end;

{ gray8_pre_blend_from_lut }
procedure gray8_pre_blend_from_lut(this : pixel_formats_ptr; from : pixel_formats_ptr; color_lut : aggclr_ptr; xdst ,ydst ,xsrc ,ysrc : int; len : unsigned; cover : int8u );
var
 ppsz : unsigned;

 psrc ,pdst : int8u_ptr;

begin
 ppsz:=from._pix_width;
 psrc:=from.row_ptr(ysrc );

 if psrc <> NIL then
  begin
   pdst:=int8u_ptr(ptrcomp(this.m_rbuf.row_xy(xdst ,ydst ,len ) ) + xdst * this.m_step + this.m_offset );

   repeat
    copy_or_blend_pix_gray_pre(
     pdst ,aggclr_ptr(ptrcomp(color_lut ) + psrc^ * sizeof(aggclr ) ) ,cover );

    inc(ptrcomp(psrc ) ,ppsz );
    inc(ptrcomp(pdst ) ,this.m_step );
    dec(len );

   until len = 0;

  end;

end;