← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/paint-funcs/paint-funcs-generic.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/paint-funcs/paint-funcs-generic.h
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
56
56
  guint              bytes2 : 3;
57
57
  guchar            *src1;
58
58
  guchar            *src2;
59
 
  guchar            *mask;
 
59
  const guchar      *mask;
60
60
  guchar           **dest;
61
61
  gint               x;
62
62
  gint               y;
165
165
 
166
166
void
167
167
color_pixels_mask (guchar       *dest,
168
 
                   guchar       *mask,
 
168
                   const guchar *mask,
169
169
                   const guchar *color,
170
170
                   guint         w,
171
171
                   guint         bytes)
221
221
}
222
222
 
223
223
void
224
 
pattern_pixels_mask (guchar  *dest,
225
 
                     guchar  *mask,
226
 
                     TempBuf *pattern,
227
 
                     guint    w,
228
 
                     guint    bytes,
229
 
                     gint     x,
230
 
                     gint     y)
 
224
pattern_pixels_mask (guchar       *dest,
 
225
                     const guchar *mask,
 
226
                     TempBuf      *pattern,
 
227
                     guint         w,
 
228
                     guint         bytes,
 
229
                     gint          x,
 
230
                     gint          y)
231
231
{
232
 
  guchar *pat, *p;
233
 
  gint    alpha, b;
234
 
  gint    i;
 
232
  const guint   alpha = HAS_ALPHA (bytes) ? bytes - 1 : bytes;
 
233
  const guchar *pat;
 
234
  guint         i;
235
235
 
236
236
  /*  Get a pointer to the appropriate scanline of the pattern buffer  */
237
237
  pat = (temp_buf_data (pattern) +
238
238
         (y % pattern->height) * pattern->width * pattern->bytes);
239
239
 
240
 
  alpha = HAS_ALPHA (bytes) ? bytes - 1 : bytes;
241
240
 
242
241
  /*
243
242
   * image data = pattern data for all but alpha
255
254
 
256
255
  for (i = 0; i < w; i++)
257
256
    {
258
 
      p = pat + ((i + x) % pattern->width) * pattern->bytes;
 
257
      const guchar *p = pat + ((i + x) % pattern->width) * pattern->bytes;
 
258
      guint         b;
259
259
 
260
260
      for (b = 0; b < alpha; b++)
261
261
        dest[b] = p[b];
276
276
    }
277
277
}
278
278
 
 
279
/*
 
280
 * blend_pixels patched 8-24-05 to fix bug #163721.  Note that this change
 
281
 * causes the function to treat src1 and src2 asymmetrically.  This gives the
 
282
 * right behavior for the smudge tool, which is the only user of this function
 
283
 * at the time of patching.  If you want to use the function for something
 
284
 * else, caveat emptor.
 
285
 */
279
286
inline void
280
287
blend_pixels (const guchar *src1,
281
288
              const guchar *src2,
284
291
              guint         w,
285
292
              guint         bytes)
286
293
{
287
 
  guint b;
288
 
 
289
294
  if (HAS_ALPHA (bytes))
290
295
    {
291
 
      const guint blend1 = 256 - blend;
 
296
      const guint blend1 = 255 - blend;
292
297
      const guint blend2 = blend + 1;
293
298
      const guint c      = bytes - 1;
294
299
 
295
300
      while (w--)
296
301
        {
297
 
          guint a1 = blend1 * src1[c];
298
 
          guint a2 = blend2 * src2[c];
299
 
          guint a  = a1 + a2;
 
302
          const gint  a1 = blend1 * src1[c];
 
303
          const gint  a2 = blend2 * src2[c];
 
304
          const gint  a  = a1 + a2;
 
305
          guint       b;
300
306
 
301
307
          if (!a)
302
308
            {
306
312
          else
307
313
            {
308
314
              for (b = 0; b < c; b++)
309
 
                dest[b] = (src1[b] * a1 + src2[b] * a2) / a;
 
315
                dest[b] =
 
316
                  src1[b] + (src1[b] * a1 + src2[b] * a2 - a * src1[b]) / a;
310
317
 
311
318
              dest[c] = a >> 8;
312
319
            }
322
329
 
323
330
      while (w--)
324
331
        {
 
332
          guint b;
 
333
 
325
334
          for (b = 0; b < bytes; b++)
326
 
            dest[b] = (src1[b] * blend1 + src2[b] * blend) / 255;
 
335
            dest[b] =
 
336
              src1[b] + (src1[b] * blend1 + src2[b] * blend - src1[b] * 255) / 255;
327
337
 
328
338
          src1 += bytes;
329
339
          src2 += bytes;
336
346
shade_pixels (const guchar *src,
337
347
              guchar       *dest,
338
348
              const guchar *col,
339
 
              guchar            blend,
 
349
              guchar        blend,
340
350
              guint         w,
341
351
              guint         bytes,
342
352
              gboolean      has_alpha)
343
353
{
344
354
  const guchar blend2 = (255 - blend);
345
355
  const guint  alpha = (has_alpha) ? bytes - 1 : bytes;
346
 
  guint b;
347
356
 
348
357
  while (w--)
349
358
    {
 
359
      guint b;
 
360
 
350
361
      for (b = 0; b < alpha; b++)
351
362
        dest[b] = (src[b] * blend2 + col[b] * blend) / 255;
352
363
 
367
378
                      guint         bytes)
368
379
{
369
380
  const guint alpha = bytes - 1;
370
 
  gint          tmp;
371
381
 
372
382
  if (mask)
373
383
    {
374
384
      const guchar *m = mask;
 
385
 
375
386
      while (w--)
376
387
        {
 
388
          gint tmp;
 
389
 
377
390
          *dest++ = INT_MULT(src[alpha], *m, tmp);
378
391
          m++;
379
392
          src += bytes;
383
396
    {
384
397
      while (w--)
385
398
        {
 
399
          gint tmp;
 
400
 
386
401
          *dest++ = INT_MULT(src[alpha], OPAQUE_OPACITY, tmp);
387
402
          src += bytes;
388
403
        }
400
415
{
401
416
  const guint has_alpha1 = HAS_ALPHA (bytes1);
402
417
  const guint has_alpha2 = HAS_ALPHA (bytes2);
403
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
404
 
  guint b;
405
 
  guchar s1, s2;
 
418
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
419
                            MAX (bytes1, bytes2) - 1 : bytes1);
406
420
 
407
421
  while (length--)
408
422
    {
 
423
      guint b;
 
424
 
409
425
      for (b = 0; b < alpha; b++)
410
426
        {
411
 
          s1 = src1[b];
412
 
          s2 = src2[b];
 
427
          guchar s1 = src1[b];
 
428
          guchar s2 = src2[b];
 
429
 
413
430
          dest[b] = (s1 < s2) ? s1 : s2;
414
431
        }
415
432
 
435
452
{
436
453
  const guint has_alpha1 = HAS_ALPHA (bytes1);
437
454
  const guint has_alpha2 = HAS_ALPHA (bytes2);
438
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
439
 
  guint b;
440
 
  guchar s1, s2;
 
455
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
456
                            MAX (bytes1, bytes2) - 1 : bytes1);
441
457
 
442
458
  while (length--)
443
459
    {
 
460
      guint b;
 
461
 
444
462
      for (b = 0; b < alpha; b++)
445
463
        {
446
 
          s1 = src1[b];
447
 
          s2 = src2[b];
 
464
          guchar s1 = src1[b];
 
465
          guchar s2 = src2[b];
 
466
 
448
467
          dest[b] = (s1 < s2) ? s2 : s1;
449
468
        }
450
469
 
470
489
{
471
490
  const guint has_alpha1 = HAS_ALPHA (bytes1);
472
491
  const guint has_alpha2 = HAS_ALPHA (bytes2);
473
 
  gint r1, g1, b1;
474
 
  gint r2, g2, b2;
475
492
 
476
493
  /*  assumes inputs are only 4 byte RGBA pixels  */
477
494
  while (length--)
478
495
    {
 
496
      gint r1, g1, b1;
 
497
      gint r2, g2, b2;
 
498
 
479
499
      r1 = src1[0]; g1 = src1[1]; b1 = src1[2];
480
500
      r2 = src2[0]; g2 = src2[1]; b2 = src2[2];
 
501
 
481
502
      gimp_rgb_to_hsv_int (&r1, &g1, &b1);
482
503
      gimp_rgb_to_hsv_int (&r2, &g2, &b2);
483
504
 
510
531
{
511
532
  const guint has_alpha1 = HAS_ALPHA (bytes1);
512
533
  const guint has_alpha2 = HAS_ALPHA (bytes2);
513
 
  guint r1, g1, b1;
514
 
  guint r2, g2, b2;
515
534
 
516
535
  /*  assumes inputs are only 4 byte RGBA pixels  */
517
536
  while (length--)
518
537
    {
 
538
      gint r1, g1, b1;
 
539
      gint r2, g2, b2;
 
540
 
519
541
      r1 = src1[0]; g1 = src1[1]; b1 = src1[2];
520
542
      r2 = src2[0]; g2 = src2[1]; b2 = src2[2];
 
543
 
521
544
      gimp_rgb_to_hsv_int (&r1, &g1, &b1);
522
545
      gimp_rgb_to_hsv_int (&r2, &g2, &b2);
523
546
 
550
573
{
551
574
  const guint has_alpha1 = HAS_ALPHA (bytes1);
552
575
  const guint has_alpha2 = HAS_ALPHA (bytes2);
553
 
  guint r1, g1, b1;
554
 
  guint r2, g2, b2;
555
576
 
556
577
  /*  assumes inputs are only 4 byte RGBA pixels  */
557
578
  while (length--)
558
579
    {
 
580
      gint r1, g1, b1;
 
581
      gint r2, g2, b2;
 
582
 
559
583
      r1 = src1[0]; g1 = src1[1]; b1 = src1[2];
560
584
      r2 = src2[0]; g2 = src2[1]; b2 = src2[2];
 
585
 
561
586
      gimp_rgb_to_hsv_int (&r1, &g1, &b1);
562
587
      gimp_rgb_to_hsv_int (&r2, &g2, &b2);
563
588
 
590
615
{
591
616
  const guint has_alpha1 = HAS_ALPHA (bytes1);
592
617
  const guint has_alpha2 = HAS_ALPHA (bytes2);
593
 
  guint r1, g1, b1;
594
 
  guint r2, g2, b2;
595
618
 
596
619
  /*  assumes inputs are only 4 byte RGBA pixels  */
597
620
  while (length--)
598
621
    {
 
622
      gint r1, g1, b1;
 
623
      gint r2, g2, b2;
 
624
 
599
625
      r1 = src1[0]; g1 = src1[1]; b1 = src1[2];
600
626
      r2 = src2[0]; g2 = src2[1]; b2 = src2[2];
 
627
 
601
628
      gimp_rgb_to_hsl_int (&r1, &g1, &b1);
602
629
      gimp_rgb_to_hsl_int (&r2, &g2, &b2);
603
630
 
632
659
{
633
660
  const guint has_alpha1 = HAS_ALPHA (bytes1);
634
661
  const guint has_alpha2 = HAS_ALPHA (bytes2);
635
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
636
 
  guint b, tmp;
 
662
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
663
                            MAX (bytes1, bytes2) - 1 : bytes1);
637
664
 
638
665
  if (has_alpha1 && has_alpha2)
639
666
    {
640
667
      while (length --)
641
668
        {
 
669
          guint b;
 
670
 
642
671
          for (b = 0; b < alpha; b++)
643
 
            dest[b] = INT_MULT(src1[b], src2[b], tmp);
 
672
            {
 
673
              guint tmp;
 
674
 
 
675
              dest[b] = INT_MULT(src1[b], src2[b], tmp);
 
676
            }
644
677
 
645
678
          dest[alpha] = MIN (src1[alpha], src2[alpha]);
646
679
 
653
686
    {
654
687
      while (length --)
655
688
        {
 
689
          guint b;
 
690
 
656
691
          for (b = 0; b < alpha; b++)
657
 
            dest[b] = INT_MULT(src1[b], src2[b], tmp);
 
692
            {
 
693
              guint tmp;
 
694
 
 
695
              dest[b] = INT_MULT(src1[b], src2[b], tmp);
 
696
            }
658
697
 
659
698
          dest[alpha] = src2[alpha];
660
699
 
667
706
    {
668
707
      while (length --)
669
708
        {
 
709
          guint b;
 
710
 
670
711
          for (b = 0; b < alpha; b++)
671
 
            dest[b] = INT_MULT(src1[b], src2[b], tmp);
 
712
            {
 
713
              guint tmp;
 
714
 
 
715
              dest[b] = INT_MULT (src1[b], src2[b], tmp);
 
716
            }
672
717
 
673
718
          src1 += bytes1;
674
719
          src2 += bytes2;
688
733
{
689
734
  const guint has_alpha1 = HAS_ALPHA (bytes1);
690
735
  const guint has_alpha2 = HAS_ALPHA (bytes2);
691
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
692
 
  guint b, result;
693
 
 
 
736
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
737
                            MAX (bytes1, bytes2) - 1 : bytes1);
694
738
  while (length--)
695
739
    {
 
740
      guint b;
 
741
 
696
742
      for (b = 0; b < alpha; b++)
697
743
        {
698
 
          result = ((src1[b] * 256) / (1+src2[b]));
 
744
          guint result = ((src1[b] * 256) / (1 + src2[b]));
 
745
 
699
746
          dest[b] = MIN (result, 255);
700
747
        }
701
748
 
721
768
{
722
769
  const guint has_alpha1 = HAS_ALPHA (bytes1);
723
770
  const guint has_alpha2 = HAS_ALPHA (bytes2);
724
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
725
 
  guint b, tmp;
 
771
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
772
                            MAX (bytes1, bytes2) - 1 : bytes1);
726
773
 
727
774
  while (length --)
728
775
    {
 
776
      guint b;
 
777
 
729
778
      for (b = 0; b < alpha; b++)
730
 
        dest[b] = 255 - INT_MULT((255 - src1[b]), (255 - src2[b]), tmp);
 
779
        {
 
780
          guint tmp;
 
781
 
 
782
          dest[b] = 255 - INT_MULT((255 - src1[b]), (255 - src2[b]), tmp);
 
783
        }
731
784
 
732
785
      if (has_alpha1 && has_alpha2)
733
786
        dest[alpha] = MIN (src1[alpha], src2[alpha]);
751
804
{
752
805
  const guint has_alpha1 = HAS_ALPHA (bytes1);
753
806
  const guint has_alpha2 = HAS_ALPHA (bytes2);
754
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
755
 
  guint b, tmp, tmpM;
 
807
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
808
                            MAX (bytes1, bytes2) - 1 : bytes1);
756
809
 
757
810
  while (length --)
758
811
    {
 
812
      guint b;
 
813
 
759
814
      for (b = 0; b < alpha; b++)
760
815
        {
761
 
          dest[b] = INT_MULT(src1[b], src1[b] + INT_MULT(2 * src2[b],
762
 
                                                         255 - src1[b],
763
 
                                                         tmpM), tmp);
 
816
          guint tmp, tmpM;
 
817
 
 
818
          dest[b] = INT_MULT(src1[b], src1[b] + INT_MULT (2 * src2[b],
 
819
                                                          255 - src1[b],
 
820
                                                          tmpM), tmp);
764
821
        }
765
822
 
766
823
      if (has_alpha1 && has_alpha2)
785
842
{
786
843
  const guint has_alpha1 = HAS_ALPHA (bytes1);
787
844
  const guint has_alpha2 = HAS_ALPHA (bytes2);
788
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
789
 
  guint b, tmp;
790
 
 
 
845
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
846
                            MAX (bytes1, bytes2) - 1 : bytes1);
791
847
  while (length --)
792
848
    {
 
849
      guint b;
 
850
 
793
851
      for (b = 0; b < alpha; b++)
794
852
        {
 
853
          guint tmp;
 
854
 
795
855
          tmp = src1[b] << 8;
796
856
          tmp /= 256 - src2[b];
 
857
 
797
858
          dest[b] = (guchar) MIN (tmp, 255);
798
859
        }
799
860
 
819
880
{
820
881
  const guint has_alpha1 = HAS_ALPHA (bytes1);
821
882
  const guint has_alpha2 = HAS_ALPHA (bytes2);
822
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
823
 
  guint b;
824
 
 
825
 
  /* FIXME: Is the burn effect supposed to be dependant on the sign of this
826
 
   * temporary variable? */
827
 
  gint tmp;
 
883
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
884
                            MAX (bytes1, bytes2) - 1 : bytes1);
828
885
 
829
886
  while (length --)
830
887
    {
 
888
      guint b;
 
889
 
831
890
      for (b = 0; b < alpha; b++)
832
891
        {
833
 
            tmp = (255 - src1[b]) << 8;
834
 
            tmp /= src2[b] + 1;
835
 
            dest[b] = (guchar) CLAMP (255 - tmp, 0, 255);
 
892
          /* FIXME: Is the burn effect supposed to be dependant on the sign
 
893
           * of this temporary variable?
 
894
           */
 
895
          gint tmp;
 
896
 
 
897
          tmp = (255 - src1[b]) << 8;
 
898
          tmp /= src2[b] + 1;
 
899
 
 
900
          dest[b] = (guchar) CLAMP (255 - tmp, 0, 255);
836
901
        }
837
902
 
838
903
      if (has_alpha1 && has_alpha2)
857
922
{
858
923
  const guint has_alpha1 = HAS_ALPHA (bytes1);
859
924
  const guint has_alpha2 = HAS_ALPHA (bytes2);
860
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
861
 
  guint b, tmp;
 
925
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
926
                            MAX (bytes1, bytes2) - 1 : bytes1);
862
927
 
863
928
  while (length --)
864
929
    {
 
930
      guint b;
 
931
 
865
932
      for (b = 0; b < alpha; b++)
866
933
        {
867
 
          if (src2[b] > 128) {
868
 
            tmp = ((gint)255 - src1[b]) * ((gint)255 - ((src2[b] - 128) << 1));
869
 
            dest[b] = (guchar) MIN (255 - (tmp >> 8), 255);
870
 
          } else {
871
 
            tmp = (gint)src1[b] * ((gint)src2[b] << 1);
872
 
            dest[b] = (guchar) MIN (tmp >> 8, 255);
873
 
          }
 
934
          guint tmp;
 
935
 
 
936
          if (src2[b] > 128)
 
937
            {
 
938
              tmp = (((gint)255 - src1[b]) *
 
939
                     ((gint)255 - ((src2[b] - 128) << 1)));
 
940
              dest[b] = (guchar) MIN (255 - (tmp >> 8), 255);
 
941
            }
 
942
          else
 
943
            {
 
944
              tmp = (gint) src1[b] * ((gint)src2[b] << 1);
 
945
              dest[b] = (guchar) MIN (tmp >> 8, 255);
 
946
            }
874
947
        }
875
948
 
876
949
      if (has_alpha1 && has_alpha2)
895
968
{
896
969
  const guint has_alpha1 = HAS_ALPHA (bytes1);
897
970
  const guint has_alpha2 = HAS_ALPHA (bytes2);
898
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
899
 
  guint b, tmpS, tmpM, tmp1, tmp2, tmp3;
 
971
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
972
                            MAX (bytes1, bytes2) - 1 : bytes1);
900
973
 
901
974
  while (length --)
902
975
    {
903
 
      for (b = 0; b < alpha; b++)
 
976
      guint b;
 
977
 
 
978
        for (b = 0; b < alpha; b++)
904
979
        {
 
980
          guint tmp1, tmp2, tmp3;
 
981
 
905
982
          /* Mix multiply and screen */
906
 
          tmpM = INT_MULT (src1[b], src2[b], tmpM);
907
 
          tmpS = 255 - INT_MULT((255 - src1[b]), (255 - src2[b]), tmp1);
 
983
         guint tmpM = INT_MULT (src1[b], src2[b], tmpM);
 
984
         guint tmpS = 255 - INT_MULT((255 - src1[b]), (255 - src2[b]), tmp1);
 
985
 
908
986
          dest[b] = INT_MULT ((255 - src1[b]), tmpM, tmp2) +
909
987
            INT_MULT (src1[b], tmpS, tmp3);
910
988
        }
929
1007
                      guint         bytes1,
930
1008
                      guint         bytes2)
931
1009
{
932
 
  guint alpha, b;
933
 
  gint diff;
934
1010
  const guint has_alpha1 = HAS_ALPHA (bytes1);
935
1011
  const guint has_alpha2 = HAS_ALPHA (bytes2);
936
 
 
937
 
  alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
 
1012
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
1013
                            MAX (bytes1, bytes2) - 1 : bytes1);
938
1014
 
939
1015
  while (length --)
940
1016
    {
 
1017
      guint b;
 
1018
 
941
1019
      for (b = 0; b < alpha; b++)
942
1020
        {
943
 
          diff = src1[b] - src2[b] + 128;
 
1021
          gint diff = src1[b] - src2[b] + 128;
 
1022
 
944
1023
          dest[b] = (guchar) CLAMP (diff, 0, 255);
945
1024
        }
946
1025
 
964
1043
                    guint         bytes1,
965
1044
                    guint         bytes2)
966
1045
{
967
 
  gint alpha, b;
968
 
  gint sum;
969
1046
  const guint has_alpha1 = HAS_ALPHA (bytes1);
970
1047
  const guint has_alpha2 = HAS_ALPHA (bytes2);
971
 
 
972
 
  alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
 
1048
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
1049
                            MAX (bytes1, bytes2) - 1 : bytes1);
973
1050
 
974
1051
  while (length --)
975
1052
    {
 
1053
      guint  b;
 
1054
 
976
1055
      for (b = 0; b < alpha; b++)
977
1056
        {
978
1057
          /* Add, re-center and clip. */
979
 
          sum = src1[b] + src2[b] - 128;
 
1058
          gint sum = src1[b] + src2[b] - 128;
 
1059
 
980
1060
          dest[b] = (guchar) CLAMP (sum, 0, 255);
981
1061
        }
982
1062
 
1002
1082
{
1003
1083
  const guint has_alpha1 = HAS_ALPHA (bytes1);
1004
1084
  const guint has_alpha2 = HAS_ALPHA (bytes2);
1005
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
1006
 
  guint b;
 
1085
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
1086
                            MAX (bytes1, bytes2) - 1 : bytes1);
1007
1087
 
1008
1088
  while (length --)
1009
1089
    {
 
1090
      guint b;
 
1091
 
1010
1092
      for (b = 0; b < alpha; b++)
1011
1093
          dest[b] = add_lut[src1[b] + src2[b]];
1012
1094
 
1032
1114
{
1033
1115
  const guint has_alpha1 = HAS_ALPHA (bytes1);
1034
1116
  const guint has_alpha2 = HAS_ALPHA (bytes2);
1035
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
1036
 
  guint b;
1037
 
  gint diff;
 
1117
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
1118
                            MAX (bytes1, bytes2) - 1 : bytes1);
1038
1119
 
1039
1120
  while (length --)
1040
1121
    {
 
1122
      guint b;
 
1123
 
1041
1124
      for (b = 0; b < alpha; b++)
1042
1125
        {
1043
 
          diff = src1[b] - src2[b];
 
1126
          gint diff = src1[b] - src2[b];
 
1127
 
1044
1128
          dest[b] = (diff < 0) ? 0 : diff;
1045
1129
        }
1046
1130
 
1066
1150
{
1067
1151
  const guint has_alpha1 = HAS_ALPHA (bytes1);
1068
1152
  const guint has_alpha2 = HAS_ALPHA (bytes2);
1069
 
  const guint alpha = (has_alpha1 || has_alpha2) ? MAX (bytes1, bytes2) - 1 : bytes1;
1070
 
  guint b;
1071
 
  gint diff;
 
1153
  const guint alpha      = ((has_alpha1 || has_alpha2) ?
 
1154
                            MAX (bytes1, bytes2) - 1 : bytes1);
1072
1155
 
1073
1156
  while (length --)
1074
1157
    {
 
1158
      guint b;
 
1159
 
1075
1160
      for (b = 0; b < alpha; b++)
1076
1161
        {
1077
 
          diff = src1[b] - src2[b];
 
1162
          gint diff = src1[b] - src2[b];
 
1163
 
1078
1164
          dest[b] = (diff < 0) ? -diff : diff;
1079
1165
        }
1080
1166
 
1092
1178
 
1093
1179
static inline void
1094
1180
dissolve_pixels (const guchar *src,
1095
 
                 guchar       *mask,
 
1181
                 const guchar *mask,
1096
1182
                 guchar       *dest,
1097
1183
                 gint          x,
1098
1184
                 gint          y,
1100
1186
                 gint          length,
1101
1187
                 gint          sb,
1102
1188
                 gint          db,
1103
 
                 guint               has_alpha)
 
1189
                 gboolean      has_alpha)
1104
1190
{
1105
 
  gint    alpha, b;
1106
 
  gint32  rand_val;
1107
 
  gint    combined_opacity;
1108
 
  GRand  *gr;
 
1191
  const gint  alpha = db - 1;
 
1192
  gint        b;
 
1193
  GRand      *gr;
1109
1194
 
1110
1195
  gr = g_rand_new_with_seed (random_table[y % RANDOM_TABLE_SIZE]);
1111
1196
 
1113
1198
  for (b = 0; b < x; b ++)
1114
1199
    g_rand_int (gr);
1115
1200
 
1116
 
  alpha = db - 1;
1117
 
 
1118
1201
  while (length--)
1119
1202
    {
 
1203
      gint    combined_opacity;
 
1204
      gint32  rand_val;
 
1205
 
1120
1206
      /*  preserve the intensity values  */
1121
1207
      for (b = 0; b < alpha; b++)
1122
1208
        dest[b] = src[b];
1152
1238
}
1153
1239
 
1154
1240
static inline void
1155
 
replace_pixels (guchar         *src1,
1156
 
                guchar         *src2,
 
1241
replace_pixels (const guchar   *src1,
 
1242
                const guchar   *src2,
1157
1243
                guchar         *dest,
1158
 
                guchar         *mask,
 
1244
                const guchar   *mask,
1159
1245
                gint            length,
1160
1246
                gint            opacity,
1161
1247
                const gboolean *affect,
1162
1248
                gint            bytes1,
1163
1249
                gint            bytes2)
1164
1250
{
1165
 
  gint    alpha;
1166
 
  gint    b;
1167
 
  gdouble a_val, a_recip, mask_val;
1168
 
  gdouble norm_opacity;
1169
 
  gint    s1_a, s2_a;
1170
 
  gint    new_val;
 
1251
  const gint    alpha        = bytes1 - 1;
 
1252
  const gdouble norm_opacity = opacity * (1.0 / 65536.0);
1171
1253
 
1172
1254
  if (bytes1 != bytes2)
1173
1255
    {
1175
1257
      return;
1176
1258
    }
1177
1259
 
1178
 
  alpha = bytes1 - 1;
1179
 
  norm_opacity = opacity * (1.0 / 65536.0);
1180
 
 
1181
1260
  while (length --)
1182
1261
    {
1183
 
      mask_val = mask[0] * norm_opacity;
 
1262
      guint    b;
 
1263
      gdouble  mask_val = mask[0] * norm_opacity;
 
1264
 
1184
1265
      /* calculate new alpha first. */
1185
 
      s1_a = src1[alpha];
1186
 
      s2_a = src2[alpha];
1187
 
      a_val = s1_a + mask_val * (s2_a - s1_a);
 
1266
      gint     s1_a  = src1[alpha];
 
1267
      gint     s2_a  = src2[alpha];
 
1268
      gdouble  a_val = s1_a + mask_val * (s2_a - s1_a);
1188
1269
 
1189
 
      if (a_val == 0) /* In any case, write out versions of the blending function */
1190
 
                      /* that result when combinations of s1_a, s2_a, and         */
1191
 
                      /* mask_val --> 0 (or mask_val -->1)                        */
 
1270
      if (a_val == 0)
 
1271
        /* In any case, write out versions of the blending function */
 
1272
        /* that result when combinations of s1_a, s2_a, and         */
 
1273
        /* mask_val --> 0 (or mask_val -->1)                        */
1192
1274
        {
1193
1275
          /* Case 1: s1_a, s2_a, AND mask_val all approach 0+:               */
1194
1276
          /* Case 2: s1_a AND s2_a both approach 0+, regardless of mask_val: */
1197
1279
            {
1198
1280
              for (b = 0; b < alpha; b++)
1199
1281
                {
1200
 
                  new_val = 0.5 + (gdouble) src1[b] +
 
1282
                  gint new_val = 0.5 + (gdouble) src1[b] +
1201
1283
                    mask_val * ((gdouble) src2[b] - (gdouble) src1[b]);
1202
1284
 
1203
1285
                  dest[b] = affect[b] ? MIN (new_val, 255) : src1[b];
1208
1290
          else if (s1_a + mask_val == 0.0)
1209
1291
            {
1210
1292
              for (b = 0; b < alpha; b++)
1211
 
                {
1212
 
                  dest[b] = src1[b];
1213
 
                }
 
1293
                dest[b] = src1[b];
1214
1294
            }
1215
1295
 
1216
1296
          /* Case 4: mask_val -->1 AND s2_a -->0, regardless of s1_a         */
1217
1297
          else if (1.0 - mask_val + s2_a == 0.0)
1218
1298
            {
1219
1299
              for (b = 0; b < alpha; b++)
1220
 
                {
1221
 
                  dest[b] = affect[b] ? src2[b] : src1[b];
1222
 
                }
 
1300
                dest[b] = affect[b] ? src2[b] : src1[b];
1223
1301
            }
1224
1302
        }
1225
1303
      else
1226
1304
        {
1227
 
          a_recip = 1.0 / a_val;
1228
 
          /* possible optimization: fold a_recip into s1_a and s2_a              */
 
1305
          gdouble a_recip = 1.0 / a_val;
 
1306
          /* possible optimization: fold a_recip into s1_a and s2_a           */
1229
1307
          for (b = 0; b < alpha; b++)
1230
1308
            {
1231
 
              new_val = 0.5 + a_recip * (src1[b] * s1_a + mask_val *
1232
 
                                         (src2[b] * s2_a - src1[b] * s1_a));
 
1309
              gint new_val = 0.5 + a_recip * (src1[b] * s1_a + mask_val *
 
1310
                                              (src2[b] * s2_a - src1[b] * s1_a));
1233
1311
              dest[b] = affect[b] ? MIN (new_val, 255) : src1[b];
1234
1312
            }
1235
1313
        }
1249
1327
{
1250
1328
  while (length--)
1251
1329
    {
1252
 
      *src = *src ^ *dest;
1253
 
      *dest = *dest ^ *src;
1254
 
      *src = *src ^ *dest;
 
1330
      guchar tmp = *dest;
 
1331
 
 
1332
      *dest = *src;
 
1333
      *src = tmp;
 
1334
 
1255
1335
      src++;
1256
1336
      dest++;
1257
1337
    }
1278
1358
                  guint         length,
1279
1359
                  guint         bytes)
1280
1360
{
1281
 
  gint alpha, b;
1282
 
 
1283
 
  alpha = bytes + 1;
 
1361
  const guint alpha = bytes + 1;
1284
1362
 
1285
1363
  while (length --)
1286
1364
    {
 
1365
      guint b;
 
1366
 
1287
1367
      for (b = 0; b < bytes; b++)
1288
1368
        dest[b] = src[b];
1289
1369
 
1302
1382
                guint         length,
1303
1383
                guint         bytes)
1304
1384
{
1305
 
  gint alpha, b;
1306
 
  gint t1, t2;
 
1385
  const guint alpha = bytes - 1;
1307
1386
 
1308
 
  alpha = bytes - 1;
1309
1387
  while (length --)
1310
1388
    {
 
1389
      guint b;
 
1390
 
1311
1391
      for (b = 0; b < alpha; b++)
1312
 
        dest[b] = INT_MULT (src[b], src[alpha], t1) +
1313
 
                  INT_MULT (bg[b], (255 - src[alpha]), t2);
 
1392
        {
 
1393
          gint t1, t2;
 
1394
 
 
1395
          dest[b] = (INT_MULT (src[b], src[alpha], t1) +
 
1396
                     INT_MULT (bg[b], (255 - src[alpha]), t2));
 
1397
        }
1314
1398
 
1315
1399
      src += bytes;
1316
1400
      dest += alpha;
1324
1408
                    guint         length,
1325
1409
                    guint         bytes)
1326
1410
{
1327
 
  gint     b;
1328
 
  gint     dest_bytes;
1329
 
  gboolean has_alpha;
1330
 
 
1331
 
  has_alpha = (bytes == 2) ? TRUE : FALSE;
1332
 
  dest_bytes = (has_alpha) ? 4 : 3;
 
1411
  const gboolean has_alpha  = (bytes == 2) ? TRUE : FALSE;
 
1412
  const gint     dest_bytes = (has_alpha) ? 4 : 3;
1333
1413
 
1334
1414
  while (length --)
1335
1415
    {
 
1416
      guint b;
 
1417
 
1336
1418
      for (b = 0; b < bytes; b++)
1337
1419
        dest[b] = src[0];
1338
1420
 
1352
1434
                             guint         length,
1353
1435
                             guint         bytes)
1354
1436
{
1355
 
  glong tmp;
1356
 
 
1357
1437
  src += bytes - 1;
1358
1438
 
1359
1439
  if (opacity == 255)
1360
1440
    {
1361
1441
      while (length --)
1362
1442
        {
 
1443
          glong tmp;
 
1444
 
1363
1445
          *src = INT_MULT(*src, *mask, tmp);
1364
1446
          mask++;
1365
1447
          src += bytes;
1369
1451
    {
1370
1452
      while (length --)
1371
1453
        {
 
1454
          glong tmp;
 
1455
 
1372
1456
          *src = INT_MULT3(*src, *mask, opacity, tmp);
1373
1457
          mask++;
1374
1458
          src += bytes;
1384
1468
                                        guint         length,
1385
1469
                                        guint         bytes)
1386
1470
{
1387
 
  gint mask_val;
1388
 
  gint tmp;
1389
 
 
1390
1471
  /* align with alpha channel */
1391
1472
  src += bytes - 1;
1392
1473
 
1393
1474
  if (opacity != 255)
1394
1475
    while (length --)
1395
1476
      {
1396
 
        mask_val = INT_MULT(*mask, opacity, tmp);
 
1477
        gint tmp;
 
1478
        gint mask_val = INT_MULT(*mask, opacity, tmp);
 
1479
 
1397
1480
        *src = *src + INT_MULT((255 - *src) , mask_val, tmp);
1398
1481
 
1399
1482
        src += bytes;
1402
1485
  else
1403
1486
    while (length --)
1404
1487
      {
 
1488
        gint tmp;
 
1489
 
1405
1490
        *src = *src + INT_MULT((255 - *src) , *mask, tmp);
1406
1491
 
1407
1492
        src += bytes;
1417
1502
                                       guint         length,
1418
1503
                                       guint         bytes)
1419
1504
{
1420
 
  gint mask_val;
1421
 
  gint tmp;
1422
 
 
1423
1505
  /* align with alpha channel */
1424
1506
  src += bytes - 1;
1425
1507
 
1428
1510
      {
1429
1511
        if (opacity > *src)
1430
1512
          {
1431
 
            mask_val = INT_MULT(*mask, opacity, tmp);
1432
 
            *src = *src + INT_MULT((opacity - *src) , mask_val, tmp);
 
1513
            gint tmp;
 
1514
            gint mask_val = INT_MULT (*mask, opacity, tmp);
 
1515
 
 
1516
            *src = *src + INT_MULT ((opacity - *src) , mask_val, tmp);
1433
1517
          }
1434
1518
 
1435
1519
        src += bytes;
1438
1522
  else
1439
1523
    while (length --)
1440
1524
      {
1441
 
        *src = *src + INT_MULT((255 - *src) , *mask, tmp);
 
1525
        gint tmp;
 
1526
 
 
1527
        *src = *src + INT_MULT ((255 - *src) , *mask, tmp);
1442
1528
 
1443
1529
        src += bytes;
1444
1530
        mask++;
1452
1538
                             guint         length,
1453
1539
                             guint         bytes)
1454
1540
{
1455
 
  gint b;
1456
 
  gint alpha;
1457
 
 
1458
 
  alpha = bytes - 1;
 
1541
  const guint alpha = bytes - 1;
1459
1542
 
1460
1543
  while (length --)
1461
1544
    {
 
1545
      guint b;
 
1546
 
1462
1547
      for (b = 0; b < alpha; b++)
1463
1548
        dest[b] = *src;
1464
1549
      dest[b] = OPAQUE_OPACITY;
1475
1560
                        guint         length,
1476
1561
                        guint         bytes)
1477
1562
{
1478
 
  gint alpha, b;
1479
 
 
1480
 
  alpha = bytes - 1;
 
1563
  const guint alpha = bytes - 1;
1481
1564
 
1482
1565
  while (length --)
1483
1566
    {
 
1567
      guint b;
 
1568
 
1484
1569
      for (b = 0; b < alpha; b++)
1485
1570
        dest[b] = src[0];
1486
1571
 
1498
1583
                        const guchar *cmap,
1499
1584
                        guint         length)
1500
1585
{
1501
 
  gint col_index;
1502
 
 
1503
1586
  /*  This function assumes always that we're mapping from
1504
1587
   *  an RGB colormap to an RGBA image...
1505
1588
   */
1506
1589
  while (length--)
1507
1590
    {
1508
 
      col_index = *src++ * 3;
 
1591
      gint col_index = *src++ * 3;
 
1592
 
1509
1593
      *dest++ = cmap[col_index++];
1510
1594
      *dest++ = cmap[col_index++];
1511
1595
      *dest++ = cmap[col_index++];
1523
1607
                          guint         opacity,
1524
1608
                          guint         length)
1525
1609
{
1526
 
  gint          col_index;
1527
 
  guchar        new_alpha;
1528
 
  const guchar *m;
1529
 
  glong         tmp;
1530
 
 
1531
 
  if (mask)
1532
 
    m = mask;
1533
 
  else
1534
 
    m = no_mask;
 
1610
  const guchar *m = mask ? mask : no_mask;
1535
1611
 
1536
1612
  while (length --)
1537
1613
    {
1538
 
      col_index = *src++ * 3;
1539
 
      new_alpha = INT_MULT3(*src, *m, opacity, tmp);
 
1614
      gint   col_index = *src++ * 3;
 
1615
      glong  tmp;
 
1616
      guchar new_alpha = INT_MULT3(*src, *m, opacity, tmp);
 
1617
 
1540
1618
      src++;
 
1619
 
1541
1620
      *dest++ = cmap[col_index++];
1542
1621
      *dest++ = cmap[col_index++];
1543
1622
      *dest++ = cmap[col_index++];
1560
1639
                      guint           length,
1561
1640
                      guint           bytes)
1562
1641
{
1563
 
  gint  b;
1564
 
  gint  tmp;
1565
 
  gint  l;
1566
 
  const guchar *m;
1567
 
  guchar       *destp;
1568
1642
  const guchar *srcp;
1569
1643
  const gint    dest_bytes = bytes + 1;
 
1644
  guchar       *destp;
 
1645
  gint          b, l;
1570
1646
 
1571
1647
  if (mask)
1572
1648
    {
1573
 
      m = mask;
 
1649
      const guchar *m = mask;
1574
1650
 
1575
1651
      /*  This function assumes the source has no alpha channel and
1576
1652
       *  the destination has an alpha channel.  So dest_bytes = bytes + 1
1586
1662
          if (opacity != 0)
1587
1663
            while(length--)
1588
1664
              {
 
1665
                gint  tmp;
 
1666
 
1589
1667
                dest[0] = src[0];
1590
1668
                dest[1] = src[1];
1591
1669
                dest[2] = src[2];
1592
 
                dest[3] = INT_MULT(opacity, *m, tmp);
 
1670
                dest[3] = INT_MULT (opacity, *m, tmp);
1593
1671
                src  += bytes;
1594
1672
                dest += dest_bytes;
1595
1673
                m++;
1604
1682
                src  += bytes;
1605
1683
                dest += dest_bytes;
1606
1684
              }
 
1685
 
1607
1686
          return;
1608
1687
        }
1609
1688
 
1610
 
      for (b =0; b < bytes; b++)
 
1689
      for (b = 0; b < bytes; b++)
1611
1690
        {
1612
1691
          destp = dest + b;
1613
1692
          srcp = src + b;
1637
1716
      if (opacity != 0)
1638
1717
        while (length--)
1639
1718
          {
 
1719
            gint  tmp;
 
1720
 
1640
1721
            *destp = INT_MULT(opacity , *m, tmp);
1641
1722
            destp += dest_bytes;
1642
1723
            m++;
1648
1729
            destp += dest_bytes;
1649
1730
          }
1650
1731
    }
1651
 
  else  /* If no mask */
 
1732
  else  /* no mask */
1652
1733
    {
1653
1734
      /*  This function assumes the source has no alpha channel and
1654
1735
       *  the destination has an alpha channel.  So dest_bytes = bytes + 1
1718
1799
                        guint           length,
1719
1800
                        guint           bytes)
1720
1801
{
1721
 
  gint          alpha, b;
1722
 
  const guchar *m;
1723
 
  glong         tmp;
 
1802
  const guint alpha = bytes - 1;
1724
1803
 
1725
 
  alpha = bytes - 1;
1726
1804
  if (mask)
1727
1805
    {
1728
 
      m = mask;
1729
 
      while (length --)
 
1806
      const guchar *m = mask;
 
1807
 
 
1808
      while (length--)
1730
1809
        {
 
1810
          guint b;
 
1811
          glong tmp;
 
1812
 
1731
1813
          for (b = 0; b < alpha; b++)
1732
1814
            dest[b] = src[b] * affect[b];
1733
1815
 
1734
1816
          /*  Set the alpha channel  */
1735
 
          dest[alpha] = affect [alpha] ? INT_MULT3(opacity, src[alpha], *m, tmp)
1736
 
            : 0;
 
1817
          dest[alpha] = (affect [alpha] ?
 
1818
                         INT_MULT3(opacity, src[alpha], *m, tmp) : 0);
1737
1819
 
1738
1820
          m++;
1739
1821
 
1743
1825
    }
1744
1826
  else
1745
1827
    {
1746
 
      while (length --)
 
1828
      while (length--)
1747
1829
        {
 
1830
          guint b;
 
1831
          glong tmp;
 
1832
 
1748
1833
          for (b = 0; b < alpha; b++)
1749
1834
            dest[b] = src[b] * affect[b];
1750
1835
 
1751
1836
          /*  Set the alpha channel  */
1752
 
          dest[alpha] = affect [alpha] ? INT_MULT(opacity , src[alpha], tmp) : 0;
 
1837
          dest[alpha] = (affect [alpha] ?
 
1838
                         INT_MULT(opacity , src[alpha], tmp) : 0);
1753
1839
 
1754
1840
          dest += bytes;
1755
1841
          src += bytes;
1758
1844
}
1759
1845
 
1760
1846
inline void
1761
 
component_pixels (const guchar *src,
1762
 
                  guchar       *dest,
1763
 
                  guint         length,
1764
 
                  guint         bytes,
1765
 
                  guint         pixel)
 
1847
copy_component_pixels (const guchar *src,
 
1848
                       guchar       *dest,
 
1849
                       guint         length,
 
1850
                       guint         bytes,
 
1851
                       guint         pixel)
1766
1852
{
1767
1853
  src += pixel;
1768
1854
 
1775
1861
    }
1776
1862
}
1777
1863
 
 
1864
inline void
 
1865
copy_color_pixels (const guchar *src,
 
1866
                   guchar       *dest,
 
1867
                   guint         length,
 
1868
                   guint         bytes)
 
1869
{
 
1870
  const guint alpha = bytes - 1;
 
1871
 
 
1872
  while (length --)
 
1873
    {
 
1874
      guint b;
 
1875
 
 
1876
      for (b = 0; b < alpha; b++)
 
1877
        dest[b] = src[b];
 
1878
 
 
1879
      src  += bytes;
 
1880
      dest += bytes - 1;
 
1881
    }
 
1882
}
 
1883
 
1778
1884
 
1779
1885
static void
1780
1886
layer_normal_mode (struct apply_layer_mode_struct *alms)
1788
1894
{
1789
1895
  const guint has_alpha1 = HAS_ALPHA (alms->bytes1);
1790
1896
  const guint has_alpha2 = HAS_ALPHA (alms->bytes2);
1791
 
  guint dest_bytes;
 
1897
  guint       dest_bytes;
1792
1898
 
1793
1899
  /*  Since dissolve requires an alpha channel...  */
1794
1900
  if (has_alpha2)