HDR: Do nonlinear blending in the compositor

cc/surfaces/surface_aggregator.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/surfaces/surface_aggregator.h"
 
 #include <stddef.h>
 
 #include <map>
 
@@ skipping 230 matching lines @@
 
     size_t sqs_size = source.shared_quad_state_list.size();
     size_t dq_size = source.quad_list.size();
     std::unique_ptr<RenderPass> copy_pass(
         RenderPass::Create(sqs_size, dq_size));
 
     int remapped_pass_id = RemapPassId(source.id, surface_id);
 
     copy_pass->SetAll(remapped_pass_id, source.output_rect, source.output_rect,
                       source.transform_to_root_target, source.filters,
-                      source.background_filters, output_color_space_,
+                      source.background_filters, blending_color_space_,
                       source.has_transparent_background);
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     // Contributing passes aggregated in to the pass list need to take the
     // transform of the surface quad into account to update their transform to
     // the root surface.
     copy_pass->transform_to_root_target.ConcatTransform(
         surface_quad->shared_quad_state->quad_to_target_transform);
     copy_pass->transform_to_root_target.ConcatTransform(target_transform);
@@ skipping 54 matching lines @@
     RenderPassDrawQuad* quad =
         dest_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
     quad->SetNew(shared_quad_state, surface_quad->rect,
                  surface_quad->visible_rect, remapped_pass_id, 0, gfx::RectF(),
                  gfx::Size(), gfx::Vector2dF(), gfx::PointF(), gfx::RectF());
   }
 
   referenced_surfaces_.erase(it);
 }
 
+void SurfaceAggregator::AddColorConversionPass() {
+  if (dest_pass_list_->empty())
+    return;
+
+  RenderPass* root_render_pass = dest_pass_list_->back().get();
+  if (root_render_pass->color_space == output_color_space_)
+    return;
+
+  gfx::Rect output_rect = root_render_pass->output_rect;
+  CHECK(root_render_pass->transform_to_root_target == gfx::Transform());
+
+  if (!color_conversion_render_pass_id_)
+    color_conversion_render_pass_id_ = next_render_pass_id_++;
+
+  std::unique_ptr<RenderPass> color_conversion_pass(RenderPass::Create(1, 1));
+  color_conversion_pass->SetNew(color_conversion_render_pass_id_, output_rect,
+                                root_render_pass->damage_rect,
+                                root_render_pass->transform_to_root_target);
+  color_conversion_pass->color_space = output_color_space_;
+
+  SharedQuadState* shared_quad_state =
+      color_conversion_pass->CreateAndAppendSharedQuadState();
+  shared_quad_state->quad_layer_bounds = output_rect.size();
+  shared_quad_state->visible_quad_layer_rect = output_rect;
+  shared_quad_state->opacity = 1.f;
+
+  RenderPassDrawQuad* quad =
+      color_conversion_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
+  quad->SetNew(shared_quad_state, output_rect, output_rect,
+               root_render_pass->id, 0, gfx::RectF(), gfx::Size(),
+               gfx::Vector2dF(), gfx::PointF(), gfx::RectF());
+  dest_pass_list_->push_back(std::move(color_conversion_pass));
+}
+
 SharedQuadState* SurfaceAggregator::CopySharedQuadState(
     const SharedQuadState* source_sqs,
     const gfx::Transform& target_transform,
     const ClipData& clip_rect,
     RenderPass* dest_render_pass) {
   SharedQuadState* copy_shared_quad_state =
       dest_render_pass->CreateAndAppendSharedQuadState();
   *copy_shared_quad_state = *source_sqs;
   // target_transform contains any transformation that may exist
   // between the context that these quads are being copied from (i.e. the
@@ skipping 149 matching lines @@
     size_t dq_size = source.quad_list.size();
     std::unique_ptr<RenderPass> copy_pass(
         RenderPass::Create(sqs_size, dq_size));
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     int remapped_pass_id = RemapPassId(source.id, surface->surface_id());
 
     copy_pass->SetAll(remapped_pass_id, source.output_rect, source.output_rect,
                       source.transform_to_root_target, source.filters,
-                      source.background_filters, output_color_space_,
+                      source.background_filters, blending_color_space_,
                       source.has_transparent_background);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     child_to_parent_map, gfx::Transform(), ClipData(),
                     copy_pass.get(), surface->surface_id());
     if (!copy_request_passes_.count(remapped_pass_id) &&
         !moved_pixel_passes_.count(remapped_pass_id)) {
       gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
       if (copy_pass->transform_to_root_target.GetInverse(&inverse_transform)) {
         gfx::Rect damage_rect_in_render_pass_space =
@@ skipping 295 matching lines @@
   PrewalkResult prewalk_result;
   root_damage_rect_ = PrewalkTree(surface_id, false, 0, &prewalk_result);
   PropagateCopyRequestPasses();
   has_copy_requests_ = !copy_request_passes_.empty();
   frame.metadata.may_contain_video = prewalk_result.may_contain_video;
 
   CopyUndrawnSurfaces(&prewalk_result);
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
   CopyPasses(root_surface_frame, surface);
   referenced_surfaces_.erase(it);
+  AddColorConversionPass();
 
   moved_pixel_passes_.clear();
   copy_request_passes_.clear();
   render_pass_dependencies_.clear();
 
   // Remove all render pass mappings that weren't used in the current frame.
   for (auto it = render_pass_allocator_map_.begin();
        it != render_pass_allocator_map_.end();) {
     if (it->second.in_use) {
       it->second.in_use = false;
@@ skipping 38 matching lines @@
 
 void SurfaceAggregator::SetFullDamageForSurface(const SurfaceId& surface_id) {
   auto it = previous_contained_surfaces_.find(surface_id);
   if (it == previous_contained_surfaces_.end())
     return;
   // Set the last drawn index as 0 to ensure full damage next time it's drawn.
   it->second = 0;
 }
 
 void SurfaceAggregator::SetOutputColorSpace(
+    const gfx::ColorSpace& blending_color_space,
     const gfx::ColorSpace& output_color_space) {
+  blending_color_space_ = blending_color_space;
   output_color_space_ = output_color_space;
 }
 
 }  // namespace cc