| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/output/filter_operations.h" | |
| 6 | |
| 7 #include <cmath> | |
| 8 | |
| 9 #include "base/trace_event/trace_event_argument.h" | |
| 10 #include "base/values.h" | |
| 11 #include "cc/output/filter_operation.h" | |
| 12 | |
| 13 namespace cc { | |
| 14 | |
| 15 FilterOperations::FilterOperations() {} | |
| 16 | |
| 17 FilterOperations::FilterOperations(const FilterOperations& other) | |
| 18 : operations_(other.operations_) {} | |
| 19 | |
| 20 FilterOperations::~FilterOperations() {} | |
| 21 | |
| 22 FilterOperations& FilterOperations::operator=(const FilterOperations& other) { | |
| 23 operations_ = other.operations_; | |
| 24 return *this; | |
| 25 } | |
| 26 | |
| 27 bool FilterOperations::operator==(const FilterOperations& other) const { | |
| 28 if (other.size() != size()) | |
| 29 return false; | |
| 30 for (size_t i = 0; i < size(); ++i) { | |
| 31 if (other.at(i) != at(i)) | |
| 32 return false; | |
| 33 } | |
| 34 return true; | |
| 35 } | |
| 36 | |
| 37 void FilterOperations::Append(const FilterOperation& filter) { | |
| 38 operations_.push_back(filter); | |
| 39 } | |
| 40 | |
| 41 void FilterOperations::Clear() { | |
| 42 operations_.clear(); | |
| 43 } | |
| 44 | |
| 45 bool FilterOperations::IsEmpty() const { | |
| 46 return operations_.empty(); | |
| 47 } | |
| 48 | |
| 49 static int SpreadForStdDeviation(float std_deviation) { | |
| 50 // https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html#feGaussianBlurE
lement | |
| 51 // provides this approximation for evaluating a gaussian blur by a triple box | |
| 52 // filter. | |
| 53 float d = floorf(std_deviation * 3.f * sqrt(8.f * atan(1.f)) / 4.f + 0.5f); | |
| 54 return static_cast<int>(ceilf(d * 3.f / 2.f)); | |
| 55 } | |
| 56 | |
| 57 void FilterOperations::GetOutsets(int* top, | |
| 58 int* right, | |
| 59 int* bottom, | |
| 60 int* left) const { | |
| 61 *top = *right = *bottom = *left = 0; | |
| 62 for (size_t i = 0; i < operations_.size(); ++i) { | |
| 63 const FilterOperation& op = operations_[i]; | |
| 64 // TODO(ajuma): Add support for reference filters once SkImageFilter | |
| 65 // reports its outsets. | |
| 66 DCHECK(op.type() != FilterOperation::REFERENCE); | |
| 67 if (op.type() == FilterOperation::BLUR || | |
| 68 op.type() == FilterOperation::DROP_SHADOW) { | |
| 69 int spread = SpreadForStdDeviation(op.amount()); | |
| 70 if (op.type() == FilterOperation::BLUR) { | |
| 71 *top += spread; | |
| 72 *right += spread; | |
| 73 *bottom += spread; | |
| 74 *left += spread; | |
| 75 } else { | |
| 76 *top += spread - op.drop_shadow_offset().y(); | |
| 77 *right += spread + op.drop_shadow_offset().x(); | |
| 78 *bottom += spread + op.drop_shadow_offset().y(); | |
| 79 *left += spread - op.drop_shadow_offset().x(); | |
| 80 } | |
| 81 } | |
| 82 } | |
| 83 } | |
| 84 | |
| 85 bool FilterOperations::HasFilterThatMovesPixels() const { | |
| 86 for (size_t i = 0; i < operations_.size(); ++i) { | |
| 87 const FilterOperation& op = operations_[i]; | |
| 88 // TODO(ajuma): Once SkImageFilter reports its outsets, use those here to | |
| 89 // determine whether a reference filter really moves pixels. | |
| 90 switch (op.type()) { | |
| 91 case FilterOperation::BLUR: | |
| 92 case FilterOperation::DROP_SHADOW: | |
| 93 case FilterOperation::ZOOM: | |
| 94 case FilterOperation::REFERENCE: | |
| 95 return true; | |
| 96 case FilterOperation::OPACITY: | |
| 97 case FilterOperation::COLOR_MATRIX: | |
| 98 case FilterOperation::GRAYSCALE: | |
| 99 case FilterOperation::SEPIA: | |
| 100 case FilterOperation::SATURATE: | |
| 101 case FilterOperation::HUE_ROTATE: | |
| 102 case FilterOperation::INVERT: | |
| 103 case FilterOperation::BRIGHTNESS: | |
| 104 case FilterOperation::CONTRAST: | |
| 105 case FilterOperation::SATURATING_BRIGHTNESS: | |
| 106 case FilterOperation::ALPHA_THRESHOLD: | |
| 107 break; | |
| 108 } | |
| 109 } | |
| 110 return false; | |
| 111 } | |
| 112 | |
| 113 bool FilterOperations::HasFilterThatAffectsOpacity() const { | |
| 114 for (size_t i = 0; i < operations_.size(); ++i) { | |
| 115 const FilterOperation& op = operations_[i]; | |
| 116 // TODO(ajuma): Make this smarter for reference filters. Once SkImageFilter | |
| 117 // can report affectsOpacity(), call that. | |
| 118 switch (op.type()) { | |
| 119 case FilterOperation::OPACITY: | |
| 120 case FilterOperation::BLUR: | |
| 121 case FilterOperation::DROP_SHADOW: | |
| 122 case FilterOperation::ZOOM: | |
| 123 case FilterOperation::REFERENCE: | |
| 124 case FilterOperation::ALPHA_THRESHOLD: | |
| 125 return true; | |
| 126 case FilterOperation::COLOR_MATRIX: { | |
| 127 const SkScalar* matrix = op.matrix(); | |
| 128 if (matrix[15] || | |
| 129 matrix[16] || | |
| 130 matrix[17] || | |
| 131 matrix[18] != 1 || | |
| 132 matrix[19]) | |
| 133 return true; | |
| 134 break; | |
| 135 } | |
| 136 case FilterOperation::GRAYSCALE: | |
| 137 case FilterOperation::SEPIA: | |
| 138 case FilterOperation::SATURATE: | |
| 139 case FilterOperation::HUE_ROTATE: | |
| 140 case FilterOperation::INVERT: | |
| 141 case FilterOperation::BRIGHTNESS: | |
| 142 case FilterOperation::CONTRAST: | |
| 143 case FilterOperation::SATURATING_BRIGHTNESS: | |
| 144 break; | |
| 145 } | |
| 146 } | |
| 147 return false; | |
| 148 } | |
| 149 | |
| 150 bool FilterOperations::HasReferenceFilter() const { | |
| 151 for (size_t i = 0; i < operations_.size(); ++i) { | |
| 152 if (operations_[i].type() == FilterOperation::REFERENCE) | |
| 153 return true; | |
| 154 } | |
| 155 return false; | |
| 156 } | |
| 157 | |
| 158 FilterOperations FilterOperations::Blend(const FilterOperations& from, | |
| 159 double progress) const { | |
| 160 if (HasReferenceFilter() || from.HasReferenceFilter()) | |
| 161 return *this; | |
| 162 | |
| 163 bool from_is_longer = from.size() > size(); | |
| 164 | |
| 165 size_t shorter_size, longer_size; | |
| 166 if (size() == from.size()) { | |
| 167 shorter_size = longer_size = size(); | |
| 168 } else if (from_is_longer) { | |
| 169 longer_size = from.size(); | |
| 170 shorter_size = size(); | |
| 171 } else { | |
| 172 longer_size = size(); | |
| 173 shorter_size = from.size(); | |
| 174 } | |
| 175 | |
| 176 for (size_t i = 0; i < shorter_size; i++) { | |
| 177 if (from.at(i).type() != at(i).type()) | |
| 178 return *this; | |
| 179 } | |
| 180 | |
| 181 FilterOperations blended_filters; | |
| 182 for (size_t i = 0; i < shorter_size; i++) { | |
| 183 blended_filters.Append( | |
| 184 FilterOperation::Blend(&from.at(i), &at(i), progress)); | |
| 185 } | |
| 186 | |
| 187 if (from_is_longer) { | |
| 188 for (size_t i = shorter_size; i < longer_size; i++) { | |
| 189 blended_filters.Append( | |
| 190 FilterOperation::Blend(&from.at(i), NULL, progress)); | |
| 191 } | |
| 192 } else { | |
| 193 for (size_t i = shorter_size; i < longer_size; i++) | |
| 194 blended_filters.Append(FilterOperation::Blend(NULL, &at(i), progress)); | |
| 195 } | |
| 196 | |
| 197 return blended_filters; | |
| 198 } | |
| 199 | |
| 200 void FilterOperations::AsValueInto( | |
| 201 base::trace_event::TracedValue* value) const { | |
| 202 for (size_t i = 0; i < operations_.size(); ++i) { | |
| 203 value->BeginDictionary(); | |
| 204 operations_[i].AsValueInto(value); | |
| 205 value->EndDictionary(); | |
| 206 } | |
| 207 } | |
| 208 | |
| 209 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
