gfx/2d/FilterNodeD2D1.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "FilterNodeD2D1.h"
   8
   9 #include "Logging.h"
  10
  11 #include "SourceSurfaceD2D1.h"
  12 #include "DrawTargetD2D1.h"
  13 #include "ExtendInputEffectD2D1.h"
  14
  15 namespace mozilla {
  16 namespace gfx {
  17
  18 D2D1_COLORMATRIX_ALPHA_MODE D2DAlphaMode(uint32_t aMode)
  19 {
  20   switch (aMode) {
  21   case ALPHA_MODE_PREMULTIPLIED:
  22     return D2D1_COLORMATRIX_ALPHA_MODE_PREMULTIPLIED;
  23   case ALPHA_MODE_STRAIGHT:
  24     return D2D1_COLORMATRIX_ALPHA_MODE_STRAIGHT;
  25   default:
  26     MOZ_CRASH("GFX: Unknown enum value D2DAlphaMode!");
  27   }
  28
  29   return D2D1_COLORMATRIX_ALPHA_MODE_PREMULTIPLIED;
  30 }
  31
  32 D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE D2DAffineTransformInterpolationMode(SamplingFilter aSamplingFilter)
  33 {
  34   switch (aSamplingFilter) {
  35   case SamplingFilter::GOOD:
  36     return D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_LINEAR;
  37   case SamplingFilter::LINEAR:
  38     return D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_LINEAR;
  39   case SamplingFilter::POINT:
  40     return D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR;
  41   default:
  42     MOZ_CRASH("GFX: Unknown enum value D2DAffineTIM!");
  43   }
  44
  45   return D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_LINEAR;
  46 }
  47
  48 D2D1_BLEND_MODE D2DBlendMode(uint32_t aMode)
  49 {
  50   switch (aMode) {
  51   case BLEND_MODE_DARKEN:
  52     return D2D1_BLEND_MODE_DARKEN;
  53   case BLEND_MODE_LIGHTEN:
  54     return D2D1_BLEND_MODE_LIGHTEN;
  55   case BLEND_MODE_MULTIPLY:
  56     return D2D1_BLEND_MODE_MULTIPLY;
  57   case BLEND_MODE_SCREEN:
  58     return D2D1_BLEND_MODE_SCREEN;
  59   case BLEND_MODE_OVERLAY:
  60     return D2D1_BLEND_MODE_OVERLAY;
  61   case BLEND_MODE_COLOR_DODGE:
  62     return D2D1_BLEND_MODE_COLOR_DODGE;
  63   case BLEND_MODE_COLOR_BURN:
  64     return D2D1_BLEND_MODE_COLOR_BURN;
  65   case BLEND_MODE_HARD_LIGHT:
  66     return D2D1_BLEND_MODE_HARD_LIGHT;
  67   case BLEND_MODE_SOFT_LIGHT:
  68     return D2D1_BLEND_MODE_SOFT_LIGHT;
  69   case BLEND_MODE_DIFFERENCE:
  70     return D2D1_BLEND_MODE_DIFFERENCE;
  71   case BLEND_MODE_EXCLUSION:
  72     return D2D1_BLEND_MODE_EXCLUSION;
  73   case BLEND_MODE_HUE:
  74     return D2D1_BLEND_MODE_HUE;
  75   case BLEND_MODE_SATURATION:
  76     return D2D1_BLEND_MODE_SATURATION;
  77   case BLEND_MODE_COLOR:
  78     return D2D1_BLEND_MODE_COLOR;
  79   case BLEND_MODE_LUMINOSITY:
  80     return D2D1_BLEND_MODE_LUMINOSITY;
  81
  82   default:
  83     MOZ_CRASH("GFX: Unknown enum value D2DBlendMode!");
  84   }
  85
  86   return D2D1_BLEND_MODE_DARKEN;
  87 }
  88
  89 D2D1_MORPHOLOGY_MODE D2DMorphologyMode(uint32_t aMode)
  90 {
  91   switch (aMode) {
  92   case MORPHOLOGY_OPERATOR_DILATE:
  93     return D2D1_MORPHOLOGY_MODE_DILATE;
  94   case MORPHOLOGY_OPERATOR_ERODE:
  95     return D2D1_MORPHOLOGY_MODE_ERODE;
  96   }
  97
  98   MOZ_CRASH("GFX: Unknown enum value D2DMorphologyMode!");
  99   return D2D1_MORPHOLOGY_MODE_DILATE;
 100 }
 101
 102 D2D1_TURBULENCE_NOISE D2DTurbulenceNoise(uint32_t aMode)
 103 {
 104   switch (aMode) {
 105   case TURBULENCE_TYPE_FRACTAL_NOISE:
 106     return D2D1_TURBULENCE_NOISE_FRACTAL_SUM;
 107   case TURBULENCE_TYPE_TURBULENCE:
 108     return D2D1_TURBULENCE_NOISE_TURBULENCE;
 109   }
 110
 111   MOZ_CRASH("GFX: Unknown enum value D2DTurbulenceNoise!");
 112   return D2D1_TURBULENCE_NOISE_TURBULENCE;
 113 }
 114
 115 D2D1_COMPOSITE_MODE D2DFilterCompositionMode(uint32_t aMode)
 116 {
 117   switch (aMode) {
 118   case COMPOSITE_OPERATOR_OVER:
 119     return D2D1_COMPOSITE_MODE_SOURCE_OVER;
 120   case COMPOSITE_OPERATOR_IN:
 121     return D2D1_COMPOSITE_MODE_SOURCE_IN;
 122   case COMPOSITE_OPERATOR_OUT:
 123     return D2D1_COMPOSITE_MODE_SOURCE_OUT;
 124   case COMPOSITE_OPERATOR_ATOP:
 125     return D2D1_COMPOSITE_MODE_SOURCE_ATOP;
 126   case COMPOSITE_OPERATOR_XOR:
 127     return D2D1_COMPOSITE_MODE_XOR;
 128   }
 129
 130   MOZ_CRASH("GFX: Unknown enum value D2DFilterCompositionMode!");
 131   return D2D1_COMPOSITE_MODE_SOURCE_OVER;
 132 }
 133
 134 D2D1_CHANNEL_SELECTOR D2DChannelSelector(uint32_t aMode)
 135 {
 136   switch (aMode) {
 137   case COLOR_CHANNEL_R:
 138     return D2D1_CHANNEL_SELECTOR_R;
 139   case COLOR_CHANNEL_G:
 140     return D2D1_CHANNEL_SELECTOR_G;
 141   case COLOR_CHANNEL_B:
 142     return D2D1_CHANNEL_SELECTOR_B;
 143   case COLOR_CHANNEL_A:
 144     return D2D1_CHANNEL_SELECTOR_A;
 145   }
 146
 147   MOZ_CRASH("GFX: Unknown enum value D2DChannelSelector!");
 148   return D2D1_CHANNEL_SELECTOR_R;
 149 }
 150
 151 already_AddRefed<ID2D1Image> GetImageForSourceSurface(DrawTarget *aDT, SourceSurface *aSurface)
 152 {
 153   if (aDT->IsTiledDrawTarget() || aDT->IsDualDrawTarget() || aDT->IsCaptureDT()) {
 154     gfxDevCrash(LogReason::FilterNodeD2D1Target) << "Incompatible draw target type! " << (int)aDT->IsTiledDrawTarget() << " " << (int)aDT->IsDualDrawTarget();
 155     return nullptr;
 156   }
 157   switch (aDT->GetBackendType()) {
 158     case BackendType::DIRECT2D1_1:
 159       return static_cast<DrawTargetD2D1*>(aDT)->GetImageForSurface(aSurface, ExtendMode::CLAMP);
 160     default:
 161       gfxDevCrash(LogReason::FilterNodeD2D1Backend) << "Unknown draw target type! " << (int)aDT->GetBackendType();
 162       return nullptr;
 163   }
 164 }
 165
 166 uint32_t ConvertValue(FilterType aType, uint32_t aAttribute, uint32_t aValue)
 167 {
 168   switch (aType) {
 169   case FilterType::COLOR_MATRIX:
 170     if (aAttribute == ATT_COLOR_MATRIX_ALPHA_MODE) {
 171       aValue = D2DAlphaMode(aValue);
 172     }
 173     break;
 174   case FilterType::TRANSFORM:
 175     if (aAttribute == ATT_TRANSFORM_FILTER) {
 176       aValue = D2DAffineTransformInterpolationMode(SamplingFilter(aValue));
 177     }
 178     break;
 179   case FilterType::BLEND:
 180     if (aAttribute == ATT_BLEND_BLENDMODE) {
 181       aValue = D2DBlendMode(aValue);
 182     }
 183     break;
 184   case FilterType::MORPHOLOGY:
 185     if (aAttribute == ATT_MORPHOLOGY_OPERATOR) {
 186       aValue = D2DMorphologyMode(aValue);
 187     }
 188     break;
 189   case FilterType::DISPLACEMENT_MAP:
 190     if (aAttribute == ATT_DISPLACEMENT_MAP_X_CHANNEL ||
 191         aAttribute == ATT_DISPLACEMENT_MAP_Y_CHANNEL) {
 192       aValue = D2DChannelSelector(aValue);
 193     }
 194     break;
 195   case FilterType::TURBULENCE:
 196     if (aAttribute == ATT_TURBULENCE_TYPE) {
 197       aValue = D2DTurbulenceNoise(aValue);
 198     }
 199     break;
 200   case FilterType::COMPOSITE:
 201     if (aAttribute == ATT_COMPOSITE_OPERATOR) {
 202       aValue = D2DFilterCompositionMode(aValue);
 203     }
 204     break;
 205   default:
 206     break;
 207   }
 208
 209   return aValue;
 210 }
 211
 212 void ConvertValue(FilterType aType, uint32_t aAttribute, IntSize &aValue)
 213 {
 214   switch (aType) {
 215   case FilterType::MORPHOLOGY:
 216     if (aAttribute == ATT_MORPHOLOGY_RADII) {
 217       aValue.width *= 2;
 218       aValue.width += 1;
 219       aValue.height *= 2;
 220       aValue.height += 1;
 221     }
 222     break;
 223   default:
 224     break;
 225   }
 226 }
 227
 228 UINT32
 229 GetD2D1InputForInput(FilterType aType, uint32_t aIndex)
 230 {
 231   return aIndex;
 232 }
 233
 234 #define CONVERT_PROP(moz2dname, d2dname) \
 235   case ATT_##moz2dname: \
 236   return D2D1_##d2dname
 237
 238 UINT32
 239 GetD2D1PropForAttribute(FilterType aType, uint32_t aIndex)
 240 {
 241   switch (aType) {
 242   case FilterType::COLOR_MATRIX:
 243     switch (aIndex) {
 244       CONVERT_PROP(COLOR_MATRIX_MATRIX, COLORMATRIX_PROP_COLOR_MATRIX);
 245       CONVERT_PROP(COLOR_MATRIX_ALPHA_MODE, COLORMATRIX_PROP_ALPHA_MODE);
 246     }
 247     break;
 248   case FilterType::TRANSFORM:
 249     switch (aIndex) {
 250       CONVERT_PROP(TRANSFORM_MATRIX, 2DAFFINETRANSFORM_PROP_TRANSFORM_MATRIX);
 251       CONVERT_PROP(TRANSFORM_FILTER, 2DAFFINETRANSFORM_PROP_INTERPOLATION_MODE);
 252     }
 253   case FilterType::BLEND:
 254     switch (aIndex) {
 255       CONVERT_PROP(BLEND_BLENDMODE, BLEND_PROP_MODE);
 256     }
 257     break;
 258   case FilterType::MORPHOLOGY:
 259     switch (aIndex) {
 260       CONVERT_PROP(MORPHOLOGY_OPERATOR, MORPHOLOGY_PROP_MODE);
 261     }
 262     break;
 263   case FilterType::FLOOD:
 264     switch (aIndex) {
 265       CONVERT_PROP(FLOOD_COLOR, FLOOD_PROP_COLOR);
 266     }
 267     break;
 268   case FilterType::TILE:
 269     switch (aIndex) {
 270       CONVERT_PROP(TILE_SOURCE_RECT, TILE_PROP_RECT);
 271     }
 272     break;
 273   case FilterType::TABLE_TRANSFER:
 274     switch (aIndex) {
 275       CONVERT_PROP(TABLE_TRANSFER_DISABLE_R, TABLETRANSFER_PROP_RED_DISABLE);
 276       CONVERT_PROP(TABLE_TRANSFER_DISABLE_G, TABLETRANSFER_PROP_GREEN_DISABLE);
 277       CONVERT_PROP(TABLE_TRANSFER_DISABLE_B, TABLETRANSFER_PROP_BLUE_DISABLE);
 278       CONVERT_PROP(TABLE_TRANSFER_DISABLE_A, TABLETRANSFER_PROP_ALPHA_DISABLE);
 279       CONVERT_PROP(TABLE_TRANSFER_TABLE_R, TABLETRANSFER_PROP_RED_TABLE);
 280       CONVERT_PROP(TABLE_TRANSFER_TABLE_G, TABLETRANSFER_PROP_GREEN_TABLE);
 281       CONVERT_PROP(TABLE_TRANSFER_TABLE_B, TABLETRANSFER_PROP_BLUE_TABLE);
 282       CONVERT_PROP(TABLE_TRANSFER_TABLE_A, TABLETRANSFER_PROP_ALPHA_TABLE);
 283     }
 284     break;
 285   case FilterType::DISCRETE_TRANSFER:
 286     switch (aIndex) {
 287       CONVERT_PROP(DISCRETE_TRANSFER_DISABLE_R, DISCRETETRANSFER_PROP_RED_DISABLE);
 288       CONVERT_PROP(DISCRETE_TRANSFER_DISABLE_G, DISCRETETRANSFER_PROP_GREEN_DISABLE);
 289       CONVERT_PROP(DISCRETE_TRANSFER_DISABLE_B, DISCRETETRANSFER_PROP_BLUE_DISABLE);
 290       CONVERT_PROP(DISCRETE_TRANSFER_DISABLE_A, DISCRETETRANSFER_PROP_ALPHA_DISABLE);
 291       CONVERT_PROP(DISCRETE_TRANSFER_TABLE_R, DISCRETETRANSFER_PROP_RED_TABLE);
 292       CONVERT_PROP(DISCRETE_TRANSFER_TABLE_G, DISCRETETRANSFER_PROP_GREEN_TABLE);
 293       CONVERT_PROP(DISCRETE_TRANSFER_TABLE_B, DISCRETETRANSFER_PROP_BLUE_TABLE);
 294       CONVERT_PROP(DISCRETE_TRANSFER_TABLE_A, DISCRETETRANSFER_PROP_ALPHA_TABLE);
 295     }
 296     break;
 297   case FilterType::LINEAR_TRANSFER:
 298     switch (aIndex) {
 299       CONVERT_PROP(LINEAR_TRANSFER_DISABLE_R, LINEARTRANSFER_PROP_RED_DISABLE);
 300       CONVERT_PROP(LINEAR_TRANSFER_DISABLE_G, LINEARTRANSFER_PROP_GREEN_DISABLE);
 301       CONVERT_PROP(LINEAR_TRANSFER_DISABLE_B, LINEARTRANSFER_PROP_BLUE_DISABLE);
 302       CONVERT_PROP(LINEAR_TRANSFER_DISABLE_A, LINEARTRANSFER_PROP_ALPHA_DISABLE);
 303       CONVERT_PROP(LINEAR_TRANSFER_INTERCEPT_R, LINEARTRANSFER_PROP_RED_Y_INTERCEPT);
 304       CONVERT_PROP(LINEAR_TRANSFER_INTERCEPT_G, LINEARTRANSFER_PROP_GREEN_Y_INTERCEPT);
 305       CONVERT_PROP(LINEAR_TRANSFER_INTERCEPT_B, LINEARTRANSFER_PROP_BLUE_Y_INTERCEPT);
 306       CONVERT_PROP(LINEAR_TRANSFER_INTERCEPT_A, LINEARTRANSFER_PROP_ALPHA_Y_INTERCEPT);
 307       CONVERT_PROP(LINEAR_TRANSFER_SLOPE_R, LINEARTRANSFER_PROP_RED_SLOPE);
 308       CONVERT_PROP(LINEAR_TRANSFER_SLOPE_G, LINEARTRANSFER_PROP_GREEN_SLOPE);
 309       CONVERT_PROP(LINEAR_TRANSFER_SLOPE_B, LINEARTRANSFER_PROP_BLUE_SLOPE);
 310       CONVERT_PROP(LINEAR_TRANSFER_SLOPE_A, LINEARTRANSFER_PROP_ALPHA_SLOPE);
 311     }
 312     break;
 313   case FilterType::GAMMA_TRANSFER:
 314     switch (aIndex) {
 315       CONVERT_PROP(GAMMA_TRANSFER_DISABLE_R, GAMMATRANSFER_PROP_RED_DISABLE);
 316       CONVERT_PROP(GAMMA_TRANSFER_DISABLE_G, GAMMATRANSFER_PROP_GREEN_DISABLE);
 317       CONVERT_PROP(GAMMA_TRANSFER_DISABLE_B, GAMMATRANSFER_PROP_BLUE_DISABLE);
 318       CONVERT_PROP(GAMMA_TRANSFER_DISABLE_A, GAMMATRANSFER_PROP_ALPHA_DISABLE);
 319       CONVERT_PROP(GAMMA_TRANSFER_AMPLITUDE_R, GAMMATRANSFER_PROP_RED_AMPLITUDE);
 320       CONVERT_PROP(GAMMA_TRANSFER_AMPLITUDE_G, GAMMATRANSFER_PROP_GREEN_AMPLITUDE);
 321       CONVERT_PROP(GAMMA_TRANSFER_AMPLITUDE_B, GAMMATRANSFER_PROP_BLUE_AMPLITUDE);
 322       CONVERT_PROP(GAMMA_TRANSFER_AMPLITUDE_A, GAMMATRANSFER_PROP_ALPHA_AMPLITUDE);
 323       CONVERT_PROP(GAMMA_TRANSFER_EXPONENT_R, GAMMATRANSFER_PROP_RED_EXPONENT);
 324       CONVERT_PROP(GAMMA_TRANSFER_EXPONENT_G, GAMMATRANSFER_PROP_GREEN_EXPONENT);
 325       CONVERT_PROP(GAMMA_TRANSFER_EXPONENT_B, GAMMATRANSFER_PROP_BLUE_EXPONENT);
 326       CONVERT_PROP(GAMMA_TRANSFER_EXPONENT_A, GAMMATRANSFER_PROP_ALPHA_EXPONENT);
 327       CONVERT_PROP(GAMMA_TRANSFER_OFFSET_R, GAMMATRANSFER_PROP_RED_OFFSET);
 328       CONVERT_PROP(GAMMA_TRANSFER_OFFSET_G, GAMMATRANSFER_PROP_GREEN_OFFSET);
 329       CONVERT_PROP(GAMMA_TRANSFER_OFFSET_B, GAMMATRANSFER_PROP_BLUE_OFFSET);
 330       CONVERT_PROP(GAMMA_TRANSFER_OFFSET_A, GAMMATRANSFER_PROP_ALPHA_OFFSET);
 331     }
 332     break;
 333   case FilterType::CONVOLVE_MATRIX:
 334     switch (aIndex) {
 335       CONVERT_PROP(CONVOLVE_MATRIX_BIAS, CONVOLVEMATRIX_PROP_BIAS);
 336       CONVERT_PROP(CONVOLVE_MATRIX_KERNEL_MATRIX, CONVOLVEMATRIX_PROP_KERNEL_MATRIX);
 337       CONVERT_PROP(CONVOLVE_MATRIX_DIVISOR, CONVOLVEMATRIX_PROP_DIVISOR);
 338       CONVERT_PROP(CONVOLVE_MATRIX_KERNEL_UNIT_LENGTH, CONVOLVEMATRIX_PROP_KERNEL_UNIT_LENGTH);
 339       CONVERT_PROP(CONVOLVE_MATRIX_PRESERVE_ALPHA, CONVOLVEMATRIX_PROP_PRESERVE_ALPHA);
 340     }
 341   case FilterType::DISPLACEMENT_MAP:
 342     switch (aIndex) {
 343       CONVERT_PROP(DISPLACEMENT_MAP_SCALE, DISPLACEMENTMAP_PROP_SCALE);
 344       CONVERT_PROP(DISPLACEMENT_MAP_X_CHANNEL, DISPLACEMENTMAP_PROP_X_CHANNEL_SELECT);
 345       CONVERT_PROP(DISPLACEMENT_MAP_Y_CHANNEL, DISPLACEMENTMAP_PROP_Y_CHANNEL_SELECT);
 346     }
 347     break;
 348   case FilterType::TURBULENCE:
 349     switch (aIndex) {
 350       CONVERT_PROP(TURBULENCE_BASE_FREQUENCY, TURBULENCE_PROP_BASE_FREQUENCY);
 351       CONVERT_PROP(TURBULENCE_NUM_OCTAVES, TURBULENCE_PROP_NUM_OCTAVES);
 352       CONVERT_PROP(TURBULENCE_SEED, TURBULENCE_PROP_SEED);
 353       CONVERT_PROP(TURBULENCE_STITCHABLE, TURBULENCE_PROP_STITCHABLE);
 354       CONVERT_PROP(TURBULENCE_TYPE, TURBULENCE_PROP_NOISE);
 355     }
 356     break;
 357   case FilterType::ARITHMETIC_COMBINE:
 358     switch (aIndex) {
 359       CONVERT_PROP(ARITHMETIC_COMBINE_COEFFICIENTS, ARITHMETICCOMPOSITE_PROP_COEFFICIENTS);
 360     }
 361     break;
 362   case FilterType::COMPOSITE:
 363     switch (aIndex) {
 364       CONVERT_PROP(COMPOSITE_OPERATOR, COMPOSITE_PROP_MODE);
 365     }
 366     break;
 367   case FilterType::GAUSSIAN_BLUR:
 368     switch (aIndex) {
 369       CONVERT_PROP(GAUSSIAN_BLUR_STD_DEVIATION, GAUSSIANBLUR_PROP_STANDARD_DEVIATION);
 370     }
 371     break;
 372   case FilterType::DIRECTIONAL_BLUR:
 373     switch (aIndex) {
 374       CONVERT_PROP(DIRECTIONAL_BLUR_STD_DEVIATION, DIRECTIONALBLUR_PROP_STANDARD_DEVIATION);
 375       CONVERT_PROP(DIRECTIONAL_BLUR_DIRECTION, DIRECTIONALBLUR_PROP_ANGLE);
 376     }
 377     break;
 378   case FilterType::POINT_DIFFUSE:
 379     switch (aIndex) {
 380       CONVERT_PROP(POINT_DIFFUSE_DIFFUSE_CONSTANT, POINTDIFFUSE_PROP_DIFFUSE_CONSTANT);
 381       CONVERT_PROP(POINT_DIFFUSE_POSITION, POINTDIFFUSE_PROP_LIGHT_POSITION);
 382       CONVERT_PROP(POINT_DIFFUSE_COLOR, POINTDIFFUSE_PROP_COLOR);
 383       CONVERT_PROP(POINT_DIFFUSE_SURFACE_SCALE, POINTDIFFUSE_PROP_SURFACE_SCALE);
 384       CONVERT_PROP(POINT_DIFFUSE_KERNEL_UNIT_LENGTH, POINTDIFFUSE_PROP_KERNEL_UNIT_LENGTH);
 385     }
 386     break;
 387   case FilterType::SPOT_DIFFUSE:
 388     switch (aIndex) {
 389       CONVERT_PROP(SPOT_DIFFUSE_DIFFUSE_CONSTANT, SPOTDIFFUSE_PROP_DIFFUSE_CONSTANT);
 390       CONVERT_PROP(SPOT_DIFFUSE_POINTS_AT, SPOTDIFFUSE_PROP_POINTS_AT);
 391       CONVERT_PROP(SPOT_DIFFUSE_FOCUS, SPOTDIFFUSE_PROP_FOCUS);
 392       CONVERT_PROP(SPOT_DIFFUSE_LIMITING_CONE_ANGLE, SPOTDIFFUSE_PROP_LIMITING_CONE_ANGLE);
 393       CONVERT_PROP(SPOT_DIFFUSE_POSITION, SPOTDIFFUSE_PROP_LIGHT_POSITION);
 394       CONVERT_PROP(SPOT_DIFFUSE_COLOR, SPOTDIFFUSE_PROP_COLOR);
 395       CONVERT_PROP(SPOT_DIFFUSE_SURFACE_SCALE, SPOTDIFFUSE_PROP_SURFACE_SCALE);
 396       CONVERT_PROP(SPOT_DIFFUSE_KERNEL_UNIT_LENGTH, SPOTDIFFUSE_PROP_KERNEL_UNIT_LENGTH);
 397     }
 398     break;
 399   case FilterType::DISTANT_DIFFUSE:
 400     switch (aIndex) {
 401       CONVERT_PROP(DISTANT_DIFFUSE_DIFFUSE_CONSTANT, DISTANTDIFFUSE_PROP_DIFFUSE_CONSTANT);
 402       CONVERT_PROP(DISTANT_DIFFUSE_AZIMUTH, DISTANTDIFFUSE_PROP_AZIMUTH);
 403       CONVERT_PROP(DISTANT_DIFFUSE_ELEVATION, DISTANTDIFFUSE_PROP_ELEVATION);
 404       CONVERT_PROP(DISTANT_DIFFUSE_COLOR, DISTANTDIFFUSE_PROP_COLOR);
 405       CONVERT_PROP(DISTANT_DIFFUSE_SURFACE_SCALE, DISTANTDIFFUSE_PROP_SURFACE_SCALE);
 406       CONVERT_PROP(DISTANT_DIFFUSE_KERNEL_UNIT_LENGTH, DISTANTDIFFUSE_PROP_KERNEL_UNIT_LENGTH);
 407     }
 408     break;
 409   case FilterType::POINT_SPECULAR:
 410     switch (aIndex) {
 411       CONVERT_PROP(POINT_SPECULAR_SPECULAR_CONSTANT, POINTSPECULAR_PROP_SPECULAR_CONSTANT);
 412       CONVERT_PROP(POINT_SPECULAR_SPECULAR_EXPONENT, POINTSPECULAR_PROP_SPECULAR_EXPONENT);
 413       CONVERT_PROP(POINT_SPECULAR_POSITION, POINTSPECULAR_PROP_LIGHT_POSITION);
 414       CONVERT_PROP(POINT_SPECULAR_COLOR, POINTSPECULAR_PROP_COLOR);
 415       CONVERT_PROP(POINT_SPECULAR_SURFACE_SCALE, POINTSPECULAR_PROP_SURFACE_SCALE);
 416       CONVERT_PROP(POINT_SPECULAR_KERNEL_UNIT_LENGTH, POINTSPECULAR_PROP_KERNEL_UNIT_LENGTH);
 417     }
 418     break;
 419   case FilterType::SPOT_SPECULAR:
 420     switch (aIndex) {
 421       CONVERT_PROP(SPOT_SPECULAR_SPECULAR_CONSTANT, SPOTSPECULAR_PROP_SPECULAR_CONSTANT);
 422       CONVERT_PROP(SPOT_SPECULAR_SPECULAR_EXPONENT, SPOTSPECULAR_PROP_SPECULAR_EXPONENT);
 423       CONVERT_PROP(SPOT_SPECULAR_POINTS_AT, SPOTSPECULAR_PROP_POINTS_AT);
 424       CONVERT_PROP(SPOT_SPECULAR_FOCUS, SPOTSPECULAR_PROP_FOCUS);
 425       CONVERT_PROP(SPOT_SPECULAR_LIMITING_CONE_ANGLE, SPOTSPECULAR_PROP_LIMITING_CONE_ANGLE);
 426       CONVERT_PROP(SPOT_SPECULAR_POSITION, SPOTSPECULAR_PROP_LIGHT_POSITION);
 427       CONVERT_PROP(SPOT_SPECULAR_COLOR, SPOTSPECULAR_PROP_COLOR);
 428       CONVERT_PROP(SPOT_SPECULAR_SURFACE_SCALE, SPOTSPECULAR_PROP_SURFACE_SCALE);
 429       CONVERT_PROP(SPOT_SPECULAR_KERNEL_UNIT_LENGTH, SPOTSPECULAR_PROP_KERNEL_UNIT_LENGTH);
 430     }
 431     break;
 432   case FilterType::DISTANT_SPECULAR:
 433     switch (aIndex) {
 434       CONVERT_PROP(DISTANT_SPECULAR_SPECULAR_CONSTANT, DISTANTSPECULAR_PROP_SPECULAR_CONSTANT);
 435       CONVERT_PROP(DISTANT_SPECULAR_SPECULAR_EXPONENT, DISTANTSPECULAR_PROP_SPECULAR_EXPONENT);
 436       CONVERT_PROP(DISTANT_SPECULAR_AZIMUTH, DISTANTSPECULAR_PROP_AZIMUTH);
 437       CONVERT_PROP(DISTANT_SPECULAR_ELEVATION, DISTANTSPECULAR_PROP_ELEVATION);
 438       CONVERT_PROP(DISTANT_SPECULAR_COLOR, DISTANTSPECULAR_PROP_COLOR);
 439       CONVERT_PROP(DISTANT_SPECULAR_SURFACE_SCALE, DISTANTSPECULAR_PROP_SURFACE_SCALE);
 440       CONVERT_PROP(DISTANT_SPECULAR_KERNEL_UNIT_LENGTH, DISTANTSPECULAR_PROP_KERNEL_UNIT_LENGTH);
 441     }
 442     break;
 443   case FilterType::CROP:
 444     switch (aIndex) {
 445       CONVERT_PROP(CROP_RECT, CROP_PROP_RECT);
 446     }
 447     break;
 448   default:
 449     break;
 450   }
 451
 452   return UINT32_MAX;
 453 }
 454
 455 bool
 456 GetD2D1PropsForIntSize(FilterType aType, uint32_t aIndex, UINT32 *aPropWidth, UINT32 *aPropHeight)
 457 {
 458   switch (aType) {
 459   case FilterType::MORPHOLOGY:
 460     if (aIndex == ATT_MORPHOLOGY_RADII) {
 461       *aPropWidth = D2D1_MORPHOLOGY_PROP_WIDTH;
 462       *aPropHeight = D2D1_MORPHOLOGY_PROP_HEIGHT;
 463       return true;
 464     }
 465     break;
 466   default:
 467     break;
 468   }
 469   return false;
 470 }
 471
 472 static inline REFCLSID GetCLDIDForFilterType(FilterType aType)
 473 {
 474   switch (aType) {
 475   case FilterType::COLOR_MATRIX:
 476     return CLSID_D2D1ColorMatrix;
 477   case FilterType::TRANSFORM:
 478     return CLSID_D2D12DAffineTransform;
 479   case FilterType::BLEND:
 480     return CLSID_D2D1Blend;
 481   case FilterType::MORPHOLOGY:
 482     return CLSID_D2D1Morphology;
 483   case FilterType::FLOOD:
 484     return CLSID_D2D1Flood;
 485   case FilterType::TILE:
 486     return CLSID_D2D1Tile;
 487   case FilterType::TABLE_TRANSFER:
 488     return CLSID_D2D1TableTransfer;
 489   case FilterType::LINEAR_TRANSFER:
 490     return CLSID_D2D1LinearTransfer;
 491   case FilterType::DISCRETE_TRANSFER:
 492     return CLSID_D2D1DiscreteTransfer;
 493   case FilterType::GAMMA_TRANSFER:
 494     return CLSID_D2D1GammaTransfer;
 495   case FilterType::DISPLACEMENT_MAP:
 496     return CLSID_D2D1DisplacementMap;
 497   case FilterType::TURBULENCE:
 498     return CLSID_D2D1Turbulence;
 499   case FilterType::ARITHMETIC_COMBINE:
 500     return CLSID_D2D1ArithmeticComposite;
 501   case FilterType::COMPOSITE:
 502     return CLSID_D2D1Composite;
 503   case FilterType::GAUSSIAN_BLUR:
 504     return CLSID_D2D1GaussianBlur;
 505   case FilterType::DIRECTIONAL_BLUR:
 506     return CLSID_D2D1DirectionalBlur;
 507   case FilterType::POINT_DIFFUSE:
 508     return CLSID_D2D1PointDiffuse;
 509   case FilterType::POINT_SPECULAR:
 510     return CLSID_D2D1PointSpecular;
 511   case FilterType::SPOT_DIFFUSE:
 512     return CLSID_D2D1SpotDiffuse;
 513   case FilterType::SPOT_SPECULAR:
 514     return CLSID_D2D1SpotSpecular;
 515   case FilterType::DISTANT_DIFFUSE:
 516     return CLSID_D2D1DistantDiffuse;
 517   case FilterType::DISTANT_SPECULAR:
 518     return CLSID_D2D1DistantSpecular;
 519   case FilterType::CROP:
 520     return CLSID_D2D1Crop;
 521   case FilterType::PREMULTIPLY:
 522     return CLSID_D2D1Premultiply;
 523   case FilterType::UNPREMULTIPLY:
 524     return CLSID_D2D1UnPremultiply;
 525   default:
 526     break;
 527   }
 528   return GUID_NULL;
 529 }
 530
 531 static bool
 532 IsTransferFilterType(FilterType aType)
 533 {
 534   switch (aType) {
 535     case FilterType::LINEAR_TRANSFER:
 536     case FilterType::GAMMA_TRANSFER:
 537     case FilterType::TABLE_TRANSFER:
 538     case FilterType::DISCRETE_TRANSFER:
 539       return true;
 540     default:
 541       return false;
 542   }
 543 }
 544
 545 static bool
 546 HasUnboundedOutputRegion(FilterType aType)
 547 {
 548   if (IsTransferFilterType(aType)) {
 549     return true;
 550   }
 551
 552   switch (aType) {
 553     case FilterType::COLOR_MATRIX:
 554     case FilterType::POINT_DIFFUSE:
 555     case FilterType::SPOT_DIFFUSE:
 556     case FilterType::DISTANT_DIFFUSE:
 557     case FilterType::POINT_SPECULAR:
 558     case FilterType::SPOT_SPECULAR:
 559     case FilterType::DISTANT_SPECULAR:
 560       return true;
 561     default:
 562       return false;
 563   }
 564 }
 565
 566 /* static */
 567 already_AddRefed<FilterNode>
 568 FilterNodeD2D1::Create(ID2D1DeviceContext *aDC, FilterType aType)
 569 {
 570   if (aType == FilterType::CONVOLVE_MATRIX) {
 571     return MakeAndAddRef<FilterNodeConvolveD2D1>(aDC);
 572   }
 573
 574   RefPtr<ID2D1Effect> effect;
 575   HRESULT hr;
 576
 577   hr = aDC->CreateEffect(GetCLDIDForFilterType(aType), getter_AddRefs(effect));
 578
 579   if (FAILED(hr) || !effect) {
 580     gfxCriticalErrorOnce() << "Failed to create effect for FilterType: " << hexa(hr);
 581     return nullptr;
 582   }
 583
 584   if (aType == FilterType::ARITHMETIC_COMBINE) {
 585     effect->SetValue(D2D1_ARITHMETICCOMPOSITE_PROP_CLAMP_OUTPUT, TRUE);
 586   }
 587
 588   RefPtr<FilterNodeD2D1> filter = new FilterNodeD2D1(effect, aType);
 589
 590   if (HasUnboundedOutputRegion(aType)) {
 591     // These filters can produce non-transparent output from transparent
 592     // input pixels, and we want them to have an unbounded output region.
 593     filter = new FilterNodeExtendInputAdapterD2D1(aDC, filter, aType);
 594   }
 595
 596   if (IsTransferFilterType(aType)) {
 597     // Component transfer filters should appear to apply on unpremultiplied
 598     // colors, but the D2D1 effects apply on premultiplied colors.
 599     filter = new FilterNodePremultiplyAdapterD2D1(aDC, filter, aType);
 600   }
 601
 602   return filter.forget();
 603 }
 604
 605 void
 606 FilterNodeD2D1::InitUnmappedProperties()
 607 {
 608   switch (mType) {
 609     case FilterType::TRANSFORM:
 610       mEffect->SetValue(D2D1_2DAFFINETRANSFORM_PROP_BORDER_MODE, D2D1_BORDER_MODE_HARD);
 611       break;
 612     default:
 613       break;
 614   }
 615 }
 616
 617 void
 618 FilterNodeD2D1::SetInput(uint32_t aIndex, SourceSurface *aSurface)
 619 {
 620   UINT32 input = GetD2D1InputForInput(mType, aIndex);
 621   ID2D1Effect* effect = InputEffect();
 622   MOZ_ASSERT(input < effect->GetInputCount());
 623
 624   if (mType == FilterType::COMPOSITE) {
 625     UINT32 inputCount = effect->GetInputCount();
 626
 627     if (aIndex == inputCount - 1 && aSurface == nullptr) {
 628       effect->SetInputCount(inputCount - 1);
 629     } else if (aIndex >= inputCount && aSurface) {
 630       effect->SetInputCount(aIndex + 1);
 631     }
 632   }
 633
 634   MOZ_ASSERT(input < effect->GetInputCount());
 635
 636   mInputSurfaces.resize(effect->GetInputCount());
 637   mInputFilters.resize(effect->GetInputCount());
 638
 639   // In order to convert aSurface into an ID2D1Image, we need to know what
 640   // DrawTarget we paint into. However, the same FilterNode object can be
 641   // used on different DrawTargets, so we need to hold on to the SourceSurface
 642   // objects and delay the conversion until we're actually painted and know
 643   // our target DrawTarget.
 644   // The conversion happens in WillDraw().
 645
 646   mInputSurfaces[input] = aSurface;
 647   mInputFilters[input] = nullptr;
 648
 649   // Clear the existing image from the effect.
 650   effect->SetInput(input, nullptr);
 651 }
 652
 653 void
 654 FilterNodeD2D1::SetInput(uint32_t aIndex, FilterNode *aFilter)
 655 {
 656   UINT32 input = GetD2D1InputForInput(mType, aIndex);
 657   ID2D1Effect* effect = InputEffect();
 658
 659   if (mType == FilterType::COMPOSITE) {
 660     UINT32 inputCount = effect->GetInputCount();
 661
 662     if (aIndex == inputCount - 1 && aFilter == nullptr) {
 663       effect->SetInputCount(inputCount - 1);
 664     } else if (aIndex >= inputCount && aFilter) {
 665       effect->SetInputCount(aIndex + 1);
 666     }
 667   }
 668
 669   MOZ_ASSERT(input < effect->GetInputCount());
 670
 671   if (aFilter && aFilter->GetBackendType() != FILTER_BACKEND_DIRECT2D1_1) {
 672     gfxWarning() << "Unknown input FilterNode set on effect.";
 673     MOZ_ASSERT(0);
 674     return;
 675   }
 676
 677   FilterNodeD2D1* filter = static_cast<FilterNodeD2D1*>(aFilter);
 678
 679   mInputSurfaces.resize(effect->GetInputCount());
 680   mInputFilters.resize(effect->GetInputCount());
 681
 682   // We hold on to the FilterNode object so that we can call WillDraw() on it.
 683   mInputSurfaces[input] = nullptr;
 684   mInputFilters[input] = filter;
 685
 686   if (filter) {
 687     effect->SetInputEffect(input, filter->OutputEffect());
 688   }
 689 }
 690
 691 void
 692 FilterNodeD2D1::WillDraw(DrawTarget *aDT)
 693 {
 694   // Convert input SourceSurfaces into ID2D1Images and set them on the effect.
 695   for (size_t inputIndex = 0; inputIndex < mInputSurfaces.size(); inputIndex++) {
 696     if (mInputSurfaces[inputIndex]) {
 697       ID2D1Effect* effect = InputEffect();
 698       RefPtr<ID2D1Image> image = GetImageForSourceSurface(aDT, mInputSurfaces[inputIndex]);
 699       effect->SetInput(inputIndex, image);
 700     }
 701   }
 702
 703   // Call WillDraw() on our input filters.
 704   for (std::vector<RefPtr<FilterNodeD2D1>>::iterator it = mInputFilters.begin();
 705        it != mInputFilters.end(); it++) {
 706     if (*it) {
 707       (*it)->WillDraw(aDT);
 708     }
 709   }
 710 }
 711
 712 void
 713 FilterNodeD2D1::SetAttribute(uint32_t aIndex, uint32_t aValue)
 714 {
 715   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 716   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 717
 718   if (mType == FilterType::TURBULENCE && aIndex == ATT_TURBULENCE_BASE_FREQUENCY) {
 719     mEffect->SetValue(input, D2D1::Vector2F(FLOAT(aValue), FLOAT(aValue)));
 720     return;
 721   } else if (mType == FilterType::DIRECTIONAL_BLUR && aIndex == ATT_DIRECTIONAL_BLUR_DIRECTION) {
 722     mEffect->SetValue(input, aValue == BLUR_DIRECTION_X ? 0 : 90.0f);
 723     return;
 724   }
 725
 726   mEffect->SetValue(input, ConvertValue(mType, aIndex, aValue));
 727 }
 728
 729 void
 730 FilterNodeD2D1::SetAttribute(uint32_t aIndex, Float aValue)
 731 {
 732   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 733   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 734
 735   mEffect->SetValue(input, aValue);
 736 }
 737
 738 void
 739 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const Point &aValue)
 740 {
 741   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 742   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 743
 744   mEffect->SetValue(input, D2DPoint(aValue));
 745 }
 746
 747 void
 748 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const Matrix5x4 &aValue)
 749 {
 750   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 751   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 752
 753   mEffect->SetValue(input, D2DMatrix5x4(aValue));
 754 }
 755
 756 void
 757 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const Point3D &aValue)
 758 {
 759   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 760   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 761
 762   mEffect->SetValue(input, D2DVector3D(aValue));
 763 }
 764
 765 void
 766 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const Size &aValue)
 767 {
 768   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 769   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 770
 771   mEffect->SetValue(input, D2D1::Vector2F(aValue.width, aValue.height));
 772 }
 773
 774 void
 775 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const IntSize &aValue)
 776 {
 777   UINT32 widthProp, heightProp;
 778
 779   if (!GetD2D1PropsForIntSize(mType, aIndex, &widthProp, &heightProp)) {
 780     return;
 781   }
 782
 783   IntSize value = aValue;
 784   ConvertValue(mType, aIndex, value);
 785
 786   mEffect->SetValue(widthProp, (UINT)value.width);
 787   mEffect->SetValue(heightProp, (UINT)value.height);
 788 }
 789
 790 void
 791 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const Color &aValue)
 792 {
 793   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 794   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 795
 796   switch (mType) {
 797   case FilterType::POINT_DIFFUSE:
 798   case FilterType::SPOT_DIFFUSE:
 799   case FilterType::DISTANT_DIFFUSE:
 800   case FilterType::POINT_SPECULAR:
 801   case FilterType::SPOT_SPECULAR:
 802   case FilterType::DISTANT_SPECULAR:
 803     mEffect->SetValue(input, D2D1::Vector3F(aValue.r, aValue.g, aValue.b));
 804         break;
 805   default:
 806     mEffect->SetValue(input, D2D1::Vector4F(aValue.r * aValue.a, aValue.g * aValue.a, aValue.b * aValue.a, aValue.a));
 807   }
 808 }
 809
 810 void
 811 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const Rect &aValue)
 812 {
 813   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 814   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 815
 816   mEffect->SetValue(input, D2DRect(aValue));
 817 }
 818
 819 void
 820 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const IntRect &aValue)
 821 {
 822   if (mType == FilterType::TURBULENCE) {
 823     MOZ_ASSERT(aIndex == ATT_TURBULENCE_RECT);
 824
 825     mEffect->SetValue(D2D1_TURBULENCE_PROP_OFFSET, D2D1::Vector2F(Float(aValue.X()), Float(aValue.Y())));
 826     mEffect->SetValue(D2D1_TURBULENCE_PROP_SIZE, D2D1::Vector2F(Float(aValue.Width()), Float(aValue.Height())));
 827     return;
 828   }
 829
 830   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 831   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 832
 833   mEffect->SetValue(input, D2D1::RectF(Float(aValue.X()), Float(aValue.Y()),
 834                                        Float(aValue.XMost()), Float(aValue.YMost())));
 835 }
 836
 837 void
 838 FilterNodeD2D1::SetAttribute(uint32_t aIndex, bool aValue)
 839 {
 840   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 841   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 842
 843   mEffect->SetValue(input, (BOOL)aValue);
 844 }
 845
 846 void
 847 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const Float *aValues, uint32_t aSize)
 848 {
 849   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 850   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 851
 852   mEffect->SetValue(input, (BYTE*)aValues, sizeof(Float) * aSize);
 853 }
 854
 855 void
 856 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const IntPoint &aValue)
 857 {
 858   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 859   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 860
 861   mEffect->SetValue(input, D2DPoint(aValue));
 862 }
 863
 864 void
 865 FilterNodeD2D1::SetAttribute(uint32_t aIndex, const Matrix &aMatrix)
 866 {
 867   UINT32 input = GetD2D1PropForAttribute(mType, aIndex);
 868   MOZ_ASSERT(input < mEffect->GetPropertyCount());
 869
 870   mEffect->SetValue(input, D2DMatrix(aMatrix));
 871 }
 872
 873 FilterNodeConvolveD2D1::FilterNodeConvolveD2D1(ID2D1DeviceContext *aDC)
 874   : FilterNodeD2D1(nullptr, FilterType::CONVOLVE_MATRIX)
 875   , mEdgeMode(EDGE_MODE_DUPLICATE)
 876 {
 877   // Correctly handling the interaction of edge mode and source rect is a bit
 878   // tricky with D2D1 effects. We want the edge mode to only apply outside of
 879   // the source rect (as specified by the ATT_CONVOLVE_MATRIX_SOURCE_RECT
 880   // attribute). So if our input surface or filter is smaller than the source
 881   // rect, we need to add transparency around it until we reach the edges of
 882   // the source rect, and only then do any repeating or edge duplicating.
 883   // Unfortunately, the border effect does not have a source rect attribute -
 884   // it only looks at the output rect of its input filter or surface. So we use
 885   // our custom ExtendInput effect to adjust the output rect of our input.
 886   // All of this is only necessary when our edge mode is not EDGE_MODE_NONE, so
 887   // we update the filter chain dynamically in UpdateChain().
 888
 889   HRESULT hr;
 890
 891   hr = aDC->CreateEffect(CLSID_D2D1ConvolveMatrix, getter_AddRefs(mEffect));
 892
 893   if (FAILED(hr) || !mEffect) {
 894     gfxWarning() << "Failed to create ConvolveMatrix filter!";
 895     return;
 896   }
 897
 898   mEffect->SetValue(D2D1_CONVOLVEMATRIX_PROP_BORDER_MODE, D2D1_BORDER_MODE_SOFT);
 899
 900   hr = aDC->CreateEffect(CLSID_ExtendInputEffect, getter_AddRefs(mExtendInputEffect));
 901
 902   if (FAILED(hr) || !mExtendInputEffect) {
 903     gfxWarning() << "Failed to create ConvolveMatrix filter!";
 904     return;
 905   }
 906
 907   hr = aDC->CreateEffect(CLSID_D2D1Border, getter_AddRefs(mBorderEffect));
 908
 909   if (FAILED(hr) || !mBorderEffect) {
 910     gfxWarning() << "Failed to create ConvolveMatrix filter!";
 911     return;
 912   }
 913
 914   mBorderEffect->SetInputEffect(0, mExtendInputEffect.get());
 915
 916   UpdateChain();
 917   UpdateSourceRect();
 918 }
 919
 920 void
 921 FilterNodeConvolveD2D1::SetInput(uint32_t aIndex, FilterNode *aFilter)
 922 {
 923   FilterNodeD2D1::SetInput(aIndex, aFilter);
 924
 925   UpdateChain();
 926 }
 927
 928 void
 929 FilterNodeConvolveD2D1::SetAttribute(uint32_t aIndex, uint32_t aValue)
 930 {
 931   if (aIndex != ATT_CONVOLVE_MATRIX_EDGE_MODE) {
 932     return FilterNodeD2D1::SetAttribute(aIndex, aValue);
 933   }
 934
 935   mEdgeMode = (ConvolveMatrixEdgeMode)aValue;
 936
 937   UpdateChain();
 938 }
 939
 940 ID2D1Effect*
 941 FilterNodeConvolveD2D1::InputEffect()
 942 {
 943   return mEdgeMode == EDGE_MODE_NONE ? mEffect.get() : mExtendInputEffect.get();
 944 }
 945
 946 void
 947 FilterNodeConvolveD2D1::UpdateChain()
 948 {
 949   // The shape of the filter graph:
 950   //
 951   // EDGE_MODE_NONE:
 952   // input --> convolvematrix
 953   //
 954   // EDGE_MODE_DUPLICATE or EDGE_MODE_WRAP:
 955   // input --> extendinput --> border --> convolvematrix
 956   //
 957   // mEffect is convolvematrix.
 958
 959   if (mEdgeMode != EDGE_MODE_NONE) {
 960     mEffect->SetInputEffect(0, mBorderEffect.get());
 961   }
 962
 963   RefPtr<ID2D1Effect> inputEffect;
 964   if (mInputFilters.size() > 0 && mInputFilters[0]) {
 965     inputEffect = mInputFilters[0]->OutputEffect();
 966   }
 967   InputEffect()->SetInputEffect(0, inputEffect);
 968
 969   if (mEdgeMode == EDGE_MODE_DUPLICATE) {
 970     mBorderEffect->SetValue(D2D1_BORDER_PROP_EDGE_MODE_X, D2D1_BORDER_EDGE_MODE_CLAMP);
 971     mBorderEffect->SetValue(D2D1_BORDER_PROP_EDGE_MODE_Y, D2D1_BORDER_EDGE_MODE_CLAMP);
 972   } else if (mEdgeMode == EDGE_MODE_WRAP) {
 973     mBorderEffect->SetValue(D2D1_BORDER_PROP_EDGE_MODE_X, D2D1_BORDER_EDGE_MODE_WRAP);
 974     mBorderEffect->SetValue(D2D1_BORDER_PROP_EDGE_MODE_Y, D2D1_BORDER_EDGE_MODE_WRAP);
 975   }
 976 }
 977
 978 void
 979 FilterNodeConvolveD2D1::SetAttribute(uint32_t aIndex, const IntSize &aValue)
 980 {
 981   if (aIndex != ATT_CONVOLVE_MATRIX_KERNEL_SIZE) {
 982     MOZ_ASSERT(false);
 983     return;
 984   }
 985
 986   mKernelSize = aValue;
 987
 988   mEffect->SetValue(D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_X, aValue.width);
 989   mEffect->SetValue(D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_Y, aValue.height);
 990
 991   UpdateOffset();
 992 }
 993
 994 void
 995 FilterNodeConvolveD2D1::SetAttribute(uint32_t aIndex, const IntPoint &aValue)
 996 {
 997   if (aIndex != ATT_CONVOLVE_MATRIX_TARGET) {
 998     MOZ_ASSERT(false);
 999     return;
1000   }
1001
1002   mTarget = aValue;
1003
1004   UpdateOffset();
1005 }
1006
1007 void
1008 FilterNodeConvolveD2D1::SetAttribute(uint32_t aIndex, const IntRect &aValue)
1009 {
1010   if (aIndex != ATT_CONVOLVE_MATRIX_SOURCE_RECT) {
1011     MOZ_ASSERT(false);
1012     return;
1013   }
1014
1015   mSourceRect = aValue;
1016
1017   UpdateSourceRect();
1018 }
1019
1020 void
1021 FilterNodeConvolveD2D1::UpdateOffset()
1022 {
1023   D2D1_VECTOR_2F vector =
1024     D2D1::Vector2F((Float(mKernelSize.width) - 1.0f) / 2.0f - Float(mTarget.x),
1025                    (Float(mKernelSize.height) - 1.0f) / 2.0f - Float(mTarget.y));
1026
1027   mEffect->SetValue(D2D1_CONVOLVEMATRIX_PROP_KERNEL_OFFSET, vector);
1028 }
1029
1030 void
1031 FilterNodeConvolveD2D1::UpdateSourceRect()
1032 {
1033   mExtendInputEffect->SetValue(EXTENDINPUT_PROP_OUTPUT_RECT,
1034                    D2D1::Vector4F(Float(mSourceRect.X()), Float(mSourceRect.Y()),
1035                    Float(mSourceRect.XMost()), Float(mSourceRect.YMost())));
1036 }
1037
1038 FilterNodeExtendInputAdapterD2D1::FilterNodeExtendInputAdapterD2D1(ID2D1DeviceContext *aDC,
1039                                                                    FilterNodeD2D1 *aFilterNode, FilterType aType)
1040  : FilterNodeD2D1(aFilterNode->MainEffect(), aType)
1041  , mWrappedFilterNode(aFilterNode)
1042 {
1043   // We have an mEffect that looks at the bounds of the input effect, and we
1044   // want mEffect to regard its input as unbounded. So we take the input,
1045   // pipe it through an ExtendInput effect (which has an infinite output rect
1046   // by default), and feed the resulting unbounded composition into mEffect.
1047
1048   HRESULT hr;
1049
1050   hr = aDC->CreateEffect(CLSID_ExtendInputEffect, getter_AddRefs(mExtendInputEffect));
1051
1052   if (FAILED(hr) || !mExtendInputEffect) {
1053     gfxWarning() << "Failed to create extend input effect for filter: " << hexa(hr);
1054     return;
1055   }
1056
1057   aFilterNode->InputEffect()->SetInputEffect(0, mExtendInputEffect.get());
1058 }
1059
1060 FilterNodePremultiplyAdapterD2D1::FilterNodePremultiplyAdapterD2D1(ID2D1DeviceContext *aDC,
1061                                                                    FilterNodeD2D1 *aFilterNode, FilterType aType)
1062  : FilterNodeD2D1(aFilterNode->MainEffect(), aType)
1063 {
1064   // D2D1 component transfer effects do strange things when it comes to
1065   // premultiplication.
1066   // For our purposes we only need the transfer filters to apply straight to
1067   // unpremultiplied source channels and output unpremultiplied results.
1068   // However, the D2D1 effects are designed differently: They can apply to both
1069   // premultiplied and unpremultiplied inputs, and they always premultiply
1070   // their result - at least in those color channels that have not been
1071   // disabled.
1072   // In order to determine whether the input needs to be unpremultiplied as
1073   // part of the transfer, the effect consults the alpha mode metadata of the
1074   // input surface or the input effect. We don't have such a concept in Moz2D,
1075   // and giving Moz2D users different results based on something that cannot be
1076   // influenced through Moz2D APIs seems like a bad idea.
1077   // We solve this by applying a premultiply effect to the input before feeding
1078   // it into the transfer effect. The premultiply effect always premultiplies
1079   // regardless of any alpha mode metadata on inputs, and it always marks its
1080   // output as premultiplied so that the transfer effect will unpremultiply
1081   // consistently. Feeding always-premultiplied input into the transfer effect
1082   // also avoids another problem that would appear when individual color
1083   // channels disable the transfer: In that case, the disabled channels would
1084   // pass through unchanged in their unpremultiplied form and the other
1085   // channels would be premultiplied, giving a mixed result.
1086   // But since we now ensure that the input is premultiplied, disabled channels
1087   // will pass premultiplied values through to the result, which is consistent
1088   // with the enabled channels.
1089   // We also add an unpremultiply effect that postprocesses the result of the
1090   // transfer effect because getting unpremultiplied results from the transfer
1091   // filters is part of the FilterNode API.
1092   HRESULT hr;
1093
1094   hr = aDC->CreateEffect(CLSID_D2D1Premultiply, getter_AddRefs(mPrePremultiplyEffect));
1095
1096   if (FAILED(hr) || !mPrePremultiplyEffect) {
1097     gfxWarning() << "Failed to create ComponentTransfer filter!";
1098     return;
1099   }
1100
1101   hr = aDC->CreateEffect(CLSID_D2D1UnPremultiply, getter_AddRefs(mPostUnpremultiplyEffect));
1102
1103   if (FAILED(hr) || !mPostUnpremultiplyEffect) {
1104     gfxWarning() << "Failed to create ComponentTransfer filter!";
1105     return;
1106   }
1107
1108   aFilterNode->InputEffect()->SetInputEffect(0, mPrePremultiplyEffect.get());
1109   mPostUnpremultiplyEffect->SetInputEffect(0, aFilterNode->OutputEffect());
1110 }
1111
1112 }
1113 }