← Back to branch summary

~ubuntu-branches/ubuntu/saucy/lazarus/saucy

« back to all changes in this revision

Viewing changes to components/aggpas/src/pf_rgba32_pre.inc

  • Committer: Package Import Robot
  • Author(s): Paul Gevers, Abou Al Montacir, Bart Martens, Paul Gevers
  • Date: 2013-06-08 14:12:17 UTC
  • mfrom: (1.1.9)
  • Revision ID: package-import@ubuntu.com-20130608141217-7k0cy9id8ifcnutc
Tags: 1.0.8+dfsg-1
http://bugs.debian.org/708695
[ Abou Al Montacir ]
* New upstream major release and multiple maintenace release offering many
  fixes and new features marking a new milestone for the Lazarus development
  and its stability level.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_fixes_branch
* LCL changes:
  - LCL is now a normal package.
      + Platform independent parts of the LCL are now in the package LCLBase
      + LCL is automatically recompiled when switching the target platform,
        unless pre-compiled binaries for this target are already installed.
      + No impact on existing projects.
      + Linker options needed by LCL are no more added to projects that do
        not use the LCL package.
  - Minor changes in LCL basic classes behaviour
      + TCustomForm.Create raises an exception if a form resource is not
        found.
      + TNotebook and TPage: a new implementation of these classes was added.
      + TDBNavigator: It is now possible to have focusable buttons by setting
        Options = [navFocusableButtons] and TabStop = True, useful for
        accessibility and for devices with neither mouse nor touch screen.
      + Names of TControlBorderSpacing.GetSideSpace and GetSpace were swapped
        and are now consistent. GetSideSpace = Around + GetSpace.
      + TForm.WindowState=wsFullscreen was added
      + TCanvas.TextFitInfo was added to calculate how many characters will
        fit into a specified Width. Useful for word-wrapping calculations.
      + TControl.GetColorResolvingParent and
        TControl.GetRGBColorResolvingParent were added, simplifying the work
        to obtain the final color of the control while resolving clDefault
        and the ParentColor.
      + LCLIntf.GetTextExtentExPoint now has a good default implementation
        which works in any platform not providing a specific implementation.
        However, Widgetset specific implementation is better, when available.
      + TTabControl was reorganized. Now it has the correct class hierarchy
        and inherits from TCustomTabControl as it should.
  - New unit in the LCL:
      + lazdialogs.pas: adds non-native versions of various native dialogs,
        for example TLazOpenDialog, TLazSaveDialog, TLazSelectDirectoryDialog.
        It is used by widgetsets which either do not have a native dialog, or
        do not wish to use it because it is limited. These dialogs can also be
        used by user applications directly.
      + lazdeviceapis.pas: offers an interface to more hardware devices such
        as the accelerometer, GPS, etc. See LazDeviceAPIs
      + lazcanvas.pas: provides a TFPImageCanvas descendent implementing
        drawing in a LCL-compatible way, but 100% in Pascal.
      + lazregions.pas. LazRegions is a wholly Pascal implementation of
        regions for canvas clipping, event clipping, finding in which control
        of a region tree one an event should reach, for drawing polygons, etc.
      + customdrawncontrols.pas, customdrawndrawers.pas,
        customdrawn_common.pas, customdrawn_android.pas and
        customdrawn_winxp.pas: are the Lazarus Custom Drawn Controls -controls
        which imitate the standard LCL ones, but with the difference that they
        are non-native and support skinning.
  - New APIs added to the LCL to improve support of accessibility software
    such as screen readers.
* IDE changes:
  - Many improvments.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/New_IDE_features_since#v1.0_.282012-08-29.29
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes#IDE_Changes
* Debugger / Editor changes:
  - Added pascal sources and breakpoints to the disassembler
  - Added threads dialog.
