OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/trees/layer_tree_host_impl.h" | 5 #include "cc/trees/layer_tree_host_impl.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <limits> | 8 #include <limits> |
9 | 9 |
10 #include "base/basictypes.h" | 10 #include "base/basictypes.h" |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
144 // that time interval, and then uploads should have a chance to be processed. | 144 // that time interval, and then uploads should have a chance to be processed. |
145 size_t ms_per_frame = std::floor(1000.0 / refresh_rate); | 145 size_t ms_per_frame = std::floor(1000.0 / refresh_rate); |
146 size_t max_transfer_buffer_usage_bytes = | 146 size_t max_transfer_buffer_usage_bytes = |
147 ms_per_frame * kMaxBytesUploadedPerMs; | 147 ms_per_frame * kMaxBytesUploadedPerMs; |
148 | 148 |
149 // The context may request a lower limit based on the device capabilities. | 149 // The context may request a lower limit based on the device capabilities. |
150 return std::min(context_capabilities.max_transfer_buffer_usage_bytes, | 150 return std::min(context_capabilities.max_transfer_buffer_usage_bytes, |
151 max_transfer_buffer_usage_bytes); | 151 max_transfer_buffer_usage_bytes); |
152 } | 152 } |
153 | 153 |
154 unsigned GetMapImageTextureTarget( | |
155 const ContextProvider::Capabilities& context_capabilities) { | |
156 // TODO(reveman): This should be a setting passed to the compositor instead | |
157 // of hard-coded here. The target that need to be used depends on our choice | |
158 // of GpuMemoryBuffer type. Note: SURFACE_TEXTURE needs EXTERNAL_OES, | |
159 // IO_SURFACE needs RECTANGLE_ARB. crbug.com/431059 | |
160 #if defined(OS_ANDROID) | |
161 if (context_capabilities.gpu.egl_image_external) | |
162 return GL_TEXTURE_EXTERNAL_OES; | |
163 #endif | |
164 if (context_capabilities.gpu.texture_rectangle) | |
165 return GL_TEXTURE_RECTANGLE_ARB; | |
166 | |
167 return GL_TEXTURE_2D; | |
168 } | |
169 | |
170 size_t GetMaxStagingResourceCount() { | 154 size_t GetMaxStagingResourceCount() { |
171 // Upper bound for number of staging resource to allow. | 155 // Upper bound for number of staging resource to allow. |
172 return 32; | 156 return 32; |
173 } | 157 } |
174 | 158 |
175 } // namespace | 159 } // namespace |
176 | 160 |
177 LayerTreeHostImpl::FrameData::FrameData() : has_no_damage(false) { | 161 LayerTreeHostImpl::FrameData::FrameData() : has_no_damage(false) { |
178 } | 162 } |
179 | 163 |
(...skipping 1818 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1998 void LayerTreeHostImpl::CreateResourceAndRasterWorkerPool( | 1982 void LayerTreeHostImpl::CreateResourceAndRasterWorkerPool( |
1999 scoped_ptr<RasterWorkerPool>* raster_worker_pool, | 1983 scoped_ptr<RasterWorkerPool>* raster_worker_pool, |
2000 scoped_ptr<ResourcePool>* resource_pool, | 1984 scoped_ptr<ResourcePool>* resource_pool, |
2001 scoped_ptr<ResourcePool>* staging_resource_pool) { | 1985 scoped_ptr<ResourcePool>* staging_resource_pool) { |
2002 base::SingleThreadTaskRunner* task_runner = | 1986 base::SingleThreadTaskRunner* task_runner = |
2003 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner() | 1987 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner() |
2004 : proxy_->MainThreadTaskRunner(); | 1988 : proxy_->MainThreadTaskRunner(); |
2005 DCHECK(task_runner); | 1989 DCHECK(task_runner); |
2006 | 1990 |
2007 ContextProvider* context_provider = output_surface_->context_provider(); | 1991 ContextProvider* context_provider = output_surface_->context_provider(); |
2008 bool should_use_zero_copy_rasterizer = | |
2009 settings_.use_zero_copy || IsSynchronousSingleThreaded(); | |
2010 | |
2011 if (!context_provider) { | 1992 if (!context_provider) { |
2012 *resource_pool = | 1993 *resource_pool = |
2013 ResourcePool::Create(resource_provider_.get(), | 1994 ResourcePool::Create(resource_provider_.get(), |
2014 GL_TEXTURE_2D, | 1995 GL_TEXTURE_2D, |
2015 resource_provider_->best_texture_format()); | 1996 resource_provider_->best_texture_format()); |
2016 | 1997 |
2017 *raster_worker_pool = | 1998 *raster_worker_pool = |
2018 BitmapRasterWorkerPool::Create(task_runner, | 1999 BitmapRasterWorkerPool::Create(task_runner, |
2019 RasterWorkerPool::GetTaskGraphRunner(), | 2000 RasterWorkerPool::GetTaskGraphRunner(), |
2020 resource_provider_.get()); | 2001 resource_provider_.get()); |
2021 } else if (use_gpu_rasterization_) { | 2002 return; |
| 2003 } |
| 2004 |
| 2005 if (use_gpu_rasterization_) { |
2022 *resource_pool = | 2006 *resource_pool = |
2023 ResourcePool::Create(resource_provider_.get(), | 2007 ResourcePool::Create(resource_provider_.get(), |
2024 GL_TEXTURE_2D, | 2008 GL_TEXTURE_2D, |
2025 resource_provider_->best_texture_format()); | 2009 resource_provider_->best_texture_format()); |
2026 | 2010 |
2027 *raster_worker_pool = | 2011 *raster_worker_pool = |
2028 GpuRasterWorkerPool::Create(task_runner, | 2012 GpuRasterWorkerPool::Create(task_runner, |
2029 context_provider, | 2013 context_provider, |
2030 resource_provider_.get(), | 2014 resource_provider_.get(), |
2031 settings_.use_distance_field_text); | 2015 settings_.use_distance_field_text); |
2032 } else if (should_use_zero_copy_rasterizer && CanUseZeroCopyRasterizer()) { | 2016 return; |
2033 *resource_pool = ResourcePool::Create( | 2017 } |
2034 resource_provider_.get(), | |
2035 GetMapImageTextureTarget(context_provider->ContextCapabilities()), | |
2036 resource_provider_->best_texture_format()); | |
2037 | 2018 |
2038 TaskGraphRunner* task_graph_runner; | 2019 if (GetRendererCapabilities().using_image) { |
2039 if (IsSynchronousSingleThreaded()) { | 2020 unsigned image_target = GL_TEXTURE_2D; |
2040 DCHECK(!single_thread_synchronous_task_graph_runner_); | 2021 #if defined(OS_MACOSX) |
2041 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner); | 2022 // GL_TEXTURE_RECTANGLE_ARB target is required by IOSurface backed images. |
2042 task_graph_runner = single_thread_synchronous_task_graph_runner_.get(); | 2023 DCHECK(context_provider->ContextCapabilities().gpu.texture_rectangle); |
2043 } else { | 2024 image_target = GL_TEXTURE_RECTANGLE_ARB; |
2044 task_graph_runner = RasterWorkerPool::GetTaskGraphRunner(); | 2025 #endif |
| 2026 if (settings_.use_image_external) { |
| 2027 DCHECK(context_provider->ContextCapabilities().gpu.egl_image_external); |
| 2028 image_target = GL_TEXTURE_EXTERNAL_OES; |
2045 } | 2029 } |
2046 | 2030 |
2047 *raster_worker_pool = ZeroCopyRasterWorkerPool::Create( | 2031 if (settings_.use_zero_copy || IsSynchronousSingleThreaded()) { |
2048 task_runner, task_graph_runner, resource_provider_.get()); | 2032 *resource_pool = |
2049 } else if (settings_.use_one_copy && CanUseOneCopyRasterizer()) { | 2033 ResourcePool::Create(resource_provider_.get(), image_target, |
2050 // We need to create a staging resource pool when using copy rasterizer. | 2034 resource_provider_->best_texture_format()); |
2051 *staging_resource_pool = ResourcePool::Create( | |
2052 resource_provider_.get(), | |
2053 GetMapImageTextureTarget(context_provider->ContextCapabilities()), | |
2054 resource_provider_->best_texture_format()); | |
2055 *resource_pool = | |
2056 ResourcePool::Create(resource_provider_.get(), | |
2057 GL_TEXTURE_2D, | |
2058 resource_provider_->best_texture_format()); | |
2059 | 2035 |
2060 *raster_worker_pool = | 2036 TaskGraphRunner* task_graph_runner; |
2061 OneCopyRasterWorkerPool::Create(task_runner, | 2037 if (IsSynchronousSingleThreaded()) { |
2062 RasterWorkerPool::GetTaskGraphRunner(), | 2038 DCHECK(!single_thread_synchronous_task_graph_runner_); |
2063 context_provider, | 2039 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner); |
2064 resource_provider_.get(), | 2040 task_graph_runner = single_thread_synchronous_task_graph_runner_.get(); |
2065 staging_resource_pool_.get()); | 2041 } else { |
2066 } else { | 2042 task_graph_runner = RasterWorkerPool::GetTaskGraphRunner(); |
2067 *resource_pool = ResourcePool::Create( | 2043 } |
2068 resource_provider_.get(), | |
2069 GL_TEXTURE_2D, | |
2070 resource_provider_->memory_efficient_texture_format()); | |
2071 | 2044 |
2072 *raster_worker_pool = PixelBufferRasterWorkerPool::Create( | 2045 *raster_worker_pool = ZeroCopyRasterWorkerPool::Create( |
2073 task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider, | 2046 task_runner, task_graph_runner, resource_provider_.get()); |
2074 resource_provider_.get(), | 2047 return; |
2075 GetMaxTransferBufferUsageBytes( | 2048 } |
2076 context_provider->ContextCapabilities(), | 2049 |
2077 settings_.renderer_settings.refresh_rate)); | 2050 if (settings_.use_one_copy) { |
| 2051 // We need to create a staging resource pool when using copy rasterizer. |
| 2052 *staging_resource_pool = |
| 2053 ResourcePool::Create(resource_provider_.get(), image_target, |
| 2054 resource_provider_->best_texture_format()); |
| 2055 *resource_pool = |
| 2056 ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D, |
| 2057 resource_provider_->best_texture_format()); |
| 2058 |
| 2059 *raster_worker_pool = OneCopyRasterWorkerPool::Create( |
| 2060 task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider, |
| 2061 resource_provider_.get(), staging_resource_pool_.get()); |
| 2062 return; |
| 2063 } |
2078 } | 2064 } |
| 2065 |
| 2066 *resource_pool = ResourcePool::Create( |
| 2067 resource_provider_.get(), GL_TEXTURE_2D, |
| 2068 resource_provider_->memory_efficient_texture_format()); |
| 2069 |
| 2070 *raster_worker_pool = PixelBufferRasterWorkerPool::Create( |
| 2071 task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider, |
| 2072 resource_provider_.get(), |
| 2073 GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(), |
| 2074 settings_.renderer_settings.refresh_rate)); |
2079 } | 2075 } |
2080 | 2076 |
2081 void LayerTreeHostImpl::DestroyTileManager() { | 2077 void LayerTreeHostImpl::DestroyTileManager() { |
2082 tile_manager_ = nullptr; | 2078 tile_manager_ = nullptr; |
2083 resource_pool_ = nullptr; | 2079 resource_pool_ = nullptr; |
2084 staging_resource_pool_ = nullptr; | 2080 staging_resource_pool_ = nullptr; |
2085 raster_worker_pool_ = nullptr; | 2081 raster_worker_pool_ = nullptr; |
2086 single_thread_synchronous_task_graph_runner_ = nullptr; | 2082 single_thread_synchronous_task_graph_runner_ = nullptr; |
2087 } | 2083 } |
2088 | 2084 |
2089 bool LayerTreeHostImpl::UsePendingTreeForSync() const { | 2085 bool LayerTreeHostImpl::UsePendingTreeForSync() const { |
2090 // In impl-side painting, synchronize to the pending tree so that it has | 2086 // In impl-side painting, synchronize to the pending tree so that it has |
2091 // time to raster before being displayed. | 2087 // time to raster before being displayed. |
2092 return settings_.impl_side_painting; | 2088 return settings_.impl_side_painting; |
2093 } | 2089 } |
2094 | 2090 |
2095 bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const { | 2091 bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const { |
2096 return !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler; | 2092 return !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler; |
2097 } | 2093 } |
2098 | 2094 |
2099 bool LayerTreeHostImpl::CanUseZeroCopyRasterizer() const { | |
2100 return GetRendererCapabilities().using_image; | |
2101 } | |
2102 | |
2103 bool LayerTreeHostImpl::CanUseOneCopyRasterizer() const { | |
2104 return GetRendererCapabilities().using_image; | |
2105 } | |
2106 | |
2107 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) { | 2095 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) { |
2108 SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget); | 2096 SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget); |
2109 } | 2097 } |
2110 | 2098 |
2111 bool LayerTreeHostImpl::InitializeRenderer( | 2099 bool LayerTreeHostImpl::InitializeRenderer( |
2112 scoped_ptr<OutputSurface> output_surface) { | 2100 scoped_ptr<OutputSurface> output_surface) { |
2113 TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer"); | 2101 TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer"); |
2114 | 2102 |
2115 // Since we will create a new resource provider, we cannot continue to use | 2103 // Since we will create a new resource provider, we cannot continue to use |
2116 // the old resources (i.e. render_surfaces and texture IDs). Clear them | 2104 // the old resources (i.e. render_surfaces and texture IDs). Clear them |
(...skipping 1374 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3491 } | 3479 } |
3492 | 3480 |
3493 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { | 3481 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { |
3494 std::vector<PictureLayerImpl*>::iterator it = | 3482 std::vector<PictureLayerImpl*>::iterator it = |
3495 std::find(picture_layers_.begin(), picture_layers_.end(), layer); | 3483 std::find(picture_layers_.begin(), picture_layers_.end(), layer); |
3496 DCHECK(it != picture_layers_.end()); | 3484 DCHECK(it != picture_layers_.end()); |
3497 picture_layers_.erase(it); | 3485 picture_layers_.erase(it); |
3498 } | 3486 } |
3499 | 3487 |
3500 } // namespace cc | 3488 } // namespace cc |
OLD | NEW |