The Tor Browser / file comparison
comparison: layout/svg/nsSVGFilterInstance.cpp
layout/svg/nsSVGFilterInstance.cpp
- branch
- TOR_BUG_9701
- changeset 8
- 97036ab72558
equal
deleted
inserted
replaced
| -1:000000000000 | 0:01f3717f8be5 |
|---|---|
| 1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
| 2 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 3 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 5 | |
| 6 // Main header first: | |
| 7 #include "nsSVGFilterInstance.h" | |
| 8 | |
| 9 // Keep others in (case-insensitive) order: | |
| 10 #include "gfxPlatform.h" | |
| 11 #include "gfxUtils.h" | |
| 12 #include "nsISVGChildFrame.h" | |
| 13 #include "nsRenderingContext.h" | |
| 14 #include "mozilla/dom/SVGFilterElement.h" | |
| 15 #include "nsReferencedElement.h" | |
| 16 #include "nsSVGFilterFrame.h" | |
| 17 #include "nsSVGFilterPaintCallback.h" | |
| 18 #include "nsSVGUtils.h" | |
| 19 #include "SVGContentUtils.h" | |
| 20 #include "FilterSupport.h" | |
| 21 #include "gfx2DGlue.h" | |
| 22 | |
| 23 using namespace mozilla; | |
| 24 using namespace mozilla::dom; | |
| 25 using namespace mozilla::gfx; | |
| 26 | |
| 27 nsSVGFilterInstance::nsSVGFilterInstance(const nsStyleFilter& aFilter, | |
| 28 nsIFrame *aTargetFrame, | |
| 29 const gfxRect& aTargetBBox, | |
| 30 const gfxSize& aUserSpaceToFilterSpaceScale, | |
| 31 const gfxSize& aFilterSpaceToUserSpaceScale) : | |
| 32 mFilter(aFilter), | |
| 33 mTargetFrame(aTargetFrame), | |
| 34 mTargetBBox(aTargetBBox), | |
| 35 mUserSpaceToFilterSpaceScale(aUserSpaceToFilterSpaceScale), | |
| 36 mFilterSpaceToUserSpaceScale(aFilterSpaceToUserSpaceScale), | |
| 37 mInitialized(false) { | |
| 38 | |
| 39 // Get the filter frame. | |
| 40 mFilterFrame = GetFilterFrame(); | |
| 41 if (!mFilterFrame) { | |
| 42 return; | |
| 43 } | |
| 44 | |
| 45 // Get the filter element. | |
| 46 mFilterElement = mFilterFrame->GetFilterContent(); | |
| 47 if (!mFilterElement) { | |
| 48 NS_NOTREACHED("filter frame should have a related element"); | |
| 49 return; | |
| 50 } | |
| 51 | |
| 52 mPrimitiveUnits = | |
| 53 mFilterFrame->GetEnumValue(SVGFilterElement::PRIMITIVEUNITS); | |
| 54 | |
| 55 nsresult rv = ComputeBounds(); | |
| 56 if (NS_FAILED(rv)) { | |
| 57 return; | |
| 58 } | |
| 59 | |
| 60 mInitialized = true; | |
| 61 } | |
| 62 | |
| 63 nsresult | |
| 64 nsSVGFilterInstance::ComputeBounds() | |
| 65 { | |
| 66 // XXX if filterUnits is set (or has defaulted) to objectBoundingBox, we | |
| 67 // should send a warning to the error console if the author has used lengths | |
| 68 // with units. This is a common mistake and can result in the filter region | |
| 69 // being *massive* below (because we ignore the units and interpret the number | |
| 70 // as a factor of the bbox width/height). We should also send a warning if the | |
| 71 // user uses a number without units (a future SVG spec should really | |
| 72 // deprecate that, since it's too confusing for a bare number to be sometimes | |
| 73 // interpreted as a fraction of the bounding box and sometimes as user-space | |
| 74 // units). So really only percentage values should be used in this case. | |
| 75 | |
| 76 // Set the user space bounds (i.e. the filter region in user space). | |
| 77 nsSVGLength2 XYWH[4]; | |
| 78 NS_ABORT_IF_FALSE(sizeof(mFilterElement->mLengthAttributes) == sizeof(XYWH), | |
| 79 "XYWH size incorrect"); | |
| 80 memcpy(XYWH, mFilterElement->mLengthAttributes, | |
| 81 sizeof(mFilterElement->mLengthAttributes)); | |
| 82 XYWH[0] = *mFilterFrame->GetLengthValue(SVGFilterElement::ATTR_X); | |
| 83 XYWH[1] = *mFilterFrame->GetLengthValue(SVGFilterElement::ATTR_Y); | |
| 84 XYWH[2] = *mFilterFrame->GetLengthValue(SVGFilterElement::ATTR_WIDTH); | |
| 85 XYWH[3] = *mFilterFrame->GetLengthValue(SVGFilterElement::ATTR_HEIGHT); | |
| 86 uint16_t filterUnits = | |
| 87 mFilterFrame->GetEnumValue(SVGFilterElement::FILTERUNITS); | |
| 88 mUserSpaceBounds = nsSVGUtils::GetRelativeRect(filterUnits, | |
| 89 XYWH, mTargetBBox, mTargetFrame); | |
| 90 | |
| 91 // Temporarily transform the user space bounds to filter space, so we | |
| 92 // can align them with the pixel boundries of the offscreen surface. | |
| 93 // The offscreen surface has the same scale as filter space. | |
| 94 mUserSpaceBounds = UserSpaceToFilterSpace(mUserSpaceBounds); | |
| 95 mUserSpaceBounds.RoundOut(); | |
| 96 if (mUserSpaceBounds.Width() <= 0 || mUserSpaceBounds.Height() <= 0) { | |
| 97 // 0 disables rendering, < 0 is error. dispatch error console warning | |
| 98 // or error as appropriate. | |
| 99 return NS_ERROR_FAILURE; | |
| 100 } | |
| 101 | |
| 102 // Set the filter space bounds. | |
| 103 if (!gfxUtils::GfxRectToIntRect(mUserSpaceBounds, &mFilterSpaceBounds)) { | |
| 104 // The filter region is way too big if there is float -> int overflow. | |
| 105 return NS_ERROR_FAILURE; | |
| 106 } | |
| 107 | |
| 108 // Undo the temporary transformation of the user space bounds. | |
| 109 mUserSpaceBounds = FilterSpaceToUserSpace(mUserSpaceBounds); | |
| 110 | |
| 111 return NS_OK; | |
| 112 } | |
| 113 | |
| 114 nsSVGFilterFrame* | |
| 115 nsSVGFilterInstance::GetFilterFrame() | |
| 116 { | |
| 117 if (mFilter.GetType() != NS_STYLE_FILTER_URL) { | |
| 118 // The filter is not an SVG reference filter. | |
| 119 return nullptr; | |
| 120 } | |
| 121 | |
| 122 nsIURI* url = mFilter.GetURL(); | |
| 123 if (!url) { | |
| 124 NS_NOTREACHED("an nsStyleFilter of type URL should have a non-null URL"); | |
| 125 return nullptr; | |
| 126 } | |
| 127 | |
| 128 // Get the target element to use as a point of reference for looking up the | |
| 129 // filter element. | |
| 130 nsIContent* targetElement = mTargetFrame->GetContent(); | |
| 131 if (!targetElement) { | |
| 132 // There is no element associated with the target frame. | |
| 133 return nullptr; | |
| 134 } | |
| 135 | |
| 136 // Look up the filter element by URL. | |
| 137 nsReferencedElement filterElement; | |
| 138 bool watch = false; | |
| 139 filterElement.Reset(targetElement, url, watch); | |
| 140 Element* element = filterElement.get(); | |
| 141 if (!element) { | |
| 142 // The URL points to no element. | |
| 143 return nullptr; | |
| 144 } | |
| 145 | |
| 146 // Get the frame of the filter element. | |
| 147 nsIFrame* frame = element->GetPrimaryFrame(); | |
| 148 if (frame->GetType() != nsGkAtoms::svgFilterFrame) { | |
| 149 // The URL points to an element that's not an SVG filter element. | |
| 150 return nullptr; | |
| 151 } | |
| 152 | |
| 153 return static_cast<nsSVGFilterFrame*>(frame); | |
| 154 } | |
| 155 | |
| 156 float | |
| 157 nsSVGFilterInstance::GetPrimitiveNumber(uint8_t aCtxType, float aValue) const | |
| 158 { | |
| 159 nsSVGLength2 val; | |
| 160 val.Init(aCtxType, 0xff, aValue, | |
| 161 nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER); | |
| 162 | |
| 163 float value; | |
| 164 if (mPrimitiveUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) { | |
| 165 value = nsSVGUtils::ObjectSpace(mTargetBBox, &val); | |
| 166 } else { | |
| 167 value = nsSVGUtils::UserSpace(mTargetFrame, &val); | |
| 168 } | |
| 169 | |
| 170 switch (aCtxType) { | |
| 171 case SVGContentUtils::X: | |
| 172 return value * mUserSpaceToFilterSpaceScale.width; | |
| 173 case SVGContentUtils::Y: | |
| 174 return value * mUserSpaceToFilterSpaceScale.height; | |
| 175 case SVGContentUtils::XY: | |
| 176 default: | |
| 177 return value * SVGContentUtils::ComputeNormalizedHypotenuse( | |
| 178 mUserSpaceToFilterSpaceScale.width, | |
| 179 mUserSpaceToFilterSpaceScale.height); | |
| 180 } | |
| 181 } | |
| 182 | |
| 183 Point3D | |
| 184 nsSVGFilterInstance::ConvertLocation(const Point3D& aPoint) const | |
| 185 { | |
| 186 nsSVGLength2 val[4]; | |
| 187 val[0].Init(SVGContentUtils::X, 0xff, aPoint.x, | |
| 188 nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER); | |
| 189 val[1].Init(SVGContentUtils::Y, 0xff, aPoint.y, | |
| 190 nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER); | |
| 191 // Dummy width/height values | |
| 192 val[2].Init(SVGContentUtils::X, 0xff, 0, | |
| 193 nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER); | |
| 194 val[3].Init(SVGContentUtils::Y, 0xff, 0, | |
| 195 nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER); | |
| 196 | |
| 197 gfxRect feArea = nsSVGUtils::GetRelativeRect(mPrimitiveUnits, | |
| 198 val, mTargetBBox, mTargetFrame); | |
| 199 gfxRect r = UserSpaceToFilterSpace(feArea); | |
| 200 return Point3D(r.x, r.y, GetPrimitiveNumber(SVGContentUtils::XY, aPoint.z)); | |
| 201 } | |
| 202 | |
| 203 gfxRect | |
| 204 nsSVGFilterInstance::UserSpaceToFilterSpace(const gfxRect& aUserSpaceRect) const | |
| 205 { | |
| 206 gfxRect filterSpaceRect = aUserSpaceRect; | |
| 207 filterSpaceRect.Scale(mUserSpaceToFilterSpaceScale.width, | |
| 208 mUserSpaceToFilterSpaceScale.height); | |
| 209 return filterSpaceRect; | |
| 210 } | |
| 211 | |
| 212 gfxRect | |
| 213 nsSVGFilterInstance::FilterSpaceToUserSpace(const gfxRect& aFilterSpaceRect) const | |
| 214 { | |
| 215 gfxRect userSpaceRect = aFilterSpaceRect; | |
| 216 userSpaceRect.Scale(mFilterSpaceToUserSpaceScale.width, | |
| 217 mFilterSpaceToUserSpaceScale.height); | |
| 218 return userSpaceRect; | |
| 219 } | |
| 220 | |
| 221 IntRect | |
| 222 nsSVGFilterInstance::ComputeFilterPrimitiveSubregion(nsSVGFE* aFilterElement, | |
| 223 const nsTArray<FilterPrimitiveDescription>& aPrimitiveDescrs, | |
| 224 const nsTArray<int32_t>& aInputIndices) | |
| 225 { | |
| 226 nsSVGFE* fE = aFilterElement; | |
| 227 | |
| 228 IntRect defaultFilterSubregion(0,0,0,0); | |
| 229 if (fE->SubregionIsUnionOfRegions()) { | |
| 230 for (uint32_t i = 0; i < aInputIndices.Length(); ++i) { | |
| 231 int32_t inputIndex = aInputIndices[i]; | |
| 232 IntRect inputSubregion = inputIndex >= 0 ? | |
| 233 aPrimitiveDescrs[inputIndex].PrimitiveSubregion() : | |
| 234 ToIntRect(mFilterSpaceBounds); | |
| 235 | |
| 236 defaultFilterSubregion = defaultFilterSubregion.Union(inputSubregion); | |
| 237 } | |
| 238 } else { | |
| 239 defaultFilterSubregion = ToIntRect(mFilterSpaceBounds); | |
| 240 } | |
| 241 | |
| 242 gfxRect feArea = nsSVGUtils::GetRelativeRect(mPrimitiveUnits, | |
| 243 &fE->mLengthAttributes[nsSVGFE::ATTR_X], mTargetBBox, mTargetFrame); | |
| 244 Rect region = ToRect(UserSpaceToFilterSpace(feArea)); | |
| 245 | |
| 246 if (!fE->mLengthAttributes[nsSVGFE::ATTR_X].IsExplicitlySet()) | |
| 247 region.x = defaultFilterSubregion.X(); | |
| 248 if (!fE->mLengthAttributes[nsSVGFE::ATTR_Y].IsExplicitlySet()) | |
| 249 region.y = defaultFilterSubregion.Y(); | |
| 250 if (!fE->mLengthAttributes[nsSVGFE::ATTR_WIDTH].IsExplicitlySet()) | |
| 251 region.width = defaultFilterSubregion.Width(); | |
| 252 if (!fE->mLengthAttributes[nsSVGFE::ATTR_HEIGHT].IsExplicitlySet()) | |
| 253 region.height = defaultFilterSubregion.Height(); | |
| 254 | |
| 255 // We currently require filter primitive subregions to be pixel-aligned. | |
| 256 // Following the spec, any pixel partially in the region is included | |
| 257 // in the region. | |
| 258 region.RoundOut(); | |
| 259 | |
| 260 return RoundedToInt(region); | |
| 261 } | |
| 262 | |
| 263 void | |
| 264 nsSVGFilterInstance::GetInputsAreTainted(const nsTArray<FilterPrimitiveDescription>& aPrimitiveDescrs, | |
| 265 const nsTArray<int32_t>& aInputIndices, | |
| 266 nsTArray<bool>& aOutInputsAreTainted) | |
| 267 { | |
| 268 for (uint32_t i = 0; i < aInputIndices.Length(); i++) { | |
| 269 int32_t inputIndex = aInputIndices[i]; | |
| 270 if (inputIndex < 0) { | |
| 271 // SourceGraphic, SourceAlpha, FillPaint and StrokePaint are tainted. | |
| 272 aOutInputsAreTainted.AppendElement(true); | |
| 273 } else { | |
| 274 aOutInputsAreTainted.AppendElement(aPrimitiveDescrs[inputIndex].IsTainted()); | |
| 275 } | |
| 276 } | |
| 277 } | |
| 278 | |
| 279 static int32_t | |
| 280 GetLastResultIndex(const nsTArray<FilterPrimitiveDescription>& aPrimitiveDescrs) | |
| 281 { | |
| 282 uint32_t numPrimitiveDescrs = aPrimitiveDescrs.Length(); | |
| 283 return !numPrimitiveDescrs ? | |
| 284 FilterPrimitiveDescription::kPrimitiveIndexSourceGraphic : | |
| 285 numPrimitiveDescrs - 1; | |
| 286 } | |
| 287 | |
| 288 nsresult | |
| 289 nsSVGFilterInstance::GetSourceIndices(nsSVGFE* aPrimitiveElement, | |
| 290 const nsTArray<FilterPrimitiveDescription>& aPrimitiveDescrs, | |
| 291 const nsDataHashtable<nsStringHashKey, int32_t>& aImageTable, | |
| 292 nsTArray<int32_t>& aSourceIndices) | |
| 293 { | |
| 294 nsAutoTArray<nsSVGStringInfo,2> sources; | |
| 295 aPrimitiveElement->GetSourceImageNames(sources); | |
| 296 | |
| 297 for (uint32_t j = 0; j < sources.Length(); j++) { | |
| 298 nsAutoString str; | |
| 299 sources[j].mString->GetAnimValue(str, sources[j].mElement); | |
| 300 | |
| 301 int32_t sourceIndex = 0; | |
| 302 if (str.EqualsLiteral("SourceGraphic")) { | |
| 303 sourceIndex = mSourceGraphicIndex; | |
| 304 } else if (str.EqualsLiteral("SourceAlpha")) { | |
| 305 sourceIndex = FilterPrimitiveDescription::kPrimitiveIndexSourceAlpha; | |
| 306 } else if (str.EqualsLiteral("FillPaint")) { | |
| 307 sourceIndex = FilterPrimitiveDescription::kPrimitiveIndexFillPaint; | |
| 308 } else if (str.EqualsLiteral("StrokePaint")) { | |
| 309 sourceIndex = FilterPrimitiveDescription::kPrimitiveIndexStrokePaint; | |
| 310 } else if (str.EqualsLiteral("BackgroundImage") || | |
| 311 str.EqualsLiteral("BackgroundAlpha")) { | |
| 312 return NS_ERROR_NOT_IMPLEMENTED; | |
| 313 } else if (str.EqualsLiteral("")) { | |
| 314 sourceIndex = GetLastResultIndex(aPrimitiveDescrs); | |
| 315 } else { | |
| 316 bool inputExists = aImageTable.Get(str, &sourceIndex); | |
| 317 if (!inputExists) | |
| 318 return NS_ERROR_FAILURE; | |
| 319 } | |
| 320 | |
| 321 aSourceIndices.AppendElement(sourceIndex); | |
| 322 } | |
| 323 return NS_OK; | |
| 324 } | |
| 325 | |
| 326 nsresult | |
| 327 nsSVGFilterInstance::BuildPrimitives(nsTArray<FilterPrimitiveDescription>& aPrimitiveDescrs, | |
| 328 nsTArray<mozilla::RefPtr<SourceSurface>>& aInputImages) | |
| 329 { | |
| 330 mSourceGraphicIndex = GetLastResultIndex(aPrimitiveDescrs); | |
| 331 | |
| 332 // Get the filter primitive elements. | |
| 333 nsTArray<nsRefPtr<nsSVGFE> > primitives; | |
| 334 for (nsIContent* child = mFilterElement->nsINode::GetFirstChild(); | |
| 335 child; | |
| 336 child = child->GetNextSibling()) { | |
| 337 nsRefPtr<nsSVGFE> primitive; | |
| 338 CallQueryInterface(child, (nsSVGFE**)getter_AddRefs(primitive)); | |
| 339 if (primitive) { | |
| 340 primitives.AppendElement(primitive); | |
| 341 } | |
| 342 } | |
| 343 | |
| 344 // Maps source image name to source index. | |
| 345 nsDataHashtable<nsStringHashKey, int32_t> imageTable(10); | |
| 346 | |
| 347 // The principal that we check principals of any loaded images against. | |
| 348 nsCOMPtr<nsIPrincipal> principal = mTargetFrame->GetContent()->NodePrincipal(); | |
| 349 | |
| 350 for (uint32_t primitiveElementIndex = 0; | |
| 351 primitiveElementIndex < primitives.Length(); | |
| 352 ++primitiveElementIndex) { | |
| 353 nsSVGFE* filter = primitives[primitiveElementIndex]; | |
| 354 | |
| 355 nsAutoTArray<int32_t,2> sourceIndices; | |
| 356 nsresult rv = GetSourceIndices(filter, aPrimitiveDescrs, imageTable, sourceIndices); | |
| 357 if (NS_FAILED(rv)) { | |
| 358 return rv; | |
| 359 } | |
| 360 | |
| 361 IntRect primitiveSubregion = | |
| 362 ComputeFilterPrimitiveSubregion(filter, aPrimitiveDescrs, sourceIndices); | |
| 363 | |
| 364 nsTArray<bool> sourcesAreTainted; | |
| 365 GetInputsAreTainted(aPrimitiveDescrs, sourceIndices, sourcesAreTainted); | |
| 366 | |
| 367 FilterPrimitiveDescription descr = | |
| 368 filter->GetPrimitiveDescription(this, primitiveSubregion, sourcesAreTainted, aInputImages); | |
| 369 | |
| 370 descr.SetIsTainted(filter->OutputIsTainted(sourcesAreTainted, principal)); | |
| 371 descr.SetPrimitiveSubregion(primitiveSubregion); | |
| 372 | |
| 373 for (uint32_t i = 0; i < sourceIndices.Length(); i++) { | |
| 374 int32_t inputIndex = sourceIndices[i]; | |
| 375 descr.SetInputPrimitive(i, inputIndex); | |
| 376 | |
| 377 ColorSpace inputColorSpace = inputIndex >= 0 | |
| 378 ? aPrimitiveDescrs[inputIndex].OutputColorSpace() | |
| 379 : ColorSpace(ColorSpace::SRGB); | |
| 380 | |
| 381 ColorSpace desiredInputColorSpace = filter->GetInputColorSpace(i, inputColorSpace); | |
| 382 descr.SetInputColorSpace(i, desiredInputColorSpace); | |
| 383 if (i == 0) { | |
| 384 // the output color space is whatever in1 is if there is an in1 | |
| 385 descr.SetOutputColorSpace(desiredInputColorSpace); | |
| 386 } | |
| 387 } | |
| 388 | |
| 389 if (sourceIndices.Length() == 0) { | |
| 390 descr.SetOutputColorSpace(filter->GetOutputColorSpace()); | |
| 391 } | |
| 392 | |
| 393 aPrimitiveDescrs.AppendElement(descr); | |
| 394 uint32_t primitiveDescrIndex = aPrimitiveDescrs.Length() - 1; | |
| 395 | |
| 396 nsAutoString str; | |
| 397 filter->GetResultImageName().GetAnimValue(str, filter); | |
| 398 imageTable.Put(str, primitiveDescrIndex); | |
| 399 } | |
| 400 | |
| 401 return NS_OK; | |
| 402 } |
