| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/overlay_strategy_single_on_top.h" | |
| 6 | |
| 7 #include <limits> | |
| 8 | |
| 9 #include "cc/quads/draw_quad.h" | |
| 10 #include "cc/quads/solid_color_draw_quad.h" | |
| 11 #include "cc/quads/stream_video_draw_quad.h" | |
| 12 #include "cc/quads/texture_draw_quad.h" | |
| 13 #include "ui/gfx/geometry/point3_f.h" | |
| 14 #include "ui/gfx/geometry/rect_conversions.h" | |
| 15 #include "ui/gfx/transform.h" | |
| 16 | |
| 17 namespace cc { | |
| 18 | |
| 19 OverlayStrategySingleOnTop::OverlayStrategySingleOnTop( | |
| 20 OverlayCandidateValidator* capability_checker, | |
| 21 ResourceProvider* resource_provider) | |
| 22 : capability_checker_(capability_checker), | |
| 23 resource_provider_(resource_provider) {} | |
| 24 | |
| 25 bool OverlayStrategySingleOnTop::IsOverlayQuad(const DrawQuad* draw_quad) { | |
| 26 unsigned int resource_id; | |
| 27 switch (draw_quad->material) { | |
| 28 case DrawQuad::TEXTURE_CONTENT: | |
| 29 resource_id = TextureDrawQuad::MaterialCast(draw_quad)->resource_id; | |
| 30 break; | |
| 31 case DrawQuad::STREAM_VIDEO_CONTENT: | |
| 32 resource_id = StreamVideoDrawQuad::MaterialCast(draw_quad)->resource_id; | |
| 33 break; | |
| 34 default: | |
| 35 return false; | |
| 36 } | |
| 37 return resource_provider_->AllowOverlay(resource_id); | |
| 38 } | |
| 39 | |
| 40 bool OverlayStrategySingleOnTop::GetTextureQuadInfo( | |
| 41 const TextureDrawQuad& quad, | |
| 42 OverlayCandidate* quad_info) { | |
| 43 gfx::OverlayTransform overlay_transform = | |
| 44 OverlayCandidate::GetOverlayTransform(quad.quadTransform(), quad.flipped); | |
| 45 if (quad.background_color != SK_ColorTRANSPARENT || | |
| 46 quad.premultiplied_alpha || | |
| 47 overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID) | |
| 48 return false; | |
| 49 quad_info->resource_id = quad.resource_id; | |
| 50 quad_info->transform = overlay_transform; | |
| 51 quad_info->uv_rect = BoundingRect(quad.uv_top_left, quad.uv_bottom_right); | |
| 52 return true; | |
| 53 } | |
| 54 | |
| 55 bool OverlayStrategySingleOnTop::GetVideoQuadInfo( | |
| 56 const StreamVideoDrawQuad& quad, | |
| 57 OverlayCandidate* quad_info) { | |
| 58 gfx::OverlayTransform overlay_transform = | |
| 59 OverlayCandidate::GetOverlayTransform(quad.quadTransform(), false); | |
| 60 if (overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID) | |
| 61 return false; | |
| 62 if (!quad.matrix.IsScaleOrTranslation()) { | |
| 63 // We cannot handle anything other than scaling & translation for texture | |
| 64 // coordinates yet. | |
| 65 return false; | |
| 66 } | |
| 67 quad_info->resource_id = quad.resource_id; | |
| 68 quad_info->transform = overlay_transform; | |
| 69 | |
| 70 gfx::Point3F uv0 = gfx::Point3F(0, 0, 0); | |
| 71 gfx::Point3F uv1 = gfx::Point3F(1, 1, 0); | |
| 72 quad.matrix.TransformPoint(&uv0); | |
| 73 quad.matrix.TransformPoint(&uv1); | |
| 74 gfx::Vector3dF delta = uv1 - uv0; | |
| 75 if (delta.x() < 0) { | |
| 76 quad_info->transform = OverlayCandidate::ModifyTransform( | |
| 77 quad_info->transform, gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL); | |
| 78 float x0 = uv0.x(); | |
| 79 uv0.set_x(uv1.x()); | |
| 80 uv1.set_x(x0); | |
| 81 delta.set_x(-delta.x()); | |
| 82 } | |
| 83 | |
| 84 if (delta.y() < 0) { | |
| 85 // In this situation, uv0y < uv1y. Since we overlay inverted, a request | |
| 86 // to invert the source texture means we can just output the texture | |
| 87 // normally and it will be correct. | |
| 88 quad_info->uv_rect = gfx::RectF(uv0.x(), uv1.y(), delta.x(), -delta.y()); | |
| 89 } else { | |
| 90 quad_info->transform = OverlayCandidate::ModifyTransform( | |
| 91 quad_info->transform, gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL); | |
| 92 quad_info->uv_rect = gfx::RectF(uv0.x(), uv0.y(), delta.x(), delta.y()); | |
| 93 } | |
| 94 return true; | |
| 95 } | |
| 96 | |
| 97 bool OverlayStrategySingleOnTop::GetCandidateQuadInfo( | |
| 98 const DrawQuad& draw_quad, | |
| 99 OverlayCandidate* quad_info) { | |
| 100 // All quad checks. | |
| 101 if (draw_quad.needs_blending || draw_quad.shared_quad_state->opacity != 1.f || | |
| 102 draw_quad.shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode) | |
| 103 return false; | |
| 104 | |
| 105 if (draw_quad.material == DrawQuad::TEXTURE_CONTENT) { | |
| 106 const TextureDrawQuad& quad = *TextureDrawQuad::MaterialCast(&draw_quad); | |
| 107 if (!GetTextureQuadInfo(quad, quad_info)) | |
| 108 return false; | |
| 109 } else if (draw_quad.material == DrawQuad::STREAM_VIDEO_CONTENT) { | |
| 110 const StreamVideoDrawQuad& quad = | |
| 111 *StreamVideoDrawQuad::MaterialCast(&draw_quad); | |
| 112 if (!GetVideoQuadInfo(quad, quad_info)) | |
| 113 return false; | |
| 114 } | |
| 115 | |
| 116 quad_info->format = RGBA_8888; | |
| 117 quad_info->display_rect = OverlayCandidate::GetOverlayRect( | |
| 118 draw_quad.quadTransform(), draw_quad.rect); | |
| 119 return true; | |
| 120 } | |
| 121 | |
| 122 bool OverlayStrategySingleOnTop::IsInvisibleQuad(const DrawQuad* draw_quad) { | |
| 123 if (draw_quad->material == DrawQuad::SOLID_COLOR) { | |
| 124 const SolidColorDrawQuad* solid_quad = | |
| 125 SolidColorDrawQuad::MaterialCast(draw_quad); | |
| 126 SkColor color = solid_quad->color; | |
| 127 float opacity = solid_quad->opacity(); | |
| 128 float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity; | |
| 129 // Ignore transparent solid color quads. | |
| 130 return solid_quad->ShouldDrawWithBlending() && | |
| 131 alpha < std::numeric_limits<float>::epsilon(); | |
| 132 } | |
| 133 return false; | |
| 134 } | |
| 135 | |
| 136 bool OverlayStrategySingleOnTop::Attempt( | |
| 137 RenderPassList* render_passes_in_draw_order, | |
| 138 OverlayCandidateList* candidate_list) { | |
| 139 // Only attempt to handle very simple case for now. | |
| 140 if (!capability_checker_) | |
| 141 return false; | |
| 142 | |
| 143 RenderPass* root_render_pass = render_passes_in_draw_order->back(); | |
| 144 DCHECK(root_render_pass); | |
| 145 | |
| 146 OverlayCandidate candidate; | |
| 147 QuadList& quad_list = root_render_pass->quad_list; | |
| 148 auto candidate_iterator = quad_list.end(); | |
| 149 for (auto it = quad_list.begin(); it != quad_list.end(); ++it) { | |
| 150 const DrawQuad* draw_quad = *it; | |
| 151 if (IsOverlayQuad(draw_quad)) { | |
| 152 // Check that no prior quads overlap it. | |
| 153 bool intersects = false; | |
| 154 gfx::RectF rect = draw_quad->rect; | |
| 155 draw_quad->quadTransform().TransformRect(&rect); | |
| 156 for (auto overlap_iter = quad_list.cbegin(); overlap_iter != it; | |
| 157 ++overlap_iter) { | |
| 158 gfx::RectF overlap_rect = overlap_iter->rect; | |
| 159 overlap_iter->quadTransform().TransformRect(&overlap_rect); | |
| 160 if (rect.Intersects(overlap_rect) && !IsInvisibleQuad(*overlap_iter)) { | |
| 161 intersects = true; | |
| 162 break; | |
| 163 } | |
| 164 } | |
| 165 if (intersects || !GetCandidateQuadInfo(*draw_quad, &candidate)) | |
| 166 continue; | |
| 167 candidate_iterator = it; | |
| 168 break; | |
| 169 } | |
| 170 } | |
| 171 if (candidate_iterator == quad_list.end()) | |
| 172 return false; | |
| 173 | |
| 174 // Add our primary surface. | |
| 175 OverlayCandidateList candidates; | |
| 176 OverlayCandidate main_image; | |
| 177 main_image.display_rect = root_render_pass->output_rect; | |
| 178 candidates.push_back(main_image); | |
| 179 | |
| 180 // Add the overlay. | |
| 181 candidate.plane_z_order = 1; | |
| 182 candidates.push_back(candidate); | |
| 183 | |
| 184 // Check for support. | |
| 185 capability_checker_->CheckOverlaySupport(&candidates); | |
| 186 | |
| 187 // If the candidate can be handled by an overlay, create a pass for it. | |
| 188 if (candidates[1].overlay_handled) { | |
| 189 quad_list.EraseAndInvalidateAllPointers(candidate_iterator); | |
| 190 candidate_list->swap(candidates); | |
| 191 return true; | |
| 192 } | |
| 193 return false; | |
| 194 } | |
| 195 | |
| 196 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
