$OpenBSD: patch-filters_krita_gmagick_kis_image_magick_converter_cc,v 1.1 2009/01/08 19:57:49 kili Exp $
--- filters/krita/gmagick/kis_image_magick_converter.cc.orig	Wed May 30 23:39:37 2007
+++ filters/krita/gmagick/kis_image_magick_converter.cc	Mon Dec 15 23:10:01 2008
@@ -168,32 +168,22 @@ namespace {
 
     void setAnnotationsForImage(const Image * src, KisImageSP image)
     {
+	ImageProfileIterator ipi;
+	const char *name;
+	const unsigned char *profiledata;
         size_t length;
         
-        const unsigned char * profiledata = GetImageProfile(src, "IPTC", &length);
-        if( profiledata != NULL )
-        {
+	ipi = AllocateImageProfileIterator(src);
+	while (NextImageProfile(ipi, &name, &profiledata, &length) != MagickFail) {
             QByteArray rawdata;
             rawdata.resize(length);
             memcpy(rawdata.data(), profiledata, length);
-            
-            KisAnnotation* annotation = new KisAnnotation(QString("IPTC"), "", rawdata);
+            KisAnnotation* annotation = new KisAnnotation(QString(name), "", rawdata);
             Q_CHECK_PTR(annotation);
-
             image -> addAnnotation(annotation);
-        }
-        for(int i = 0; i < src->generic_profiles; i++)
-        {
-            QByteArray rawdata;
-            rawdata.resize(length);
-            memcpy(rawdata.data(), src->generic_profile[i].info, src->generic_profile[i].length);
-            
-            KisAnnotation* annotation = new KisAnnotation(QString(src->generic_profile[i].name), "", rawdata);
-            Q_CHECK_PTR(annotation);
+	}
+	DeallocateImageProfileIterator(ipi);
 
-            image -> addAnnotation(annotation);
-        }
-        
         const ImageAttribute* imgAttr = GetImageAttribute(src, NULL);
         while(imgAttr)
         {
@@ -480,7 +470,7 @@ KisImageBuilder_Result KisImageMagickConverter::decode
             Q_UINT8 opacity = OPACITY_OPAQUE;
             const ImageAttribute * attr = GetImageAttribute(image, "[layer-opacity]");
             if (attr != 0) {
-                opacity = Q_UINT8_MAX - Downscale(QString(attr->value).toInt());
+                opacity = Q_UINT8_MAX - ScaleQuantumToChar(QString(attr->value).toInt());
             }
 
             KisPaintLayerSP layer = 0;
@@ -534,17 +524,17 @@ KisImageBuilder_Result KisImageMagickConverter::decode
                         while (!hiter.isDone())
                         {
                             Q_UINT8 *ptr= hiter.rawData();
-                            *(ptr++) = Downscale(pp->red); // cyan
-                            *(ptr++) = Downscale(pp->green); // magenta
-                            *(ptr++) = Downscale(pp->blue); // yellow
-                            *(ptr++) = Downscale(indexes[x]); // Black
+                            *(ptr++) = ScaleQuantumToChar(pp->red); // cyan
+                            *(ptr++) = ScaleQuantumToChar(pp->green); // magenta
+                            *(ptr++) = ScaleQuantumToChar(pp->blue); // yellow
+                            *(ptr++) = ScaleQuantumToChar(indexes[x]); // Black
 // XXX: Warning! This ifdef messes up the paren matching big-time!
 #ifdef HAVE_MAGICK6
                             if (image->matte != MagickFalse) {
 #else
                             if (image->matte == true) {
 #endif
-                                *(ptr++) = OPACITY_OPAQUE - Downscale(pp->opacity);
+                                *(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
                             }
                             else {
                                 *(ptr++) = OPACITY_OPAQUE;
@@ -578,10 +568,10 @@ KisImageBuilder_Result KisImageMagickConverter::decode
                             {
                                 Q_UINT8 *ptr= hiter.rawData();
                                 // XXX: not colorstrategy and bitdepth independent
-                                *(ptr++) = Downscale(pp->blue);
-                                *(ptr++) = Downscale(pp->green);
-                                *(ptr++) = Downscale(pp->red);
-                                *(ptr++) = OPACITY_OPAQUE - Downscale(pp->opacity);
+                                *(ptr++) = ScaleQuantumToChar(pp->blue);
+                                *(ptr++) = ScaleQuantumToChar(pp->green);
+                                *(ptr++) = ScaleQuantumToChar(pp->red);
+                                *(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
 
                                 pp++;
                                 ++hiter;
@@ -608,8 +598,8 @@ KisImageBuilder_Result KisImageMagickConverter::decode
                             {
                                 Q_UINT8 *ptr= hiter.rawData();
                                 // XXX: not colorstrategy and bitdepth independent
-                                *(ptr++) = Downscale(pp->blue);
-                                *(ptr++) = OPACITY_OPAQUE - Downscale(pp->opacity);
+                                *(ptr++) = ScaleQuantumToChar(pp->blue);
+                                *(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
 
                                 pp++;
                                 ++hiter;
@@ -812,13 +802,13 @@ KisImageBuilder_Result KisImageMagickConverter::decode
                     while (!it.isDone()) {
 
                         Q_UINT8 * d = it.rawData();
-                        pp -> red = Upscale(d[PIXEL_CYAN]);
-                        pp -> green = Upscale(d[PIXEL_MAGENTA]);
-                        pp -> blue = Upscale(d[PIXEL_YELLOW]);
+                        pp -> red = ScaleCharToQuantum(d[PIXEL_CYAN]);
+                        pp -> green = ScaleCharToQuantum(d[PIXEL_MAGENTA]);
+                        pp -> blue = ScaleCharToQuantum(d[PIXEL_YELLOW]);
                         if (alpha)
-                            pp -> opacity = Upscale(OPACITY_OPAQUE - d[PIXEL_CMYK_ALPHA]);
+                            pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_CMYK_ALPHA]);
 
-                        indexes[x]= Upscale(d[PIXEL_BLACK]);
+                        indexes[x]= ScaleCharToQuantum(d[PIXEL_BLACK]);
 
                         x++;
                         pp++;
@@ -848,11 +838,11 @@ KisImageBuilder_Result KisImageMagickConverter::decode
                     while (!it.isDone()) {
 
                         Q_UINT8 * d = it.rawData();
-                        pp -> red = Upscale(d[PIXEL_RED]);
-                        pp -> green = Upscale(d[PIXEL_GREEN]);
-                        pp -> blue = Upscale(d[PIXEL_BLUE]);
+                        pp -> red = ScaleCharToQuantum(d[PIXEL_RED]);
+                        pp -> green = ScaleCharToQuantum(d[PIXEL_GREEN]);
+                        pp -> blue = ScaleCharToQuantum(d[PIXEL_BLUE]);
                         if (alpha)
-                            pp -> opacity = Upscale(OPACITY_OPAQUE - d[PIXEL_ALPHA]);
+                            pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_ALPHA]);
 
                         pp++;
                         ++it;
@@ -879,11 +869,11 @@ KisImageBuilder_Result KisImageMagickConverter::decode
                 else {
                     while (!it.isDone()) {
                         Q_UINT8 * d = it.rawData();
-                        pp -> red = Upscale(d[PIXEL_GRAY]);
-                        pp -> green = Upscale(d[PIXEL_GRAY]);
-                        pp -> blue = Upscale(d[PIXEL_GRAY]);
+                        pp -> red = ScaleCharToQuantum(d[PIXEL_GRAY]);
+                        pp -> green = ScaleCharToQuantum(d[PIXEL_GRAY]);
+                        pp -> blue = ScaleCharToQuantum(d[PIXEL_GRAY]);
                         if (alpha)
-                            pp -> opacity = Upscale(OPACITY_OPAQUE - d[PIXEL_GRAY_ALPHA]);
+                            pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_GRAY_ALPHA]);
 
                         pp++;
                         ++it;