* Components changes:
  - TAChart: many fixes and new features
  - CodeTool: support Delphi style generics and new syntax extensions.
  - AggPas: removed to honor free licencing. (Closes: Bug#708695)
[Bart Martens]
* New debian/watch file fixing issues with upstream RC release.
[Abou Al Montacir]
* Avoid changing files in .pc hidden directory, these are used by quilt for
  internal purpose and could lead to surprises during build.
[Paul Gevers]
* Updated get-orig-source target and it compinion script orig-tar.sh so that they
  repack the source file, allowing bug 708695 to be fixed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
components/aggpas/src/pf_rgba32_pre.inc
1
 
//
2
 
// AggPas 2.4 RM3 pixel format definition file
3
 
//
4
 
{ blend_pix_rgba_pre }
5
 
procedure blend_pix_rgba_pre(p : unsigned_ptr; cr ,cg ,cb ,alpha : unsigned ); overload;
6
 
begin
7
 
 alpha:=base_mask - alpha;
8
 
 
9
 
 order_rgba(p^ ).R:=int8u(((order_rgba(p^ ).R * alpha) shr base_shift ) + cr );
10
 
 order_rgba(p^ ).G:=int8u(((order_rgba(p^ ).G * alpha) shr base_shift ) + cg );
11
 
 order_rgba(p^ ).B:=int8u(((order_rgba(p^ ).B * alpha) shr base_shift ) + cb );
12
 
 order_rgba(p^ ).A:=int8u(base_mask - ((alpha * (base_mask - order_rgba(p^ ).A ) ) shr base_shift) );
13
 
 
14
 
end;
15
 
 
16
 
{ blend_pix_rgba_pre }
17
 
procedure blend_pix_rgba_pre(p : unsigned_ptr; cr ,cg ,cb ,alpha ,cover : unsigned ); overload;
18
 
begin
19
 
 alpha:=base_mask - alpha;
20
 
 cover:=(cover + 1 ) shl (base_shift - 8 );
21
 
 
22
 
 order_rgba(p^ ).R:=int8u((order_rgba(p^ ).R * alpha + cr * cover ) shr base_shift );
23
 
 order_rgba(p^ ).G:=int8u((order_rgba(p^ ).G * alpha + cg * cover ) shr base_shift );
24
 
 order_rgba(p^ ).B:=int8u((order_rgba(p^ ).B * alpha + cb * cover ) shr base_shift );
25
 
 order_rgba(p^ ).A:=int8u(base_mask - ((alpha * (base_mask - order_rgba(p^ ).A ) ) shr base_shift ) );
26
 
 
27
 
end;
28
 
 
29
 
{ copy_or_blend_pix_rgba_pre }
30
 
procedure copy_or_blend_pix_rgba_pre(p : unsigned_ptr; cr ,cg ,cb ,alpha : unsigned ); overload;
31
 
begin
32
 
 if alpha <> 0 then
33
 
  if alpha = base_mask then
34
 
   begin
35
 
    order_rgba(p^ ).R:=cr;
36
 
    order_rgba(p^ ).G:=cg;
37
 
    order_rgba(p^ ).B:=cb;
38
 
    order_rgba(p^ ).A:=base_mask;
39
 
 
40
 
   end
41
 
  else
42
 
   blend_pix_rgba_pre(p ,cr ,cg ,cb ,alpha );
43
 
 
44
 
end;
45
 
 
46
 
{ copy_or_blend_pix_rgba_pre }
47
 
procedure copy_or_blend_pix_rgba_pre(p : unsigned_ptr; cr ,cg ,cb ,alpha ,cover : unsigned ); overload;
48
 
begin
49
 
 if cover = 255 then
50
 
  copy_or_blend_pix_rgba_pre(p ,cr ,cg ,cb ,alpha )
51
 
 else
52
 
  if alpha <> 0 then
53
 
   begin
54
 
    alpha:=(alpha * (cover + 1 ) ) shr 8;
55
 
 
56
 
    if alpha = base_mask then
57
 
     begin
58
 
      order_rgba(p^ ).R:=cr;
59
 
      order_rgba(p^ ).G:=cg;
60
 
      order_rgba(p^ ).B:=cb;
61
 
      order_rgba(p^ ).A:=base_mask;
62
 
 
63
 
     end
64
 
    else
65
 
     blend_pix_rgba_pre(p ,cr ,cg ,cb ,alpha ,cover );
66
 
 
67
 
   end;
68
 
 
69
 
end;
70
 
 
71
 
{ rgba32_pre_blend_pixel }
72
 
procedure rgba32_pre_blend_pixel(this : pixel_formats_ptr; x ,y : int; c : aggclr_ptr; cover : int8u );
73
 
begin
74
 
 copy_or_blend_pix_rgba_pre(
75
 
  unsigned_ptr(ptrcomp(this.m_rbuf.row(y ) ) + (x shl 2 ) ) ,
76
 
  c.r ,c.g ,c.b ,c.a ,cover );
77
 
 
78
 
end;
79
 
 
80
 
{ rgba32_pre_blend_hline }
81
 
procedure rgba32_pre_blend_hline(this : pixel_formats_ptr; x ,y : int; len : unsigned; c : aggclr_ptr; cover : int8u );
82
 
var
83
 
 p : unsigned_ptr;
84
 
 v : unsigned;
85
 
 
86
 
 alpha : unsigned;
87
 
 
88
 
begin
89
 
 if c.a <> 0 then
90
 
  begin
91
 
   p:=unsigned_ptr(ptrcomp(this.m_rbuf.row(y ) ) + (x shl 2 ) );
92
 
 
93
 
   alpha:=(c.a * (cover + 1 ) ) shr 8;
94
 
 
95
 
   if alpha = base_mask then
96
 
    begin
97
 
     order_rgba(v ).R:=c.r;
98
 
     order_rgba(v ).G:=c.g;
99
 
     order_rgba(v ).B:=c.b;
100
 
     order_rgba(v ).A:=c.a;
101
 
 
102
 
     repeat
103
 
      p^:=v;
104
 
 
105
 
      inc(ptrcomp(p ) ,sizeof(unsigned ) );
106
 
      dec(len );
107
 
 
108
 
     until len = 0;
109
 
 
110
 
    end
111
 
   else
112
 
    if cover = 255 then
113
 
     repeat
114
 
      blend_pix_rgba_pre(p ,c.r ,c.g ,c.b ,alpha );
115
 
 
116
 
      inc(ptrcomp(p ) ,sizeof(unsigned ) );
117
 
      dec(len );
118
 
 
119
 
     until len = 0
120
 
    else
121
 
     repeat
122
 
      blend_pix_rgba_pre(p ,c.r ,c.g ,c.b ,alpha ,cover );
123
 
 
124
 
      inc(ptrcomp(p ) ,sizeof(unsigned ) );
125
 
      dec(len );
126
 
 
127
 
     until len = 0;
128
 
 
129
 
  end;
130
 
 
131
 
end;
132
 
 
133
 
{ rgba32_pre_blend_vline }
134
 
procedure rgba32_pre_blend_vline(this : pixel_formats_ptr; x ,y : int; len : unsigned; c : aggclr_ptr; cover : int8u );
135
 
var
136
 
 p : unsigned_ptr;
137
 
 v : unsigned;
138
 
 
139
 
 alpha : unsigned;
140
 
 
141
 
begin
142
 
 if c.a <> 0 then
143
 
  begin
144
 
   p:=unsigned_ptr(ptrcomp(this.m_rbuf.row(y ) ) + (x shl 2 ) );
145
 
 
146
 
   alpha:=(c.a * (cover + 1 ) ) shr 8;
147
 
 
148
 
   if alpha = base_mask then
149
 
    begin
150
 
     order_rgba(v ).R:=c.r;
151
 
     order_rgba(v ).G:=c.g;
152
 
     order_rgba(v ).B:=c.b;
153
 
     order_rgba(v ).A:=c.a;
154
 
 
155
 
     repeat
156
 
      p^:=v;
157
 
      p :=unsigned_ptr(this.m_rbuf.next_row(int8u_ptr(p ) ) );
158
 
 
159
 
     until len = 0;
160
 
 
161
 
    end
162
 
   else
163
 
    if cover = 255 then
164
 
     repeat
165
 
      blend_pix_rgba_pre(p ,c.r ,c.g ,c.b ,alpha );
166
 
 
167
 
      p:=unsigned_ptr(this.m_rbuf.next_row(int8u_ptr(p ) ) );
168
 
 
169
 
      dec(len );
170
 
 
171
 
     until len = 0
172
 
    else
173
 
     repeat
174
 
      blend_pix_rgba_pre(p ,c.r ,c.g ,c.b ,alpha ,cover );
175
 
 
176
 
      p:=unsigned_ptr(this.m_rbuf.next_row(int8u_ptr(p ) ) );
177
 
 
178
 
      dec(len );
179
 
 
180
 
     until len = 0;
181
 
 
182
 
  end;
183
 
 
184
 
end;
185
 
 
186
 
{ rgba32_pre_blend_solid_hspan }
187
 
procedure rgba32_pre_blend_solid_hspan(this : pixel_formats_ptr; x ,y : int; len : unsigned; c : aggclr_ptr; covers : int8u_ptr );
188
 
var
189
 
 p : unsigned_ptr;
190
 
 
191
 
 alpha : unsigned;
192
 
 
193
 
begin
194
 
 if c.a <> 0 then
195
 
  begin
196
 
   p:=unsigned_ptr(ptrcomp(this.m_rbuf.row(y ) ) + (x shl 2 ) );
197
 
 
198
 
   repeat
199
 
    alpha:=(c.a * (covers^ + 1 ) ) shr 8;
200
 
 
201
 
    if alpha = base_mask then
202
 
     begin
203
 
      order_rgba(p^ ).R:=c.r;
204
 
      order_rgba(p^ ).G:=c.g;
205
 
      order_rgba(p^ ).B:=c.b;
206
 
      order_rgba(p^ ).A:=base_mask;
207
 
 
208
 
     end
209
 
    else
210
 
     blend_pix_rgba_pre(p ,c.r ,c.g ,c.b ,alpha ,covers^ );
211
 
 
212
 
    inc(ptrcomp(p ) ,4 );
213
 
    inc(ptrcomp(covers ) );
214
 
 
215
 
    dec(len );
216
 
 
217
 
   until len = 0;
218
 
 
219
 
  end;
220
 
 
221
 
end;
222
 
 
223
 
{ rgba32_pre_blend_solid_vspan }
224
 
procedure rgba32_pre_blend_solid_vspan(this : pixel_formats_ptr; x ,y : int; len : unsigned; c : aggclr_ptr; covers : int8u_ptr );
225
 
var
226
 
 p : unsigned_ptr;
227
 
 
228
 
 alpha : unsigned;
229
 
 
230
 
begin
231
 
 if c.a <> 0 then
232
 
  begin
233
 
   p:=unsigned_ptr(ptrcomp(this.m_rbuf.row(y ) ) + (x shl 2 ) );
234
 
 
235
 
   repeat
236
 
    alpha:=(c.a * (covers^ + 1 ) ) shr 8;
237
 
 
238
 
    if alpha = base_mask then
239
 
     begin
240
 
      order_rgba(p^ ).R:=c.r;
241
 
      order_rgba(p^ ).G:=c.g;
242
 
      order_rgba(p^ ).B:=c.b;
243
 
      order_rgba(p^ ).A:=base_mask;
244
 
 
245
 
     end
246
 
    else
247
 
     blend_pix_rgba_pre(p ,c.r ,c.g ,c.b ,alpha ,covers^ );
248
 
 
249
 
    p:=unsigned_ptr(this.m_rbuf.next_row(int8u_ptr(p ) ) );
250
 
 
251
 
    inc(ptrcomp(covers ) ,sizeof(int8u ) );
252
 
    dec(len );
253
 
 
254
 
   until len = 0;
255
 
 
256
 
  end;
257
 
 
258
 
end;
259
 
 
260
 
{ rgba32_pre_blend_color_hspan }
261
 
procedure rgba32_pre_blend_color_hspan(this : pixel_formats_ptr; x ,y : int; len : unsigned; colors : aggclr_ptr; covers : int8u_ptr; cover : int8u );
262
 
var
263
 
 p : unsigned_ptr;
264
 
 
265
 
begin
266
 
 p:=unsigned_ptr(ptrcomp(this.m_rbuf.row(y ) ) + (x shl 2 ) );
267
 
 
268
 
 if covers <> NIL then
269
 
  repeat
270
 
   copy_or_blend_pix_rgba_pre(p ,colors.r ,colors.g ,colors.b ,colors.a ,covers^ );
271
 
 
272
 
   inc(ptrcomp(covers ) ,sizeof(int8u ) );
273
 
   inc(ptrcomp(p ) ,4 );
274
 
   inc(ptrcomp(colors ) ,sizeof(aggclr ) );
275
 
   dec(len );
276
 
 
277
 
  until len = 0
278
 
 else
279
 
  if cover = 255 then
280
 
   repeat
281
 
    copy_or_blend_pix_rgba_pre(p ,colors.r ,colors.g ,colors.b ,colors.a );
282
 
 
283
 
    inc(ptrcomp(p ) ,4 );
284
 
    inc(ptrcomp(colors ) ,sizeof(aggclr ) );
285
 
    dec(len );
286
 
 
287
 
   until len = 0
288
 
  else
289
 
   repeat
290
 
    copy_or_blend_pix_rgba_pre(p ,colors.r ,colors.g ,colors.b ,colors.a ,cover );
291
 
 
292
 
    inc(ptrcomp(p ) ,4 );
293
 
    inc(ptrcomp(colors ) ,sizeof(aggclr ) );
294
 
    dec(len );
295
 
 
296
 
   until len = 0;
297
 
 
298
 
end;
299
 
 
300
 
{ rgba32_pre_blend_color_vspan }
301
 
procedure rgba32_pre_blend_color_vspan(this : pixel_formats_ptr; x ,y : int; len : unsigned; colors : aggclr_ptr; covers : int8u_ptr; cover : int8u );
302
 
var
303
 
 p : unsigned_ptr;
304
 
 
305
 
begin
306
 
 p:=unsigned_ptr(ptrcomp(this.m_rbuf.row(y ) ) + (x shl 2 ) );
307
 
 
308
 
 if covers <> NIL then
309
 
  repeat
310
 
   copy_or_blend_pix_rgba_pre(
311
 
    p ,
312
 
    colors.r ,
313
 
    colors.g ,
314
 
    colors.b ,
315
 
    colors.a ,
316
 
    covers^ );
317
 
 
318
 
   inc(ptrcomp(covers ) ,sizeof(int8u ) );
319
 
 
320
 
   p:=unsigned_ptr(this.m_rbuf.next_row(int8u_ptr(p ) ) );
321
 
 
322
 
   inc(ptrcomp(colors ) ,sizeof(aggclr ) );
323
 
   dec(len );
324
 
 
325
 
  until len = 0
326
 
 else
327
 
  if cover = 255 then
328
 
   repeat
329
 
    copy_or_blend_pix_rgba_pre(
330
 
     p ,
331
 
     colors.r ,
332
 
     colors.g ,
333
 
     colors.b ,
334
 
     colors.a );
335
 
 
336
 
    p:=unsigned_ptr(this.m_rbuf.next_row(int8u_ptr(p ) ) );
337
 
 
338
 
    inc(ptrcomp(colors ) ,sizeof(aggclr ) );
339
 
    dec(len );
340
 
 
341
 
   until len = 0
342
 
  else
343
 
   repeat
344
 
    copy_or_blend_pix_rgba_pre(
345
 
     p ,
346
 
     colors.r ,
347
 
     colors.g ,
348
 
     colors.b ,
349
 
     colors.a ,
350
 
     cover );
351
 
 
352
 
    p:=unsigned_ptr(this.m_rbuf.next_row(int8u_ptr(p ) ) );
353
 
 
354
 
    inc(ptrcomp(colors ) ,sizeof(aggclr ) );
355
 
    dec(len );
356
 
 
357
 
   until len = 0;
358
 
 
359
 
end;
360
 
 
361
 
{ rgba32_pre_blend_from }
362
 
procedure rgba32_pre_blend_from(this : pixel_formats_ptr; from : pixel_formats_ptr; psrc_ : int8u_ptr; xdst ,ydst ,xsrc ,ysrc : int; len : unsigned; cover : int8u );
363
 
var
364
 
 psrc ,pdst : unsigned_ptr;
365
 
 
366
 
 incp : int;
367
 
 
368
 
begin
369
 
 psrc:=unsigned_ptr(psrc_ );
370
 
 pdst:=unsigned_ptr(ptrcomp(this.m_rbuf.row(ydst ) ) + (xdst shl 2 ) * sizeof(int8u ) );
371
 
 incp:=4;
372
 
 
373
 
 if ptrcomp(xdst ) > ptrcomp(xsrc ) then
374
 
  begin
375
 
   inc(ptrcomp(psrc ) ,((len - 1 ) shl 2 ) * sizeof(int8u ) );
376
 
   inc(ptrcomp(pdst ) ,((len - 1 ) shl 2 ) * sizeof(int8u ) );
377
 
 
378
 
   incp:=-4;
379
 
 
380
 
  end;
381
 
 
382
 
 if cover = 255 then
383
 
  repeat
384
 
   copy_or_blend_pix_rgba_pre(
385
 
    pdst ,
386
 
    order_rgba(psrc^ ).R ,
387
 
    order_rgba(psrc^ ).G ,
388
 
    order_rgba(psrc^ ).B ,
389
 
    order_rgba(psrc^ ).A );
390
 
 
391
 
   inc(ptrcomp(psrc ) ,incp );
392
 
   inc(ptrcomp(pdst ) ,incp );
393
 
   dec(len );
394
 
 
395
 
  until len = 0
396
 
 else
397
 
  repeat
398
 
   copy_or_blend_pix_rgba_pre(
399
 
    pdst ,
400
 
    order_rgba(psrc^ ).R ,
401
 
    order_rgba(psrc^ ).G ,
402
 
    order_rgba(psrc^ ).B ,
403
 
    order_rgba(psrc^ ).A ,
404
 
    cover );
405
 
 
406
 
   inc(ptrcomp(psrc ) ,incp );
407
 
   inc(ptrcomp(pdst ) ,incp );
408
 
   dec(len );
409
 
 
410
 
  until len = 0;
411
 
 
412
 
end;
413
 
 
414
 
{ rgba32_pre_blend_from_color }
415
 
procedure rgba32_pre_blend_from_color(this : pixel_formats_ptr; from : pixel_formats_ptr; color : aggclr_ptr; xdst ,ydst ,xsrc ,ysrc : int; len : unsigned; cover : int8u );
416
 
var
417
 
 ppsz : unsigned;
418
 
 
419
 
 psrc : int8u_ptr;
420
 
 pdst : unsigned_ptr;
421
 
 
422
 
begin
423
 
 ppsz:=from._pix_width;
424
 
 psrc:=from.row_ptr(ysrc );
425
 
 
426
 
 if psrc <> NIL then
427
 
  begin
428
 
   pdst:=unsigned_ptr(ptrcomp(this.m_rbuf.row_xy(xdst ,ydst ,len ) ) + (xdst shl 2 ) );
429
 
 
430
 
   repeat
431
 
    copy_or_blend_pix_rgba_pre(
432
 
     pdst ,color.r, color.g, color.b, color.a,
433
 
     shr_int32(psrc^ * cover + base_mask ,base_shift ) );
434
 
 
435
 
    inc(ptrcomp(psrc ) ,ppsz );
436
 
    inc(ptrcomp(pdst ) ,4 );
437
 
    dec(len );
438
 
 
439
 
   until len = 0;
440
 
 
441
 
  end;
442
 
 
443
 
end;
444
 
 
445
 
{ rgba32_pre_blend_from_lut }
446
 
procedure rgba32_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 );
447
 
