← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gimp/vivid

« back to all changes in this revision

Viewing changes to app/core/gimpimage-convert.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach
  • Date: 2012-05-08 18:50:03 UTC
  • mto: (1.1.26) (0.5.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 71.
  • Revision ID: package-import@ubuntu.com-20120508185003-tltkvbaysf8d2426
Import upstream version 2.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/core/gimpimage-convert.c
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 * Copyright (C) 1997-2004 Adam D. Moss <adam@gimp.org>
4
4
 *
5
 
 * This program is free software; you can redistribute it and/or modify
 
5
 * This program is free software: you can redistribute it and/or modify
6
6
 * it under the terms of the GNU General Public License as published by
7
 
 * the Free Software Foundation; either version 2 of the License, or
 
7
 * the Free Software Foundation; either version 3 of the License, or
8
8
 * (at your option) any later version.
9
9
 *
10
10
 * This program is distributed in the hope that it will be useful,
13
13
 * GNU General Public License for more details.
14
14
 *
15
15
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
17
 */
19
18
 
20
19
/*
133
132
#include <stdio.h>
134
133
#include <string.h>
135
134
 
136
 
#include <glib-object.h>
 
135
#include <cairo.h>
 
136
#include <gegl.h>
137
137
 
138
138
#include "libgimpcolor/gimpcolor.h"
139
139
#include "libgimpmath/gimpmath.h"
145
145
#include "base/tile-manager.h"
146
146
 
147
147
#include "gimp.h"
 
148
#include "gimpcontainer.h"
148
149
#include "gimpdrawable.h"
149
 
#include "gimpdrawable-convert.h"
 
150
#include "gimperror.h"
150
151
#include "gimpimage.h"
151
152
#include "gimpimage-colormap.h"
152
153
#include "gimpimage-undo.h"
153
154
#include "gimpimage-undo-push.h"
154
 
#include "gimplist.h"
155
155
#include "gimplayer.h"
156
 
#include "gimplayer-floating-sel.h"
157
156
#include "gimppalette.h"
158
157
#include "gimpprogress.h"
159
158
 
692
691
 
693
692
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
694
693
                     0, 0,
695
 
                     gimp_item_width  (GIMP_ITEM (layer)),
696
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
694
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
695
                     gimp_item_get_height (GIMP_ITEM (layer)),
697
696
                     FALSE);
698
697
  pixel_region_init (&destPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
699
698
                     0, 0,
700
 
                     gimp_item_width  (GIMP_ITEM (layer)),
701
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
699
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
700
                     gimp_item_get_height (GIMP_ITEM (layer)),
702
701
                     TRUE);
703
702
 
704
703
  for (pr = pixel_regions_register (2, &srcPR, &destPR);
713
712
        {
714
713
          while (pixels--)
715
714
            {
716
 
              if (src[ALPHA_I_PIX])
717
 
                dest[INDEXED_PIX] = remap_table[src[INDEXED_PIX]];
 
715
              if (src[ALPHA_I])
 
716
                dest[INDEXED] = remap_table[src[INDEXED]];
718
717
 
719
718
              src += srcPR.bytes;
720
719
              dest += destPR.bytes;
724
723
        {
725
724
          while (pixels--)
726
725
            {
727
 
              dest[INDEXED_PIX] = remap_table[src[INDEXED_PIX]];
 
726
              dest[INDEXED] = remap_table[src[INDEXED]];
728
727
 
729
728
              src += srcPR.bytes;
730
729
              dest += destPR.bytes;
767
766
{
768
767
  QuantizeObj       *quantobj = NULL;
769
768
  GimpImageBaseType  old_type;
 
769
  GList             *all_layers;
770
770
  GList             *list;
771
771
  const gchar       *undo_desc = NULL;
772
772
  gint               nth_layer, n_layers;
781
781
      g_return_val_if_fail (custom_palette == NULL ||
782
782
                            GIMP_IS_PALETTE (custom_palette), FALSE);
783
783
      g_return_val_if_fail (custom_palette == NULL ||
784
 
                            custom_palette->n_colors <= 256, FALSE);
 
784
                            gimp_palette_get_n_colors (custom_palette) <= 256,
 
785
                            FALSE);
785
786
 
786
787
      if (! custom_palette)
787
788
        palette_type = GIMP_MONO_PALETTE;
788
789
 
789
 
      if (custom_palette->n_colors < 1)
 
790
      if (gimp_palette_get_n_colors (custom_palette) == 0)
790
791
        {
791
 
          g_set_error (error, 0, 0,
792
 
                       _("Cannot convert image: palette is empty."));
 
792
          g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
 
793
                               _("Cannot convert image: palette is empty."));
793
794
          return FALSE;
794
795
        }
795
796
    }
798
799
 
799
800
  gimp_set_busy (image->gimp);
800
801
 
801
 
  n_layers = g_list_length (GIMP_LIST (image->layers)->list);
 
802
  all_layers = gimp_image_get_layer_list (image);
 
803
 
 
804
  n_layers = g_list_length (all_layers);
802
805
 
803
806
  switch (new_type)
804
807
    {
805
808
    case GIMP_RGB:
806
 
      undo_desc = _("Convert Image to RGB");
 
809
      undo_desc = C_("undo-type", "Convert Image to RGB");
807
810
      break;
808
811
 
809
812
    case GIMP_GRAY:
810
 
      undo_desc = _("Convert Image to Grayscale");
 
813
      undo_desc = C_("undo-type", "Convert Image to Grayscale");
811
814
      break;
812
815
 
813
816
    case GIMP_INDEXED:
814
 
      undo_desc = _("Convert Image to Indexed");
 
817
      undo_desc = C_("undo-type", "Convert Image to Indexed");
815
818
      break;
816
819
    }
817
820
 
820
823
  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_CONVERT,
821
824
                               undo_desc);
822
825
 
823
 
  if (gimp_image_floating_sel (image))
824
 
    floating_sel_relax (gimp_image_floating_sel (image), TRUE);
825
 
 
826
826
  /*  Push the image type to the stack  */
827
827
  gimp_image_undo_push_image_type (image, NULL);
828
828
 
870
870
          num_found_cols = 0;
871
871
 
872
872
          /*  Build the histogram  */
873
 
          for (list = GIMP_LIST (image->layers)->list, nth_layer = 0;
 
873
          for (list = all_layers, nth_layer = 0;
874
874
               list;
875
875
               list = g_list_next (list), nth_layer++)
876
876
            {
955
955
  if (quantobj)
956
956
    quantobj->n_layers = n_layers;
957
957
 
958
 
  for (list = GIMP_LIST (image->layers)->list, nth_layer = 0;
 
958
  for (list = all_layers, nth_layer = 0;
959
959
       list;
960
960
       list = g_list_next (list), nth_layer++)
961
961
    {
962
 
      GimpLayer     *layer = list->data;
963
 
      GimpImageType  new_layer_type;
964
 
      TileManager   *new_tiles;
965
 
 
966
 
      new_layer_type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (new_type);
967
 
 
968
 
      if (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
969
 
        new_layer_type = GIMP_IMAGE_TYPE_WITH_ALPHA (new_layer_type);
970
 
 
971
 
      new_tiles = tile_manager_new (gimp_item_width  (GIMP_ITEM (layer)),
972
 
                                    gimp_item_height (GIMP_ITEM (layer)),
973
 
                                    GIMP_IMAGE_TYPE_BYTES (new_layer_type));
 
962
      GimpLayer *layer = list->data;
974
963
 
975
964
      switch (new_type)
976
965
        {
977
966
        case GIMP_RGB:
978
 
          gimp_drawable_convert_rgb (GIMP_DRAWABLE (layer),
979
 
                                     new_tiles, old_type);
980
 
          break;
981
967
        case GIMP_GRAY:
982
 
          gimp_drawable_convert_grayscale (GIMP_DRAWABLE (layer),
983
 
                                           new_tiles, old_type);
 
968
          gimp_drawable_convert_type (GIMP_DRAWABLE (layer), NULL, new_type,
 
969
                                      TRUE);
984
970
          break;
 
971
 
985
972
        case GIMP_INDEXED:
986
 
          quantobj->nth_layer = nth_layer;
987
 
          (* quantobj->second_pass) (quantobj, layer, new_tiles);
 
973
          {
 
974
            GimpImageType  new_layer_type;
 
975
            TileManager   *new_tiles;
 
976
 
 
977
            new_layer_type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (new_type);
 
978
 
 
979
            if (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
 
980
              new_layer_type = GIMP_IMAGE_TYPE_WITH_ALPHA (new_layer_type);
 
981
 
 
982
            new_tiles = tile_manager_new (gimp_item_get_width  (GIMP_ITEM (layer)),
 
983
                                          gimp_item_get_height (GIMP_ITEM (layer)),
 
984
                                          GIMP_IMAGE_TYPE_BYTES (new_layer_type));
 
985
 
 
986
            quantobj->nth_layer = nth_layer;
 
987
            (* quantobj->second_pass) (quantobj, layer, new_tiles);
 
988
 
 
989
            gimp_drawable_set_tiles (GIMP_DRAWABLE (layer), TRUE, NULL,
 
990
                                     new_tiles, new_layer_type);
 
991
            tile_manager_unref (new_tiles);
 
992
          }
988
993
          break;
 
994
 
989
995
        default:
990
996
          break;
991
997
        }
992
 
 
993
 
      gimp_drawable_set_tiles_full (GIMP_DRAWABLE (layer), TRUE, NULL,
994
 
                                    new_tiles, new_layer_type,
995
 
                                    GIMP_ITEM (layer)->offset_x,
996
 
                                    GIMP_ITEM (layer)->offset_y);
997
 
      tile_manager_unref (new_tiles);
998
998
    }
999
999
 
1000
1000
  switch (new_type)
1031
1031
                            remap_table, &num_entries);
1032
1032
 
1033
1033
          /*  Convert all layers  */
1034
 
          for (list = GIMP_LIST (image->layers)->list;
1035
 
               list;
1036
 
               list = g_list_next (list))
 
1034
          for (list = all_layers; list; list = g_list_next (list))
1037
1035
            {
1038
1036
              remap_indexed_layer (list->data, remap_table, num_entries);
1039
1037
            }
1068
1066
      break;
1069
1067
    }
1070
1068
 
 
1069
  /* TODO: attach or remove the ICC profile */
 
1070
  switch (new_type)
 
1071
    {
 
1072
    case GIMP_RGB:
 
1073
    case GIMP_INDEXED:
 
1074
      if (old_type == GIMP_GRAY)
 
1075
        gimp_image_parasite_detach (image, "icc-profile");
 
1076
      break;
 
1077
    case GIMP_GRAY:
 
1078
      gimp_image_parasite_detach (image, "icc-profile");
 
1079
      break;
 
1080
    default:
 
1081
      break;
 
1082
    }
 
1083
 
1071
1084
  /*  Delete the quantizer object, if there is one */
1072
1085
  if (quantobj)
1073
1086
    quantobj->delete_func (quantobj);
1074
1087
 
1075
 
  if (gimp_image_floating_sel (image))
1076
 
    floating_sel_rigor (gimp_image_floating_sel (image), TRUE);
1077
 
 
1078
1088
  gimp_image_undo_group_end (image);
1079
1089
 
1080
 
  gimp_image_invalidate_layer_previews (image);
1081
1090
  gimp_image_mode_changed (image);
1082
1091
  g_object_thaw_notify (G_OBJECT (image));
1083
1092
 
 
1093
  g_list_free (all_layers);
 
1094
 
1084
1095
  gimp_unset_busy (image->gimp);
1085
1096
 
1086
1097
  return TRUE;
1120
1131
 
1121
1132
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
1122
1133
                     0, 0,
1123
 
                     gimp_item_width  (GIMP_ITEM (layer)),
1124
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
1134
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
1135
                     gimp_item_get_height (GIMP_ITEM (layer)),
1125
1136
                     FALSE);
1126
1137
 
1127
1138
  for (pr = pixel_regions_register (1, &srcPR);
1135
1146
        {
1136
1147
          while (size--)
1137
1148
            {
1138
 
              if (data[ALPHA_G_PIX] > 127)
 
1149
              if (data[ALPHA_G] > 127)
1139
1150
                histogram[*data]++;
1140
1151
 
1141
1152
              data += srcPR.bytes;
1173
1184
  gint         count      = 0;
1174
1185
  gboolean     has_alpha  = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
1175
1186
 
1176
 
  gimp_item_offsets (GIMP_ITEM (layer), &offsetx, &offsety);
 
1187
  gimp_item_get_offset (GIMP_ITEM (layer), &offsetx, &offsety);
1177
1188
 
1178
1189
  /*  g_printerr ("col_limit = %d, nfc = %d\n", col_limit, num_found_cols); */
1179
1190
 
1180
1191
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
1181
1192
                     0, 0,
1182
 
                     gimp_item_width  (GIMP_ITEM (layer)),
1183
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
1193
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
1194
                     gimp_item_get_height (GIMP_ITEM (layer)),
1184
1195
                     FALSE);
1185
1196
 
1186
 
  layer_size = (gimp_item_width  (GIMP_ITEM (layer)) *
1187
 
                gimp_item_height (GIMP_ITEM (layer)));
 
1197
  layer_size = (gimp_item_get_width  (GIMP_ITEM (layer)) *
 
1198
                gimp_item_get_height (GIMP_ITEM (layer)));
1188
1199
 
1189
1200
  if (progress)
1190
1201
    gimp_progress_set_value (progress, 0.0);
1216
1227
                  gboolean transparent = FALSE;
1217
1228
 
1218
1229
                  if (has_alpha &&
1219
 
                      data[ALPHA_PIX] <
 
1230
                      data[ALPHA] <
1220
1231
                      DM[col & DM_WIDTHMASK][row & DM_HEIGHTMASK])
1221
1232
                    transparent = TRUE;
1222
1233
 
1223
1234
                  if (! transparent)
1224
1235
                    {
1225
1236
                      colfreq = HIST_RGB (histogram,
1226
 
                                          data[RED_PIX],
1227
 
                                          data[GREEN_PIX],
1228
 
                                          data[BLUE_PIX]);
 
1237
                                          data[RED],
 
1238
                                          data[GREEN],
 
1239
                                          data[BLUE]);
1229
1240
                      (*colfreq)++;
1230
1241
                    }
1231
1242
 
1243
1254
            {
1244
1255
              while (size--)
1245
1256
                {
1246
 
                  if ((has_alpha && ((data[ALPHA_PIX] > 127)))
 
1257
                  if ((has_alpha && ((data[ALPHA] > 127)))
1247
1258
                      || (!has_alpha))
1248
1259
                    {
1249
1260
                      colfreq = HIST_RGB (histogram,
1250
 
                                          data[RED_PIX],
1251
 
                                          data[GREEN_PIX],
1252
 
                                          data[BLUE_PIX]);
 
1261
                                          data[RED],
 
1262
                                          data[GREEN],
 
1263
                                          data[BLUE]);
1253
1264
                      (*colfreq)++;
1254
1265
                    }
1255
1266
                  data += srcPR.bytes;
1266
1277
          while (size--)
1267
1278
            {
1268
1279
              gboolean transparent = FALSE;
 
1280
 
1269
1281
              if (has_alpha)
1270
1282
                {
1271
1283
                  if (alpha_dither)
1272
1284
                    {
1273
 
                      if (data[ALPHA_PIX] <
 
1285
                      if (data[ALPHA] <
1274
1286
                          DM[col & DM_WIDTHMASK][row & DM_HEIGHTMASK])
1275
1287
                        transparent = TRUE;
1276
1288
                    }
1277
1289
                  else
1278
1290
                    {
1279
 
                      if (data[ALPHA_PIX] <= 127)
 
1291
                      if (data[ALPHA] <= 127)
1280
1292
                        transparent = TRUE;
1281
1293
                    }
1282
1294
                }
1283
1295
              if (! transparent)
1284
1296
                {
1285
1297
                  colfreq = HIST_RGB (histogram,
1286
 
                                      data[RED_PIX],
1287
 
                                      data[GREEN_PIX],
1288
 
                                      data[BLUE_PIX]);
 
1298
                                      data[RED],
 
1299
                                      data[GREEN],
 
1300
                                      data[BLUE]);
1289
1301
                  (*colfreq)++;
1290
1302
 
1291
1303
                  if (!needs_quantize)
1295
1307
                           nfc_iter++)
1296
1308
                        {
1297
1309
                          if (
1298
 
                              (data[RED_PIX] == found_cols[nfc_iter][0])
1299
 
                              &&
1300
 
                              (data[GREEN_PIX] == found_cols[nfc_iter][1])
1301
 
                              &&
1302
 
                              (data[BLUE_PIX] == found_cols[nfc_iter][2])
 
1310
                              (data[RED] == found_cols[nfc_iter][0])
 
1311
                              &&
 
1312
                              (data[GREEN] == found_cols[nfc_iter][1])
 
1313
                              &&
 
1314
                              (data[BLUE] == found_cols[nfc_iter][2])
1303
1315
                              )
1304
1316
                            goto already_found;
1305
1317
                        }
1325
1337
                        {
1326
1338
                          /* Remember the new colour we just found.
1327
1339
                           */
1328
 
                          found_cols[num_found_cols-1][0] = data[RED_PIX];
1329
 
                          found_cols[num_found_cols-1][1] = data[GREEN_PIX];
1330
 
                          found_cols[num_found_cols-1][2] = data[BLUE_PIX];
 
1340
                          found_cols[num_found_cols-1][0] = data[RED];
 
1341
                          found_cols[num_found_cols-1][1] = data[GREEN];
 
1342
                          found_cols[num_found_cols-1][2] = data[BLUE];
1331
1343
                        }
1332
1344
                    }
1333
1345
                }
1802
1814
 
1803
1815
  if (dist0 && dist1 && dist2)
1804
1816
  {
1805
 
    axisType longest_ax=AXIS_UNDEF, longest_ax2=AXIS_UNDEF;
 
1817
    axisType longest_ax=AXIS_UNDEF;
1806
1818
    int longest_length=0, longest_length2=0;
1807
1819
    int ratio;
1808
1820
 
1815
1827
    if ( dist0 >= longest_length)
1816
1828
      {
1817
1829
        longest_length2 = longest_length;
1818
 
        longest_ax2 = longest_ax;
1819
1830
        longest_length = dist0;
1820
1831
        longest_ax = AXIS_RED;
1821
1832
      }
1822
1833
    else if ( dist0 >= longest_length2)
1823
1834
      {
1824
1835
        longest_length2 = dist0;
1825
 
        longest_ax2 = AXIS_RED;
1826
1836
      }
1827
1837
 
1828
1838
    if ( dist1 >= longest_length)
1829
1839
      {
1830
1840
        longest_length2 = longest_length;
1831
 
        longest_ax2 = longest_ax;
1832
1841
        longest_length = dist1;
1833
1842
        longest_ax = AXIS_GREEN;
1834
1843
      }
1835
1844
    else if ( dist1 >= longest_length2)
1836
1845
      {
1837
1846
        longest_length2 = dist1;
1838
 
        longest_ax2 = AXIS_GREEN;
1839
1847
      }
1840
1848
 
1841
1849
    if ( dist2 >= longest_length)
1842
1850
      {
1843
1851
        longest_length2 = longest_length;
1844
 
        longest_ax2 = longest_ax;
1845
1852
        longest_length = dist2;
1846
1853
        longest_ax = AXIS_BLUE;
1847
1854
      }
1848
1855
    else if ( dist2 >= longest_length2)
1849
1856
      {
1850
1857
        longest_length2 = dist2;
1851
 
        longest_ax2 = AXIS_BLUE;
1852
1858
      }
1853
1859
 
1854
1860
    if (longest_length2 == 0)
2279
2285
    {
2280
2286
      compute_color_rgb (quantobj, histogram, &boxlist[i], i);
2281
2287
    }
 
2288
 
 
2289
  g_free (boxlist);
2282
2290
}
2283
2291
 
2284
2292
 
2521
2529
  int inR, inG, inB;    /* initial values for increments */
2522
2530
 
2523
2531
  /* This array holds the distance to the nearest-so-far color for each cell */
2524
 
  int bestdist[BOX_R_ELEMS * BOX_G_ELEMS * BOX_B_ELEMS];
 
2532
  int bestdist[BOX_R_ELEMS * BOX_G_ELEMS * BOX_B_ELEMS] = { 0, };
2525
2533
 
2526
2534
  /* Initialize best-distance for each cell of the update box */
2527
2535
  bptr = bestdist;
2642
2650
  int colorlist[MAXNUMCOLORS];
2643
2651
  int numcolors;                /* number of candidate colors */
2644
2652
  /* This array holds the actually closest colormap index for each cell. */
2645
 
  int bestcolor[BOX_R_ELEMS * BOX_G_ELEMS * BOX_B_ELEMS];
 
2653
  int bestcolor[BOX_R_ELEMS * BOX_G_ELEMS * BOX_B_ELEMS] = { 0, };
2646
2654
 
2647
2655
  /* Convert cell coordinates to update box id */
2648
2656
  R >>= BOX_R_LOG;
2723
2731
static void
2724
2732
custompal_pass1 (QuantizeObj *quantobj)
2725
2733
{
2726
 
  gint              i;
2727
 
  GList            *list;
2728
 
  GimpPaletteEntry *entry;
2729
 
  guchar            r, g, b;
 
2734
  gint   i;
 
2735
  GList *list;
2730
2736
 
2731
2737
  /* fprintf(stderr,
2732
2738
             "custompal_pass1: using (theCustomPalette %s) from (file %s)\n",
2733
2739
             theCustomPalette->name, theCustomPalette->filename); */
2734
2740
 
2735
 
  for (i = 0, list = theCustomPalette->colors;
 
2741
  for (i = 0, list = gimp_palette_get_colors (theCustomPalette);
2736
2742
       list;
2737
2743
       i++, list = g_list_next (list))
2738
2744
    {
2739
 
      entry = list->data;
 
2745
      GimpPaletteEntry *entry = list->data;
 
2746
      guchar            r, g, b;
2740
2747
 
2741
2748
      gimp_rgb_get_uchar (&entry->color, &r, &g, &b);
2742
2749
 
2770
2777
  gint          offsetx, offsety;
2771
2778
  gpointer      pr;
2772
2779
 
2773
 
  gimp_item_offsets (GIMP_ITEM (layer), &offsetx, &offsety);
 
2780
  gimp_item_get_offset (GIMP_ITEM (layer), &offsetx, &offsety);
2774
2781
 
2775
2782
  has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
2776
2783
 
2777
2784
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
2778
2785
                     0, 0,
2779
 
                     gimp_item_width  (GIMP_ITEM (layer)),
2780
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
2786
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
2787
                     gimp_item_get_height (GIMP_ITEM (layer)),
2781
2788
                     FALSE);
2782
2789
  pixel_region_init (&destPR, new_tiles,
2783
2790
                     0, 0,
2784
 
                     gimp_item_width  (GIMP_ITEM (layer)),
2785
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
2791
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
2792
                     gimp_item_get_height (GIMP_ITEM (layer)),
2786
2793
                     TRUE);
2787
2794
 
2788
2795
  for (pr = pixel_regions_register (2, &srcPR, &destPR);
2797
2804
          for (col = 0; col < srcPR.w; col++)
2798
2805
            {
2799
2806
              /* get pixel value and index into the cache */
2800
 
              pixel = src[GRAY_PIX];
 
2807
              pixel = src[GRAY];
2801
2808
              cachep = &histogram[pixel];
2802
2809
              /* If we have not seen this color before, find nearest colormap entry */
2803
2810
              /* and update the cache */
2810
2817
 
2811
2818
                  if (alpha_dither)
2812
2819
                    {
2813
 
                      gint dither_x = (col+offsetx+srcPR.x) & DM_WIDTHMASK;
2814
 
                      gint dither_y = (row+offsety+srcPR.y) & DM_HEIGHTMASK;
 
2820
                      gint dither_x = (col + offsetx + srcPR.x) & DM_WIDTHMASK;
 
2821
                      gint dither_y = (row + offsety + srcPR.y) & DM_HEIGHTMASK;
2815
2822
 
2816
 
                      if ((src[ALPHA_G_PIX]) < DM[dither_x][dither_y])
 
2823
                      if ((src[ALPHA_G]) < DM[dither_x][dither_y])
2817
2824
                        transparent = TRUE;
2818
2825
                    }
2819
2826
                  else
2820
2827
                    {
2821
 
                      if (src[ALPHA_G_PIX] <= 127)
 
2828
                      if (src[ALPHA_G] <= 127)
2822
2829
                        transparent = TRUE;
2823
2830
                    }
2824
2831
 
2825
2832
                  if (transparent)
2826
2833
                    {
2827
 
                      dest[ALPHA_I_PIX] = 0;
 
2834
                      dest[ALPHA_I] = 0;
2828
2835
                    }
2829
2836
                  else
2830
2837
                    {
2831
 
                      dest[ALPHA_I_PIX] = 255;
2832
 
                      index_used_count[dest[INDEXED_PIX] = *cachep - 1]++;
 
2838
                      dest[ALPHA_I] = 255;
 
2839
                      index_used_count[dest[INDEXED] = *cachep - 1]++;
2833
2840
                    }
2834
2841
                }
2835
2842
              else
2836
2843
                {
2837
2844
                  /* Now emit the colormap index for this cell */
2838
 
                  index_used_count[dest[INDEXED_PIX] = *cachep - 1]++;
 
2845
                  index_used_count[dest[INDEXED] = *cachep - 1]++;
2839
2846
                }
2840
2847
 
2841
2848
              src += srcPR.bytes;
2867
2874
  gint          offsetx, offsety;
2868
2875
  gpointer      pr;
2869
2876
 
2870
 
  gimp_item_offsets (GIMP_ITEM (layer), &offsetx, &offsety);
 
2877
  gimp_item_get_offset (GIMP_ITEM (layer), &offsetx, &offsety);
2871
2878
 
2872
2879
  has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
2873
2880
 
2874
2881
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
2875
2882
                     0, 0,
2876
 
                     gimp_item_width  (GIMP_ITEM (layer)),
2877
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
2883
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
2884
                     gimp_item_get_height (GIMP_ITEM (layer)),
2878
2885
                     FALSE);
2879
2886
  pixel_region_init (&destPR, new_tiles,
2880
2887
                     0, 0,
2881
 
                     gimp_item_width  (GIMP_ITEM (layer)),
2882
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
2888
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
2889
                     gimp_item_get_height (GIMP_ITEM (layer)),
2883
2890
                     TRUE);
2884
2891
 
2885
2892
  for (pr = pixel_regions_register (2, &srcPR, &destPR);
2894
2901
          for (col = 0; col < srcPR.w; col++)
2895
2902
            {
2896
2903
              const int dmval =
2897
 
                DM[(col+offsetx+srcPR.x) & DM_WIDTHMASK]
2898
 
                [(row+offsety+srcPR.y) & DM_HEIGHTMASK];
 
2904
                DM[(col + offsetx + srcPR.x) & DM_WIDTHMASK]
 
2905
                [(row + offsety + srcPR.y) & DM_HEIGHTMASK];
2899
2906
 
2900
2907
              /* get pixel value and index into the cache */
2901
 
              pixel = src[GRAY_PIX];
 
2908
              pixel = src[GRAY];
2902
2909
              cachep = &histogram[pixel];
2903
2910
              /* If we have not seen this color before, find nearest colormap entry */
2904
2911
              /* and update the cache */
2909
2916
              color1 = &quantobj->cmap[pixval1];
2910
2917
 
2911
2918
              if (quantobj->actual_number_of_colors > 2) {
2912
 
                const int re = src[GRAY_PIX] - (int)color1->red;
2913
 
                int RV = src[GRAY_PIX] + re;
 
2919
                const int re = src[GRAY] - (int)color1->red;
 
2920
                int RV = src[GRAY] + re;
2914
2921
                do {
2915
2922
                  const gint R = CLAMP0255(RV);
2916
2923
                  cachep = &histogram[R];
2944
2951
 
2945
2952
              color2 = &quantobj->cmap[pixval2];
2946
2953
 
2947
 
              err1 = ABS(color1->red - src[GRAY_PIX]);
2948
 
              err2 = ABS(color2->red - src[GRAY_PIX]);
 
2954
              err1 = ABS(color1->red - src[GRAY]);
 
2955
              err2 = ABS(color2->red - src[GRAY]);
2949
2956
              if (err1 || err2) {
2950
2957
                const int proportion2 = (256 * 255 * err2) / (err1 + err2);
2951
2958
                if ((dmval * 256) > proportion2) {
2959
2966
 
2960
2967
                  if (alpha_dither)
2961
2968
                    {
2962
 
                      if (src[ALPHA_G_PIX] < dmval)
 
2969
                      if (src[ALPHA_G] < dmval)
2963
2970
                        transparent = TRUE;
2964
2971
                    }
2965
2972
                  else
2966
2973
                    {
2967
 
                      if (src[ALPHA_G_PIX] <= 127)
 
2974
                      if (src[ALPHA_G] <= 127)
2968
2975
                        transparent = TRUE;
2969
2976
                    }
2970
2977
 
2971
2978
                  if (transparent)
2972
2979
                    {
2973
 
                      dest[ALPHA_I_PIX] = 0;
 
2980
                      dest[ALPHA_I] = 0;
2974
2981
                    }
2975
2982
                  else
2976
2983
                    {
2977
 
                      dest[ALPHA_I_PIX] = 255;
2978
 
                      index_used_count[dest[INDEXED_PIX] = pixval1]++;
 
2984
                      dest[ALPHA_I] = 255;
 
2985
                      index_used_count[dest[INDEXED] = pixval1]++;
2979
2986
                    }
2980
2987
                }
2981
2988
              else
2982
2989
                {
2983
2990
                  /* Now emit the colormap index for this cell, barfbarf */
2984
 
                  index_used_count[dest[INDEXED_PIX] = pixval1]++;
 
2991
                  index_used_count[dest[INDEXED] = pixval1]++;
2985
2992
                }
2986
2993
 
2987
2994
              src += srcPR.bytes;
3005
3012
  gint          row, col;
3006
3013
  gboolean      has_alpha;
3007
3014
  gpointer      pr;
3008
 
  gint          red_pix          = RED_PIX;
3009
 
  gint          green_pix        = GREEN_PIX;
3010
 
  gint          blue_pix         = BLUE_PIX;
3011
 
  gint          alpha_pix        = ALPHA_PIX;
 
3015
  gint          red_pix          = RED;
 
3016
  gint          green_pix        = GREEN;
 
3017
  gint          blue_pix         = BLUE;
 
3018
  gint          alpha_pix        = ALPHA;
3012
3019
  gboolean      alpha_dither     = quantobj->want_alpha_dither;
3013
3020
  gint          offsetx, offsety;
3014
3021
  gulong       *index_used_count = quantobj->index_used_count;
3018
3025
  gint          nth_layer        = quantobj->nth_layer;
3019
3026
  gint          n_layers         = quantobj->n_layers;
3020
3027
 
3021
 
  gimp_item_offsets (GIMP_ITEM (layer), &offsetx, &offsety);
 
3028
  gimp_item_get_offset (GIMP_ITEM (layer), &offsetx, &offsety);
3022
3029
 
3023
3030
  /*  In the case of web/mono palettes, we actually force
3024
3031
   *   grayscale drawables through the rgb pass2 functions
3025
3032
   */
3026
3033
  if (gimp_drawable_is_gray (GIMP_DRAWABLE (layer)))
3027
3034
    {
3028
 
      red_pix = green_pix = blue_pix = GRAY_PIX;
3029
 
      alpha_pix = ALPHA_G_PIX;
 
3035
      red_pix = green_pix = blue_pix = GRAY;
 
3036
      alpha_pix = ALPHA_G;
3030
3037
    }
3031
3038
 
3032
3039
  has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
3033
3040
 
3034
3041
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
3035
3042
                     0, 0,
3036
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3037
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3043
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3044
                     gimp_item_get_height (GIMP_ITEM (layer)),
3038
3045
                     FALSE);
3039
3046
  pixel_region_init (&destPR, new_tiles,
3040
3047
                     0, 0,
3041
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3042
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3048
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3049
                     gimp_item_get_height (GIMP_ITEM (layer)),
3043
3050
                     TRUE);
3044
3051
 
3045
 
  layer_size = (gimp_item_width  (GIMP_ITEM (layer)) *
3046
 
                gimp_item_height (GIMP_ITEM (layer)));
 
3052
  layer_size = (gimp_item_get_width  (GIMP_ITEM (layer)) *
 
3053
                gimp_item_get_height (GIMP_ITEM (layer)));
3047
3054
 
3048
3055
  for (pr = pixel_regions_register (2, &srcPR, &destPR);
3049
3056
       pr != NULL;
3064
3071
 
3065
3072
                  if (alpha_dither)
3066
3073
                    {
3067
 
                      gint dither_x = (col+offsetx+srcPR.x) & DM_WIDTHMASK;
3068
 
                      gint dither_y = (row+offsety+srcPR.y) & DM_HEIGHTMASK;
 
3074
                      gint dither_x = (col + offsetx + srcPR.x) & DM_WIDTHMASK;
 
3075
                      gint dither_y = (row + offsety + srcPR.y) & DM_HEIGHTMASK;
3069
3076
                      if ((src[alpha_pix]) < DM[dither_x][dither_y])
3070
3077
                        transparent = TRUE;
3071
3078
                    }
3077
3084
 
3078
3085
                  if (transparent)
3079
3086
                    {
3080
 
                      dest[ALPHA_I_PIX] = 0;
 
3087
                      dest[ALPHA_I] = 0;
3081
3088
                      goto next_pixel;
3082
3089
                    }
3083
3090
                  else
3084
3091
                    {
3085
 
                      dest[ALPHA_I_PIX] = 255;
 
3092
                      dest[ALPHA_I] = 255;
3086
3093
                    }
3087
3094
                }
3088
3095
 
3096
3103
                fill_inverse_cmap_rgb (quantobj, histogram, R, G, B);
3097
3104
 
3098
3105
              /* Now emit the colormap index for this cell, barfbarf */
3099
 
              index_used_count[dest[INDEXED_PIX] = *cachep - 1]++;
 
3106
              index_used_count[dest[INDEXED] = *cachep - 1]++;
3100
3107
 
3101
3108
            next_pixel:
3102
3109
 
3130
3137
  gint          row, col;
3131
3138
  gboolean      has_alpha;
3132
3139
  gpointer      pr;
3133
 
  gint          red_pix          = RED_PIX;
3134
 
  gint          green_pix        = GREEN_PIX;
3135
 
  gint          blue_pix         = BLUE_PIX;
3136
 
  gint          alpha_pix        = ALPHA_PIX;
 
3140
  gint          red_pix          = RED;
 
3141
  gint          green_pix        = GREEN;
 
3142
  gint          blue_pix         = BLUE;
 
3143
  gint          alpha_pix        = ALPHA;
3137
3144
  gboolean      alpha_dither     = quantobj->want_alpha_dither;
3138
3145
  gint          offsetx, offsety;
3139
3146
  gulong       *index_used_count = quantobj->index_used_count;
3143
3150
  gint          nth_layer        = quantobj->nth_layer;
3144
3151
  gint          n_layers         = quantobj->n_layers;
3145
3152
 
3146
 
  gimp_item_offsets (GIMP_ITEM (layer), &offsetx, &offsety);
 
3153
  gimp_item_get_offset (GIMP_ITEM (layer), &offsetx, &offsety);
3147
3154
 
3148
3155
  /*  In the case of web/mono palettes, we actually force
3149
3156
   *   grayscale drawables through the rgb pass2 functions
3150
3157
   */
3151
3158
  if (gimp_drawable_is_gray (GIMP_DRAWABLE (layer)))
3152
3159
    {
3153
 
      red_pix = green_pix = blue_pix = GRAY_PIX;
3154
 
      alpha_pix = ALPHA_G_PIX;
 
3160
      red_pix = green_pix = blue_pix = GRAY;
 
3161
      alpha_pix = ALPHA_G;
3155
3162
    }
3156
3163
 
3157
3164
  has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
3158
3165
 
3159
3166
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
3160
3167
                     0, 0,
3161
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3162
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3168
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3169
                     gimp_item_get_height (GIMP_ITEM (layer)),
3163
3170
                     FALSE);
3164
3171
  pixel_region_init (&destPR, new_tiles,
3165
3172
                     0, 0,
3166
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3167
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3173
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3174
                     gimp_item_get_height (GIMP_ITEM (layer)),
3168
3175
                     TRUE);
3169
3176
 
3170
 
  layer_size = (gimp_item_width  (GIMP_ITEM (layer)) *
3171
 
                gimp_item_height (GIMP_ITEM (layer)));
 
3177
  layer_size = (gimp_item_get_width  (GIMP_ITEM (layer)) *
 
3178
                gimp_item_get_height (GIMP_ITEM (layer)));
3172
3179
 
3173
3180
  for (pr = pixel_regions_register (2, &srcPR, &destPR);
3174
3181
       pr != NULL;
3184
3191
          for (col = 0; col < srcPR.w; col++)
3185
3192
            {
3186
3193
              const int dmval =
3187
 
                DM[(col+offsetx+srcPR.x) & DM_WIDTHMASK]
3188
 
                [(row+offsety+srcPR.y) & DM_HEIGHTMASK];
 
3194
                DM[(col + offsetx + srcPR.x) & DM_WIDTHMASK]
 
3195
                [(row + offsety + srcPR.y) & DM_HEIGHTMASK];
3189
3196
 
3190
3197
              if (has_alpha)
3191
3198
                {
3204
3211
 
3205
3212
                  if (transparent)
3206
3213
                    {
3207
 
                      dest[ALPHA_I_PIX] = 0;
 
3214
                      dest[ALPHA_I] = 0;
3208
3215
                      goto next_pixel;
3209
3216
                    }
3210
3217
                  else
3211
3218
                    {
3212
 
                      dest[ALPHA_I_PIX] = 255;
 
3219
                      dest[ALPHA_I] = 255;
3213
3220
                    }
3214
3221
                }
3215
3222
 
3307
3314
              }
3308
3315
 
3309
3316
              /* Now emit the colormap index for this cell, barfbarf */
3310
 
              index_used_count[dest[INDEXED_PIX] = pixval1]++;
 
3317
              index_used_count[dest[INDEXED] = pixval1]++;
3311
3318
 
3312
3319
            next_pixel:
3313
3320
 
3335
3342
  gboolean      has_alpha;
3336
3343
  gboolean      alpha_dither = quantobj->want_alpha_dither;
3337
3344
  gpointer      pr;
3338
 
  gint          red_pix = RED_PIX;
3339
 
  gint          green_pix = GREEN_PIX;
3340
 
  gint          blue_pix = BLUE_PIX;
3341
 
  gint          alpha_pix = ALPHA_PIX;
 
3345
  gint          red_pix = RED;
 
3346
  gint          green_pix = GREEN;
 
3347
  gint          blue_pix = BLUE;
 
3348
  gint          alpha_pix = ALPHA;
3342
3349
  gint          i;
3343
3350
  gint          lastindex = 0;
3344
3351
  gint          lastred = -1;
3346
3353
  gint          lastblue = -1;
3347
3354
  gint          offsetx, offsety;
3348
3355
 
3349
 
  gimp_item_offsets (GIMP_ITEM (layer), &offsetx, &offsety);
 
3356
  gimp_item_get_offset (GIMP_ITEM (layer), &offsetx, &offsety);
3350
3357
 
3351
3358
  has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
3352
3359
 
3353
3360
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
3354
3361
                     0, 0,
3355
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3356
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3362
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3363
                     gimp_item_get_height (GIMP_ITEM (layer)),
3357
3364
                     FALSE);
3358
3365
  pixel_region_init (&destPR, new_tiles, 0, 0,
3359
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3360
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3366
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3367
                     gimp_item_get_height (GIMP_ITEM (layer)),
3361
3368
                     TRUE);
3362
3369
 
3363
3370
  for (pr = pixel_regions_register (2, &srcPR, &destPR);
3397
3404
                      (lastblue == src[blue_pix]))
3398
3405
                    {
3399
3406
                      /*  same pixel colour as last time  */
3400
 
                      dest[INDEXED_PIX] = lastindex;
 
3407
                      dest[INDEXED] = lastindex;
3401
3408
                      if (has_alpha)
3402
 
                        dest[ALPHA_I_PIX] = 255;
 
3409
                        dest[ALPHA_I] = 255;
3403
3410
                    }
3404
3411
                  else
3405
3412
                    {
3423
3430
                      g_error ("Non-existant colour was expected to "
3424
3431
                               "be in non-destructive colourmap.");
3425
3432
                    got_colour:
3426
 
                      dest[INDEXED_PIX] = lastindex;
 
3433
                      dest[INDEXED] = lastindex;
3427
3434
                      if (has_alpha)
3428
 
                        dest[ALPHA_I_PIX] = 255;
 
3435
                        dest[ALPHA_I] = 255;
3429
3436
                    }
3430
3437
                }
3431
3438
              else
3432
3439
                { /*  have alpha, and transparent  */
3433
 
                  dest[ALPHA_I_PIX] = 0;
 
3440
                  dest[ALPHA_I] = 0;
3434
3441
                }
3435
3442
 
3436
3443
              src += srcPR.bytes;
3560
3567
  gint          width, height;
3561
3568
  gulong       *index_used_count = quantobj->index_used_count;
3562
3569
 
3563
 
  gimp_item_offsets (GIMP_ITEM (layer), &offsetx, &offsety);
 
3570
  gimp_item_get_offset (GIMP_ITEM (layer), &offsetx, &offsety);
3564
3571
 
3565
3572
  has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
3566
3573
 
3567
3574
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
3568
3575
                     0, 0,
3569
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3570
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3576
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3577
                     gimp_item_get_height (GIMP_ITEM (layer)),
3571
3578
                     FALSE);
3572
3579
  pixel_region_init (&destPR, new_tiles, 0, 0,
3573
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3574
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3580
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3581
                     gimp_item_get_height (GIMP_ITEM (layer)),
3575
3582
                     TRUE);
3576
3583
 
3577
 
  src_bytes  = GIMP_DRAWABLE (layer)->bytes;
 
3584
  src_bytes  = gimp_drawable_bytes (GIMP_DRAWABLE (layer));
3578
3585
  dest_bytes = tile_manager_bpp (new_tiles);
3579
 
  width      = gimp_item_width  (GIMP_ITEM (layer));
3580
 
  height     = gimp_item_height (GIMP_ITEM (layer));
 
3586
  width      = gimp_item_get_width  (GIMP_ITEM (layer));
 
3587
  height     = gimp_item_get_height (GIMP_ITEM (layer));
3581
3588
 
3582
3589
  error_limiter = init_error_limit (quantobj->error_freedom);
3583
3590
  range_limiter = range_array + 256;
3630
3637
 
3631
3638
      for (col = 0; col < width; col++)
3632
3639
        {
3633
 
          pixel = range_limiter[src[GRAY_PIX] + error_limiter[*pr]];
 
3640
          pixel = range_limiter[src[GRAY] + error_limiter[*pr]];
3634
3641
 
3635
3642
          cachep = &histogram[pixel];
3636
3643
          /* If we have not seen this color before, find nearest colormap entry */
3649
3656
                      gint dither_x = ((width-col)+offsetx-1) & DM_WIDTHMASK;
3650
3657
                      gint dither_y = (row+offsety) & DM_HEIGHTMASK;
3651
3658
 
3652
 
                      if ((src[ALPHA_G_PIX]) < DM[dither_x][dither_y])
 
3659
                      if ((src[ALPHA_G]) < DM[dither_x][dither_y])
3653
3660
                        transparent = TRUE;
3654
3661
                    }
3655
3662
                  else
3656
3663
                    {
3657
 
                      if (src[ALPHA_G_PIX] <= 127)
 
3664
                      if (src[ALPHA_G] <= 127)
3658
3665
                        transparent = TRUE;
3659
3666
                    }
3660
3667
 
3661
3668
                  if (transparent)
3662
3669
                    {
3663
 
                      dest[ALPHA_I_PIX] = 0;
 
3670
                      dest[ALPHA_I] = 0;
3664
3671
                      pr--;
3665
3672
                      nr--;
3666
3673
                      *(nr - 1) = 0;
3668
3675
                    }
3669
3676
                  else
3670
3677
                    {
3671
 
                      dest[ALPHA_I_PIX] = 255;
 
3678
                      dest[ALPHA_I] = 255;
3672
3679
                    }
3673
3680
                }
3674
3681
              else
3675
3682
                {
3676
3683
                  if (alpha_dither)
3677
3684
                    {
3678
 
                      gint dither_x = (col+offsetx) & DM_WIDTHMASK;
3679
 
                      gint dither_y = (row+offsety) & DM_HEIGHTMASK;
 
3685
                      gint dither_x = (col + offsetx) & DM_WIDTHMASK;
 
3686
                      gint dither_y = (row + offsety) & DM_HEIGHTMASK;
3680
3687
 
3681
 
                      if ((src[ALPHA_G_PIX]) < DM[dither_x][dither_y])
 
3688
                      if ((src[ALPHA_G]) < DM[dither_x][dither_y])
3682
3689
                        transparent = TRUE;
3683
3690
                    }
3684
3691
                  else
3685
3692
                    {
3686
 
                      if (src[ALPHA_G_PIX] <= 127)
 
3693
                      if (src[ALPHA_G] <= 127)
3687
3694
                        transparent = TRUE;
3688
3695
                    }
3689
3696
 
3690
3697
                  if (transparent)
3691
3698
                    {
3692
 
                      dest[ALPHA_I_PIX] = 0;
 
3699
                      dest[ALPHA_I] = 0;
3693
3700
                      pr++;
3694
3701
                      nr++;
3695
3702
                      *(nr + 1) = 0;
3697
3704
                    }
3698
3705
                  else
3699
3706
                    {
3700
 
                      dest[ALPHA_I_PIX] = 255;
 
3707
                      dest[ALPHA_I] = 255;
3701
3708
                    }
3702
3709
                }
3703
3710
            }
3704
3711
 
3705
3712
          index = *cachep - 1;
3706
 
          index_used_count[dest[INDEXED_PIX] = index]++;
 
3713
          index_used_count[dest[INDEXED] = index]++;
3707
3714
 
3708
3715
          color = &quantobj->cmap[index];
3709
3716
          pixele = pixel - color->red;
3807
3814
  gint          odd_row;
3808
3815
  gboolean      has_alpha;
3809
3816
  gint          width, height;
3810
 
  gint          red_pix   = RED_PIX;
3811
 
  gint          green_pix = GREEN_PIX;
3812
 
  gint          blue_pix  = BLUE_PIX;
3813
 
  gint          alpha_pix = ALPHA_PIX;
 
3817
  gint          red_pix   = RED;
 
3818
  gint          green_pix = GREEN;
 
3819
  gint          blue_pix  = BLUE;
 
3820
  gint          alpha_pix = ALPHA;
3814
3821
  gint          offsetx, offsety;
3815
3822
  gboolean      alpha_dither     = quantobj->want_alpha_dither;
3816
3823
  gulong       *index_used_count = quantobj->index_used_count;
3820
3827
  gint          nth_layer = quantobj->nth_layer;
3821
3828
  gint          n_layers  = quantobj->n_layers;
3822
3829
 
3823
 
  gimp_item_offsets (GIMP_ITEM (layer), &offsetx, &offsety);
 
3830
  gimp_item_get_offset (GIMP_ITEM (layer), &offsetx, &offsety);
3824
3831
 
3825
3832
  /*  In the case of web/mono palettes, we actually force
3826
3833
   *   grayscale drawables through the rgb pass2 functions
3827
3834
   */
3828
3835
  if (gimp_drawable_is_gray (GIMP_DRAWABLE (layer)))
3829
 
    red_pix = green_pix = blue_pix = GRAY_PIX;
 
3836
    red_pix = green_pix = blue_pix = GRAY;
3830
3837
 
3831
3838
  has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
3832
3839
 
3833
3840
  pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
3834
3841
                     0, 0,
3835
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3836
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3842
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3843
                     gimp_item_get_height (GIMP_ITEM (layer)),
3837
3844
                     FALSE);
3838
3845
  pixel_region_init (&destPR, new_tiles, 0, 0,
3839
 
                     gimp_item_width  (GIMP_ITEM (layer)),
3840
 
                     gimp_item_height (GIMP_ITEM (layer)),
 
3846
                     gimp_item_get_width  (GIMP_ITEM (layer)),
 
3847
                     gimp_item_get_height (GIMP_ITEM (layer)),
3841
3848
                     TRUE);
3842
3849
 
3843
 
  src_bytes  = GIMP_DRAWABLE(layer)->bytes;
 
3850
  src_bytes  = gimp_drawable_bytes (GIMP_DRAWABLE (layer));
3844
3851
  dest_bytes = tile_manager_bpp (new_tiles);
3845
 
  width      = gimp_item_width  (GIMP_ITEM (layer));
3846
 
  height     = gimp_item_height (GIMP_ITEM (layer));
 
3852
  width      = gimp_item_get_width  (GIMP_ITEM (layer));
 
3853
  height     = gimp_item_get_height (GIMP_ITEM (layer));
3847
3854
 
3848
3855
  error_limiter = init_error_limit (quantobj->error_freedom);
3849
3856
  range_limiter = range_array + 256;
3944
3951
 
3945
3952
                  if (transparent)
3946
3953
                    {
3947
 
                      dest[ALPHA_I_PIX] = 0;
 
3954
                      dest[ALPHA_I] = 0;
3948
3955
                      rpr--; gpr--; bpr--;
3949
3956
                      rnr--; gnr--; bnr--;
3950
3957
                      *(rnr - 1) = *(gnr - 1) = *(bnr - 1) = 0;
3952
3959
                    }
3953
3960
                  else
3954
3961
                    {
3955
 
                      dest[ALPHA_I_PIX] = 255;
 
3962
                      dest[ALPHA_I] = 255;
3956
3963
                    }
3957
3964
                }
3958
3965
              else
3959
3966
                {
3960
3967
                  if (alpha_dither)
3961
3968
                    {
3962
 
                      gint dither_x = (col+offsetx) & DM_WIDTHMASK;
3963
 
                      gint dither_y = (row+offsety) & DM_HEIGHTMASK;
 
3969
                      gint dither_x = (col + offsetx) & DM_WIDTHMASK;
 
3970
                      gint dither_y = (row + offsety) & DM_HEIGHTMASK;
3964
3971
 
3965
3972
                      if ((src[alpha_pix]) < DM[dither_x][dither_y])
3966
3973
                        transparent = TRUE;
3973
3980
 
3974
3981
                  if (transparent)
3975
3982
                    {
3976
 
                      dest[ALPHA_I_PIX] = 0;
 
3983
                      dest[ALPHA_I] = 0;
3977
3984
                      rpr++; gpr++; bpr++;
3978
3985
                      rnr++; gnr++; bnr++;
3979
3986
                      *(rnr + 1) = *(gnr + 1) = *(bnr + 1) = 0;
3981
3988
                    }
3982
3989
                  else
3983
3990
                    {
3984
 
                      dest[ALPHA_I_PIX] = 255;
 
3991
                      dest[ALPHA_I] = 255;
3985
3992
                    }
3986
3993
                }
3987
3994
            }
4025
4032
 
4026
4033
          index = *cachep - 1;
4027
4034
          index_used_count[index]++;
4028
 
          dest[INDEXED_PIX] = index;
 
4035
          dest[INDEXED] = index;
4029
4036
 
4030
4037
          /*if (re > global_rmax)
4031
4038
            re = (re + 3*global_rmax) / 4;