gfx/thebes/src/gfxAlphaRecovery.cpp

   1
   2 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Thebes gfx.
  17  *
  18  * The Initial Developer of the Original Code is Mozilla Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 2007
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Vladimir Vukicevic <vladimir@pobox.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "gfxAlphaRecovery.h"
  40
  41 #include "gfxImageSurface.h"
  42
  43
  44 struct gfxAlphaRecoveryResult {
  45     gfxAlphaRecoveryResult()
  46         : uniformColor(PR_FALSE),
  47           uniformAlpha(PR_FALSE)
  48     { }
  49     PRBool uniformColor;
  50     PRBool uniformAlpha;
  51     gfxFloat alpha;
  52     gfxFloat r, g, b;
  53 };
  54
  55 static void _compute_alpha_values (unsigned int *black_data,
  56                                    unsigned int *white_data,
  57                                    gfxIntSize dimensions,
  58                                    gfxAlphaRecoveryResult *result);
  59
  60 already_AddRefed<gfxImageSurface>
  61 gfxAlphaRecovery::RecoverAlpha (gfxImageSurface *blackSurf,
  62                                 gfxImageSurface *whiteSurf,
  63                                 gfxIntSize dimensions)
  64 {
  65
  66     nsRefPtr<gfxImageSurface> resultSurf;
  67     resultSurf = new gfxImageSurface(dimensions, gfxASurface::ImageFormatARGB32);
  68
  69     // copy blackSurf into resultSurf
  70     gfxContext ctx(resultSurf);
  71     ctx.SetSource(blackSurf);
  72     ctx.SetOperator(gfxContext::OPERATOR_SOURCE);
  73     ctx.Paint();
  74
  75     gfxAlphaRecoveryResult result;
  76     _compute_alpha_values ((unsigned int*) resultSurf->Data(),
  77                            (unsigned int*) whiteSurf->Data(),
  78                            dimensions,
  79                            &result);
  80
  81     // XX use result, maybe return pattern, etc.
  82
  83     NS_ADDREF(resultSurf.get());
  84     return resultSurf.get();
  85 }
  86
  87 /** from cairo-xlib-utils.c, modified */
  88 /**
  89  * Given the RGB data for two image surfaces, one a source image composited
  90  * with OVER onto a black background, and one a source image composited with
  91  * OVER onto a white background, reconstruct the original image data into
  92  * black_data.
  93  *
  94  * Consider a single color channel and a given pixel. Suppose the original
  95  * premultiplied color value was C and the alpha value was A. Let the final
  96  * on-black color be B and the final on-white color be W. All values range
  97  * over 0-255.
  98  * Then B=C and W=(255*(255 - A) + C*255)/255. Solving for A, we get
  99  * A=255 - (W - C). Therefore it suffices to leave the black_data color
 100  * data alone and set the alpha values using that simple formula. It shouldn't
 101  * matter what color channel we pick for the alpha computation, but we'll
 102  * pick green because if we went through a color channel downsample the green
 103  * bits are likely to be the most accurate.
 104  */
 105
 106 #define SET_ALPHA(v, a) (((v) & ~(0xFF << 24)) | ((a) << 24))
 107 #define GREEN_OF(v) (((v) >> 8) & 0xFF)
 108
 109 static void
 110 _compute_alpha_values (unsigned int *black_data,
 111                        unsigned int *white_data,
 112                        gfxIntSize dimensions,
 113                        gfxAlphaRecoveryResult *result)
 114 {
 115     int num_pixels = dimensions.width * dimensions.height;
 116     int i;
 117     unsigned int first;
 118     unsigned int deltas = 0;
 119     unsigned char first_alpha;
 120
 121     if (num_pixels == 0) {
 122         if (result) {
 123             result->uniformAlpha = PR_TRUE;
 124             result->uniformColor = PR_TRUE;
 125             /* whatever we put here will be true */
 126             result->alpha = 1.0;
 127             result->r = result->g = result->b = 0.0;
 128         }
 129         return;
 130     }
 131
 132     first_alpha = 255 - (GREEN_OF(*white_data) - GREEN_OF(*black_data));
 133     /* set the alpha value of 'first' */
 134     first = SET_ALPHA(*black_data, first_alpha);
 135
 136     for (i = 0; i < num_pixels; ++i) {
 137         unsigned int black = *black_data;
 138         unsigned int white = *white_data;
 139         unsigned char pixel_alpha = 255 - (GREEN_OF(white) - GREEN_OF(black));
 140
 141         black = SET_ALPHA(black, pixel_alpha);
 142         *black_data = black;
 143         deltas |= (first ^ black);
 144
 145         black_data++;
 146         white_data++;
 147     }
 148
 149     if (result) {
 150         result->uniformAlpha = (deltas >> 24) == 0;
 151         if (result->uniformAlpha) {
 152             result->alpha = first_alpha/255.0;
 153             /* we only set uniformColor when the alpha is already uniform.
 154                it's only useful in that case ... and if the alpha was nonuniform
 155                then computing whether the color is uniform would require unpremultiplying
 156                every pixel */
 157             result->uniformColor = (deltas & ~(0xFF << 24)) == 0;
 158             if (result->uniformColor) {
 159                 if (first_alpha == 0) {
 160                     /* can't unpremultiply, this is OK */
 161                     result->r = result->g = result->b = 0.0;
 162                 } else {
 163                     double d_first_alpha = first_alpha;
 164                     result->r = (first & 0xFF)/d_first_alpha;
 165                     result->g = ((first >> 8) & 0xFF)/d_first_alpha;
 166                     result->b = ((first >> 16) & 0xFF)/d_first_alpha;
 167                 }
 168             }
 169         }
 170     }
 171 }