var
448
 
 ppsz : unsigned;
449
 
 
450
 
 psrc : int8u_ptr;
451
 
 pdst : unsigned_ptr;
452
 
 
453
 
 color : aggclr_ptr;
454
 
 
455
 
begin
456
 
 ppsz:=from._pix_width;
457
 
 psrc:=from.row_ptr(ysrc );
458
 
 
459
 
 if psrc <> NIL then
460
 
  begin
461
 
   pdst:=unsigned_ptr(ptrcomp(this.m_rbuf.row_xy(xdst ,ydst ,len ) ) + (xdst shl 2 ) );
462
 
 
463
 
   if cover = 255 then
464
 
    repeat
465
 
     color:=aggclr_ptr(ptrcomp(color_lut ) + psrc^ * sizeof(aggclr ) );
466
 
 
467
 
     copy_or_blend_pix_rgba_pre(pdst ,color.r, color.g, color.b, color.a );
468
 
 
469
 
     inc(ptrcomp(psrc ) ,ppsz );
470
 
     inc(ptrcomp(pdst ) ,4 );
471
 
     dec(len );
472
 
 
473
 
    until len = 0
474
 
   else
475
 
    repeat
476
 
     color:=aggclr_ptr(ptrcomp(color_lut ) + psrc^ * sizeof(aggclr ) );
477
 
 
478
 
     copy_or_blend_pix_rgba_pre(pdst ,color.r, color.g, color.b, color.a ,cover );
479
 
 
480
 
     inc(ptrcomp(psrc ) ,ppsz );
481
 
     inc(ptrcomp(pdst ) ,4 );
482
 
     dec(len );
483
 
 
484
 
    until len = 0;
485
 
 
486
 
  end;
487
 
 
488
 
end;
489