Extend image format support in third_party/icon_family

third_party/icon_family/IconFamily.m

 // IconFamily.m
 // IconFamily class implementation
 // by Troy Stephens, Thomas Schnitzer, David Remahl, Nathan Day, Ben Haller, Sven Janssen, Peter Hosey, Conor Dearden, Elliot Glaysher, and Dave MacLachlan
 // version 0.9.4
 //
 // Project Home Page:
 //   http://iconfamily.sourceforge.net/
 //
 // Problems, shortcomings, and uncertainties that I'm aware of are flagged with "NOTE:".  Please address bug reports, bug fixes, suggestions, etc. to the project Forums and bug tracker at https://sourceforge.net/projects/iconfamily/
 
@@ skipping 1218 matching lines @@
     [graphicsContext setImageInterpolation:previousImageInterpolation];
 
     [newImage unlockFocus];
         
     [workingImage release];
 
     // Return the new image!
     return [newImage autorelease];
 }
 
+void GetRGBAFrom32BitSource(unsigned char src1, unsigned char src2, unsigned char src3, unsigned char src4,
+                            unsigned char* redOut, unsigned char* greenOut, unsigned char* blueOut, unsigned char* alphaOut,
+                       bool isAlphaFirst, bool isAlphaPremultiplied) {
+    unsigned char r, g, b, a;
+    if (isAlphaFirst) {
+        a = src1;
+        r = src2;
+        g = src3;
+        b = src4;
+    } else {
+        r = src1;
+        g = src2;
+        b = src3;
+        a = src4;
+    }
+
+    if (isAlphaPremultiplied) {
+        // The RGB values are premultiplied by the alpha (so  that
+        // Quartz can save time when compositing the bitmap to a
+        // destination), and we undo this premultiplication (with some
+        // lossiness unfortunately) when retrieving the bitmap data.
+        float oneOverAlpha = 255.0f / (float)a;
+        r = r * oneOverAlpha;
+        g = g * oneOverAlpha;
+        b = b * oneOverAlpha;
+    }
+
+    if (redOut)
+      *redOut = r;
+    if (greenOut)
+      *greenOut = g;
+    if (blueOut)
+      *blueOut = b;
+    if (alphaOut)
+      *alphaOut = a;
+}
+
 + (Handle) get32BitDataFromBitmapImageRep:(NSBitmapImageRep*)bitmapImageRep requiredPixelSize:(int)requiredPixelSize
 {
     Handle hRawData;
     unsigned char* pRawData;
     Size rawDataSize;
     unsigned char* pSrc;
     unsigned char* pDest;
     int x, y;
-    unsigned char alphaByte;
-    float oneOverAlpha;
-    
+
     // Get information about the bitmapImageRep.
     long pixelsWide      = [bitmapImageRep pixelsWide];
     long pixelsHigh      = [bitmapImageRep pixelsHigh];
     long bitsPerSample   = [bitmapImageRep bitsPerSample];
     long samplesPerPixel = [bitmapImageRep samplesPerPixel];
     long bitsPerPixel    = [bitmapImageRep bitsPerPixel];
     BOOL isPlanar       = [bitmapImageRep isPlanar];
     long bytesPerRow     = [bitmapImageRep bytesPerRow];
     unsigned char* bitmapData = [bitmapImageRep bitmapData];
+    BOOL isAlphaFirst = [bitmapImageRep bitmapFormat] & NSAlphaFirstBitmapFormat;
+    BOOL isAlphaPremultiplied = !([bitmapImageRep bitmapFormat] & NSAlphaNonpremultipliedBitmapFormat);
 
     // Make sure bitmap has the required dimensions.
     if (pixelsWide != requiredPixelSize || pixelsHigh != requiredPixelSize)
         return NULL;
         
     // So far, this code only handles non-planar 32-bit RGBA and 24-bit RGB source bitmaps.
     // This could be made more flexible with some additional programming to accommodate other possible
     // formats...
     if (isPlanar)
         {
@@ skipping 13 matching lines @@
                 if (hRawData == NULL)
                         return NULL;
                 pRawData = (unsigned char*) *hRawData;
         
                 pDest = pRawData;
                 
                 if (bitsPerPixel == 32) {
                         for (y = 0; y < pixelsHigh; y++) {
                                 pSrc = bitmapData + y * bytesPerRow;
                                         for (x = 0; x < pixelsWide; x++) {
-                                                // Each pixel is 3 bytes of RGB data, followed by 1 byte of
-                                                // alpha.  The RGB values are premultiplied by the alpha (so
-                                                // that Quartz can save time when compositing the bitmap to a
-                                                // destination), and we undo this premultiplication (with some
-                                                // lossiness unfortunately) when retrieving the bitmap data.
-                                                *pDest++ = alphaByte = *(pSrc+3);
-                                                if (alphaByte) {
-                                                        oneOverAlpha = 255.0f / (float)alphaByte;
-                                                        *pDest++ = *(pSrc+0) * oneOverAlpha;
-                                                        *pDest++ = *(pSrc+1) * oneOverAlpha;
-                                                        *pDest++ = *(pSrc+2) * oneOverAlpha;
-                                                } else {
-                                                        *pDest++ = 0;
-                                                        *pDest++ = 0;
-                                                        *pDest++ = 0;
-                                                }
-                                                pSrc+=4;
+                        unsigned char r, g, b, a;
+                        GetRGBAFrom32BitSource(pSrc[0], pSrc[1], pSrc[2], pSrc[3],
+                                               &r, &g, &b, &a, isAlphaFirst, isAlphaPremultiplied);
+                        *pDest++ = a;
+                        *pDest++ = r;
+                        *pDest++ = g;
+                        *pDest++ = b;
+                        pSrc += 4;
                                 }
                         }
                 } else if (bitsPerPixel == 24) {
                         for (y = 0; y < pixelsHigh; y++) {
                                 pSrc = bitmapData + y * bytesPerRow;
                                 for (x = 0; x < pixelsWide; x++) {
                                         *pDest++ = 0xFF;
                                         *pDest++ = *pSrc++;
                                         *pDest++ = *pSrc++;
                                         *pDest++ = *pSrc++;
@@ skipping 21 matching lines @@
         
     // Get information about the bitmapImageRep.
     long pixelsWide      = [bitmapImageRep pixelsWide];
     long pixelsHigh      = [bitmapImageRep pixelsHigh];
     long bitsPerSample   = [bitmapImageRep bitsPerSample];
     long samplesPerPixel = [bitmapImageRep samplesPerPixel];
     long bitsPerPixel    = [bitmapImageRep bitsPerPixel];
     BOOL isPlanar       = [bitmapImageRep isPlanar];
     long bytesPerRow     = [bitmapImageRep bytesPerRow];
     unsigned char* bitmapData = [bitmapImageRep bitmapData];
+    BOOL isAlphaFirst = [bitmapImageRep bitmapFormat] & NSAlphaFirstBitmapFormat;
+    BOOL isAlphaPremultiplied = !([bitmapImageRep bitmapFormat] & NSAlphaNonpremultipliedBitmapFormat);
     
     // Make sure bitmap has the required dimensions.
     if (pixelsWide != requiredPixelSize || pixelsHigh != requiredPixelSize)
         return NULL;
         
     // So far, this code only handles non-planar 32-bit RGBA and 24-bit RGB source bitmaps.
     // This could be made more flexible with some additional programming...
     if (isPlanar)
         {
                 NSLog(@"get8BitDataFromBitmapImageRep:requiredPixelSize: returning NULL due to isPlanar == YES");
@@ skipping 16 matching lines @@
                         return NULL;
                 pRawData = (unsigned char*) *hRawData;
                 
                 cgPal = CGPaletteCreateDefaultColorPalette();
                 
                 pDest = pRawData;
                 if (bitsPerPixel == 32) {
                         for (y = 0; y < pixelsHigh; y++) {
                                 pSrc = bitmapData + y * bytesPerRow;
                                 for (x = 0; x < pixelsWide; x++) {
-                                        cgCol.red = ((float)*(pSrc)) / 255;
-                                        cgCol.green = ((float)*(pSrc+1)) / 255;
-                                        cgCol.blue = ((float)*(pSrc+2)) / 255;
+                    unsigned char r, g, b;
+                    GetRGBAFrom32BitSource(pSrc[0], pSrc[1], pSrc[2], pSrc[3],
+                                           &r, &g, &b, NULL, isAlphaFirst, isAlphaPremultiplied);
+                                        cgCol.red = (float)r / 255;
+                                        cgCol.green = (float)g / 255;
+                                        cgCol.blue = (float)b / 255;
         
                                         *pDest++ = CGPaletteGetIndexForColor(cgPal, cgCol);
         
                                         pSrc+=4;
                                 }
                         }
                 } else if (bitsPerPixel == 24) {
                         for (y = 0; y < pixelsHigh; y++) {
                                 pSrc = bitmapData + y * bytesPerRow;
                                 for (x = 0; x < pixelsWide; x++) {
@@ skipping 30 matching lines @@
     
     // Get information about the bitmapImageRep.
     long pixelsWide      = [bitmapImageRep pixelsWide];
     long pixelsHigh      = [bitmapImageRep pixelsHigh];
     long bitsPerSample   = [bitmapImageRep bitsPerSample];
     long samplesPerPixel = [bitmapImageRep samplesPerPixel];
     long bitsPerPixel    = [bitmapImageRep bitsPerPixel];
     BOOL isPlanar       = [bitmapImageRep isPlanar];
     long bytesPerRow     = [bitmapImageRep bytesPerRow];
     unsigned char* bitmapData = [bitmapImageRep bitmapData];
+    BOOL isAlphaFirst = [bitmapImageRep bitmapFormat] & NSAlphaFirstBitmapFormat;
+    BOOL isAlphaPremultiplied = !([bitmapImageRep bitmapFormat] & NSAlphaNonpremultipliedBitmapFormat);
 
     // Make sure bitmap has the required dimensions.
     if (pixelsWide != requiredPixelSize || pixelsHigh != requiredPixelSize)
                 return NULL;
         
     // So far, this code only handles non-planar 32-bit RGBA, 24-bit RGB and 8-bit grayscale source bitmaps.
     // This could be made more flexible with some additional programming...
     if (isPlanar)
         {
                 NSLog(@"get8BitMaskFromBitmapImageRep:requiredPixelSize: returning NULL due to isPlanar == YES");
@@ skipping 13 matching lines @@
                         return NULL;
                 pRawData = (unsigned char*) *hRawData;
         
                 pSrc = bitmapData;
                 pDest = pRawData;
                 
                 if (bitsPerPixel == 32) {
                         for (y = 0; y < pixelsHigh; y++) {
                                 pSrc = bitmapData + y * bytesPerRow;
                                 for (x = 0; x < pixelsWide; x++) {
-                                        pSrc += 3;
-                                        *pDest++ = *pSrc++;
+                    unsigned char a;
+                    GetRGBAFrom32BitSource(pSrc[0], pSrc[1], pSrc[2], pSrc[3],
+                                           NULL, NULL, NULL, &a, isAlphaFirst, isAlphaPremultiplied);
+                    *pDest++ = a;
+                                        pSrc += 4;
                                 }
                         }
                 }
                 else if (bitsPerPixel == 24) {
                         memset( pDest, 255, rawDataSize );
                 }
                 else if (bitsPerPixel == 8) {
                         for (y = 0; y < pixelsHigh; y++) {
                                 memcpy( pDest, pSrc, pixelsWide );
                                 pSrc += bytesPerRow;
@@ skipping 23 matching lines @@
     
     // Get information about the bitmapImageRep.
     long pixelsWide      = [bitmapImageRep pixelsWide];
     long pixelsHigh      = [bitmapImageRep pixelsHigh];
     long bitsPerSample   = [bitmapImageRep bitsPerSample];
     long samplesPerPixel = [bitmapImageRep samplesPerPixel];
     long bitsPerPixel    = [bitmapImageRep bitsPerPixel];
     BOOL isPlanar       = [bitmapImageRep isPlanar];
     long bytesPerRow     = [bitmapImageRep bytesPerRow];
     unsigned char* bitmapData = [bitmapImageRep bitmapData];
+    BOOL isAlphaFirst = [bitmapImageRep bitmapFormat] & NSAlphaFirstBitmapFormat;
+    BOOL isAlphaPremultiplied = !([bitmapImageRep bitmapFormat] & NSAlphaNonpremultipliedBitmapFormat);
         
     // Make sure bitmap has the required dimensions.
     if (pixelsWide != requiredPixelSize || pixelsHigh != requiredPixelSize)
                 return NULL;
         
     // So far, this code only handles non-planar 32-bit RGBA, 24-bit RGB, 8-bit grayscale, and 1-bit source bitmaps.
     // This could be made more flexible with some additional programming...
     if (isPlanar)
         {
                 NSLog(@"get1BitMaskFromBitmapImageRep:requiredPixelSize: returning NULL due to isPlanar == YES");
@@ skipping 10 matching lines @@
                 pRawData = (unsigned char*) *hRawData;
         
                 pSrc = bitmapData;
                 pDest = pRawData;
                 
                 if (bitsPerPixel == 32) {
                         for (y = 0; y < pixelsHigh; y++) {
                                 pSrc = bitmapData + y * bytesPerRow;
                                 for (x = 0; x < pixelsWide; x += 8) {
                                         maskByte = 0;
-                                        maskByte |= (*(unsigned*)pSrc & 0xff) ? 0x80 : 0; pSrc += 4;
-                                        maskByte |= (*(unsigned*)pSrc & 0xff) ? 0x40 : 0; pSrc += 4;
-                                        maskByte |= (*(unsigned*)pSrc & 0xff) ? 0x20 : 0; pSrc += 4;
-                                        maskByte |= (*(unsigned*)pSrc & 0xff) ? 0x10 : 0; pSrc += 4;
-                                        maskByte |= (*(unsigned*)pSrc & 0xff) ? 0x08 : 0; pSrc += 4;
-                                        maskByte |= (*(unsigned*)pSrc & 0xff) ? 0x04 : 0; pSrc += 4;
-                                        maskByte |= (*(unsigned*)pSrc & 0xff) ? 0x02 : 0; pSrc += 4;
-                                        maskByte |= (*(unsigned*)pSrc & 0xff) ? 0x01 : 0; pSrc += 4;
+                    for (int i = 7; i >= 0; i--) {
+                        unsigned char a;
+                        GetRGBAFrom32BitSource(pSrc[0], pSrc[1], pSrc[2], pSrc[3],
+                                               NULL, NULL, NULL, &a, isAlphaFirst, isAlphaPremultiplied);
+                        if (a)
+                            maskByte |= 1 << i;
+                        pSrc += 4;
+                    }
                                         *pDest++ = maskByte;
                                 }
                         }
                 }
                 else if (bitsPerPixel == 24) {
                         memset( pDest, 255, rawDataSize );
                 }
                 else if (bitsPerPixel == 8) {
                         for (y = 0; y < pixelsHigh; y++) {
                                 pSrc = bitmapData + y * bytesPerRow;
@@ skipping 150 matching lines @@
         if (![self respondsToSelector:@selector(bestRepresentationForRect:context:hints:)])
         {
                 return [self bestRepresentationForDevice:nil];
         }
 #endif
         
         return [self bestRepresentationForRect:(NSRect){NSZeroPoint, [self size]} context:nil hints:nil];
 }
 
 @end