1 /*
2  * Copyright (c) 2014-2020, The Linux Foundation. All rights reserved.
3  * Not a Contribution.
4  *
5  * Copyright 2015 The Android Open Source Project
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  */
19 
20 #include "hwc_layers.h"
21 #include <qdMetaData.h>
22 #include <qd_utils.h>
23 #include <utils/debug.h>
24 #include <stdint.h>
25 #include <utility>
26 #include <cmath>
27 
28 #define __CLASS__ "HWCLayer"
29 
30 namespace sdm {
31 
32 std::atomic<hwc2_layer_t> HWCLayer::next_id_(1);
33 
SetCSC(const private_handle_t * pvt_handle,ColorMetaData * color_metadata)34 DisplayError SetCSC(const private_handle_t *pvt_handle, ColorMetaData *color_metadata) {
35   if (getMetaData(const_cast<private_handle_t *>(pvt_handle), GET_COLOR_METADATA,
36                   color_metadata) != 0) {
37     ColorSpace_t csc = ITU_R_601;
38     if (getMetaData(const_cast<private_handle_t *>(pvt_handle),  GET_COLOR_SPACE,
39                     &csc) == 0) {
40       if (csc == ITU_R_601_FR || csc == ITU_R_2020_FR) {
41         color_metadata->range = Range_Full;
42       }
43       color_metadata->transfer = Transfer_sRGB;
44 
45       switch (csc) {
46         case ITU_R_601:
47         case ITU_R_601_FR:
48           // video and display driver uses 601_525
49           color_metadata->colorPrimaries = ColorPrimaries_BT601_6_525;
50           break;
51         case ITU_R_709:
52           color_metadata->colorPrimaries = ColorPrimaries_BT709_5;
53           break;
54         case ITU_R_2020:
55         case ITU_R_2020_FR:
56           color_metadata->colorPrimaries = ColorPrimaries_BT2020;
57           break;
58         default:
59           DLOGE("Unsupported CSC: %d", csc);
60           return kErrorNotSupported;
61       }
62     }
63   }
64 
65   return kErrorNone;
66 }
67 
68 // Returns true when color primary is supported
GetColorPrimary(const int32_t & dataspace,ColorPrimaries * color_primary)69 bool GetColorPrimary(const int32_t &dataspace, ColorPrimaries *color_primary) {
70   auto standard = dataspace & HAL_DATASPACE_STANDARD_MASK;
71   bool supported_csc = true;
72   switch (standard) {
73     case  HAL_DATASPACE_STANDARD_BT709:
74       *color_primary = ColorPrimaries_BT709_5;
75       break;
76     case HAL_DATASPACE_STANDARD_BT601_525:
77     case HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED:
78       *color_primary = ColorPrimaries_BT601_6_525;
79       break;
80     case HAL_DATASPACE_STANDARD_BT601_625:
81     case HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED:
82       *color_primary = ColorPrimaries_BT601_6_625;
83       break;
84     case HAL_DATASPACE_STANDARD_DCI_P3:
85       *color_primary = ColorPrimaries_DCIP3;
86       break;
87     case HAL_DATASPACE_STANDARD_BT2020:
88       *color_primary = ColorPrimaries_BT2020;
89       break;
90     default:
91       DLOGW_IF(kTagClient, "Unsupported Standard Request = %d", standard);
92       supported_csc = false;
93   }
94   return supported_csc;
95 }
96 
GetTransfer(const int32_t & dataspace,GammaTransfer * gamma_transfer)97 bool GetTransfer(const int32_t &dataspace, GammaTransfer *gamma_transfer) {
98   auto transfer = dataspace & HAL_DATASPACE_TRANSFER_MASK;
99   bool supported_transfer = true;
100   switch (transfer) {
101     case HAL_DATASPACE_TRANSFER_SRGB:
102       *gamma_transfer = Transfer_sRGB;
103       break;
104     case HAL_DATASPACE_TRANSFER_SMPTE_170M:
105       *gamma_transfer = Transfer_SMPTE_170M;
106       break;
107     case HAL_DATASPACE_TRANSFER_ST2084:
108       *gamma_transfer = Transfer_SMPTE_ST2084;
109       break;
110     case HAL_DATASPACE_TRANSFER_HLG:
111       *gamma_transfer = Transfer_HLG;
112       break;
113     case HAL_DATASPACE_TRANSFER_LINEAR:
114       *gamma_transfer = Transfer_Linear;
115       break;
116     case HAL_DATASPACE_TRANSFER_GAMMA2_2:
117       *gamma_transfer = Transfer_Gamma2_2;
118       break;
119     case HAL_DATASPACE_TRANSFER_GAMMA2_8:
120       *gamma_transfer = Transfer_Gamma2_8;
121       break;
122     default:
123       DLOGW_IF(kTagClient, "Unsupported Transfer Request = %d", transfer);
124       supported_transfer = false;
125   }
126   return supported_transfer;
127 }
128 
GetRange(const int32_t & dataspace,ColorRange * color_range)129 bool GetRange(const int32_t &dataspace, ColorRange *color_range) {
130   auto range = dataspace & HAL_DATASPACE_RANGE_MASK;
131   switch (range) {
132     case HAL_DATASPACE_RANGE_FULL:
133       *color_range = Range_Full;
134       break;
135     case HAL_DATASPACE_RANGE_LIMITED:
136       *color_range = Range_Limited;
137       break;
138     case HAL_DATASPACE_RANGE_EXTENDED:
139       *color_range = Range_Extended;
140       return false;
141     default:
142       DLOGW_IF(kTagClient, "Unsupported Range Request = %d", range);
143       return false;
144   }
145   return true;
146 }
147 
IsBT2020(const ColorPrimaries & color_primary)148 bool IsBT2020(const ColorPrimaries &color_primary) {
149   switch (color_primary) {
150   case ColorPrimaries_BT2020:
151     return true;
152     break;
153   default:
154     return false;
155   }
156 }
157 
TranslateFromLegacyDataspace(const int32_t & legacy_ds)158 int32_t TranslateFromLegacyDataspace(const int32_t &legacy_ds) {
159   int32_t dataspace = legacy_ds;
160 
161   if (dataspace & 0xffff) {
162     switch (dataspace & 0xffff) {
163       case HAL_DATASPACE_SRGB:
164         dataspace = HAL_DATASPACE_V0_SRGB;
165         break;
166       case HAL_DATASPACE_JFIF:
167         dataspace = HAL_DATASPACE_V0_JFIF;
168         break;
169       case HAL_DATASPACE_SRGB_LINEAR:
170         dataspace = HAL_DATASPACE_V0_SRGB_LINEAR;
171         break;
172       case HAL_DATASPACE_BT601_625:
173         dataspace = HAL_DATASPACE_V0_BT601_625;
174         break;
175       case HAL_DATASPACE_BT601_525:
176         dataspace = HAL_DATASPACE_V0_BT601_525;
177         break;
178       case HAL_DATASPACE_BT709:
179         dataspace = HAL_DATASPACE_V0_BT709;
180         break;
181       default:
182         // unknown legacy dataspace
183         DLOGW_IF(kTagClient, "Unsupported dataspace type %d", dataspace);
184     }
185   }
186 
187   if (dataspace == HAL_DATASPACE_UNKNOWN) {
188     dataspace = HAL_DATASPACE_V0_SRGB;
189   }
190 
191   return dataspace;
192 }
193 
194 // Retrieve ColorMetaData from android_data_space_t (STANDARD|TRANSFER|RANGE)
GetSDMColorSpace(const int32_t & dataspace,ColorMetaData * color_metadata)195 bool GetSDMColorSpace(const int32_t &dataspace, ColorMetaData *color_metadata) {
196   bool valid = false;
197   valid = GetColorPrimary(dataspace, &(color_metadata->colorPrimaries));
198   if (valid) {
199     valid = GetTransfer(dataspace, &(color_metadata->transfer));
200   }
201   if (valid) {
202     valid = GetRange(dataspace, &(color_metadata->range));
203   }
204 
205   return valid;
206 }
207 
208 // Layer operations
HWCLayer(hwc2_display_t display_id,HWCBufferAllocator * buf_allocator)209 HWCLayer::HWCLayer(hwc2_display_t display_id, HWCBufferAllocator *buf_allocator)
210   : id_(next_id_++), display_id_(display_id), buffer_allocator_(buf_allocator) {
211   layer_ = new Layer();
212   // Fences are deferred, so the first time this layer is presented, return -1
213   // TODO(user): Verify that fences are properly obtained on suspend/resume
214   release_fences_.push_back(nullptr);
215 }
216 
~HWCLayer()217 HWCLayer::~HWCLayer() {
218   // Close any fences left for this layer
219   while (!release_fences_.empty()) {
220     release_fences_.pop_front();
221   }
222   if (layer_) {
223     if (buffer_fd_ >= 0) {
224       ::close(buffer_fd_);
225     }
226     delete layer_;
227   }
228 }
229 
SetLayerBuffer(buffer_handle_t buffer,shared_ptr<Fence> acquire_fence)230 HWC2::Error HWCLayer::SetLayerBuffer(buffer_handle_t buffer, shared_ptr<Fence> acquire_fence) {
231   if (!buffer) {
232     if (client_requested_ == HWC2::Composition::Device ||
233         client_requested_ == HWC2::Composition::Cursor) {
234       DLOGW("Invalid buffer handle: %p on layer: %" PRIu64 " client requested comp type %d", buffer,
235             id_, client_requested_);
236       return HWC2::Error::BadParameter;
237     } else {
238       return HWC2::Error::None;
239     }
240   }
241 
242   const private_handle_t *handle = static_cast<const private_handle_t *>(buffer);
243 
244   if (handle->fd < 0) {
245     return HWC2::Error::BadParameter;
246   }
247 
248   LayerBuffer *layer_buffer = &layer_->input_buffer;
249   int aligned_width, aligned_height;
250   buffer_allocator_->GetCustomWidthAndHeight(handle, &aligned_width, &aligned_height);
251 
252   LayerBufferFormat format = GetSDMFormat(handle->format, handle->flags);
253   if ((format != layer_buffer->format) || (UINT32(aligned_width) != layer_buffer->width) ||
254       (UINT32(aligned_height) != layer_buffer->height)) {
255     // Layer buffer geometry has changed.
256     geometry_changes_ |= kBufferGeometry;
257   }
258 
259   layer_buffer->format = format;
260   layer_buffer->width = UINT32(aligned_width);
261   layer_buffer->height = UINT32(aligned_height);
262   layer_buffer->unaligned_width = UINT32(handle->unaligned_width);
263   layer_buffer->unaligned_height = UINT32(handle->unaligned_height);
264 
265   layer_buffer->flags.video = (handle->buffer_type == BUFFER_TYPE_VIDEO) ? true : false;
266   if (SetMetaData(const_cast<private_handle_t *>(handle), layer_) != kErrorNone) {
267     return HWC2::Error::BadLayer;
268   }
269 
270   // TZ Protected Buffer - L1
271   secure_ = (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER);
272   bool secure_camera = secure_ && (handle->flags & private_handle_t::PRIV_FLAGS_CAMERA_WRITE);
273   bool secure_display = (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY);
274   if (secure_ != layer_buffer->flags.secure || secure_camera != layer_buffer->flags.secure_camera ||
275       secure_display != layer_buffer->flags.secure_display) {
276     // Secure attribute of layer buffer has changed.
277     layer_->update_mask.set(kSecurity);
278   }
279 
280   layer_buffer->flags.secure = secure_;
281   layer_buffer->flags.secure_camera = secure_camera;
282   layer_buffer->flags.secure_display = secure_display;
283 
284   layer_buffer->acquire_fence = acquire_fence;
285   if (buffer_fd_ >= 0) {
286     ::close(buffer_fd_);
287   }
288   buffer_fd_ = ::dup(handle->fd);
289   layer_buffer->planes[0].fd = buffer_fd_;
290   layer_buffer->planes[0].offset = handle->offset;
291   layer_buffer->planes[0].stride = UINT32(handle->width);
292   layer_buffer->size = handle->size;
293   buffer_flipped_ = reinterpret_cast<uint64_t>(handle) != layer_buffer->buffer_id;
294   layer_buffer->buffer_id = reinterpret_cast<uint64_t>(handle);
295   layer_buffer->handle_id = handle->id;
296 
297   return HWC2::Error::None;
298 }
299 
SetLayerSurfaceDamage(hwc_region_t damage)300 HWC2::Error HWCLayer::SetLayerSurfaceDamage(hwc_region_t damage) {
301   surface_updated_ = true;
302   if ((damage.numRects == 1) && (damage.rects[0].bottom == 0) && (damage.rects[0].right == 0)) {
303     surface_updated_ = false;
304   }
305 
306   if (!layer_->flags.updating && surface_updated_) {
307     layer_->update_mask.set(kSurfaceInvalidate);
308   }
309 
310   if (!partial_update_enabled_) {
311     SetDirtyRegions(damage);
312     return HWC2::Error::None;
313   }
314 
315   // Check if there is an update in SurfaceDamage rects.
316   if (layer_->dirty_regions.size() != damage.numRects) {
317     layer_->update_mask.set(kSurfaceInvalidate);
318   } else {
319     for (uint32_t j = 0; j < damage.numRects; j++) {
320       LayerRect damage_rect;
321       SetRect(damage.rects[j], &damage_rect);
322       if (damage_rect != layer_->dirty_regions.at(j)) {
323         layer_->update_mask.set(kSurfaceDamage);
324         break;
325       }
326     }
327   }
328 
329   SetDirtyRegions(damage);
330   return HWC2::Error::None;
331 }
332 
SetLayerBlendMode(HWC2::BlendMode mode)333 HWC2::Error HWCLayer::SetLayerBlendMode(HWC2::BlendMode mode) {
334   LayerBlending blending = kBlendingPremultiplied;
335   switch (mode) {
336     case HWC2::BlendMode::Coverage:
337       blending = kBlendingCoverage;
338       break;
339     case HWC2::BlendMode::Premultiplied:
340       blending = kBlendingPremultiplied;
341       break;
342     case HWC2::BlendMode::None:
343       blending = kBlendingOpaque;
344       break;
345     default:
346       return HWC2::Error::BadParameter;
347   }
348 
349   if (layer_->blending != blending) {
350     geometry_changes_ |= kBlendMode;
351     layer_->blending = blending;
352   }
353   return HWC2::Error::None;
354 }
355 
SetLayerColor(hwc_color_t color)356 HWC2::Error HWCLayer::SetLayerColor(hwc_color_t color) {
357   if (client_requested_ != HWC2::Composition::SolidColor) {
358     return HWC2::Error::None;
359   }
360   if (layer_->solid_fill_color != GetUint32Color(color)) {
361     layer_->solid_fill_color = GetUint32Color(color);
362     layer_->update_mask.set(kSurfaceInvalidate);
363     surface_updated_ = true;
364   } else {
365     surface_updated_ = false;
366   }
367 
368   layer_->input_buffer.format = kFormatARGB8888;
369   DLOGV_IF(kTagClient, "[%" PRIu64 "][%" PRIu64 "] Layer color set to %x", display_id_, id_,
370            layer_->solid_fill_color);
371   return HWC2::Error::None;
372 }
373 
SetLayerCompositionType(HWC2::Composition type)374 HWC2::Error HWCLayer::SetLayerCompositionType(HWC2::Composition type) {
375   // Validation is required when the client changes the composition type
376   if (client_requested_ != type) {
377     layer_->update_mask.set(kClientCompRequest);
378   }
379   client_requested_ = type;
380   switch (type) {
381     case HWC2::Composition::Client:
382       break;
383     case HWC2::Composition::Device:
384       // We try and default to this in SDM
385       break;
386     case HWC2::Composition::SolidColor:
387       break;
388     case HWC2::Composition::Cursor:
389       break;
390     case HWC2::Composition::Invalid:
391       return HWC2::Error::BadParameter;
392     default:
393       return HWC2::Error::Unsupported;
394   }
395 
396   return HWC2::Error::None;
397 }
398 
SetLayerDataspace(int32_t dataspace)399 HWC2::Error HWCLayer::SetLayerDataspace(int32_t dataspace) {
400   // Map deprecated dataspace values to appropriate new enums
401   dataspace = TranslateFromLegacyDataspace(dataspace);
402 
403   // cache the dataspace, to be used later to update SDM ColorMetaData
404   if (dataspace_ != dataspace) {
405     geometry_changes_ |= kDataspace;
406     dataspace_ = dataspace;
407     if (layer_->input_buffer.buffer_id) {
408       ValidateAndSetCSC(reinterpret_cast<private_handle_t *>(layer_->input_buffer.buffer_id));
409     }
410   }
411   return HWC2::Error::None;
412 }
413 
SetLayerDisplayFrame(hwc_rect_t frame)414 HWC2::Error HWCLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
415   LayerRect dst_rect = {};
416 
417   SetRect(frame, &dst_rect);
418   if (dst_rect_ != dst_rect) {
419     geometry_changes_ |= kDisplayFrame;
420     dst_rect_ = dst_rect;
421   }
422 
423   return HWC2::Error::None;
424 }
425 
ResetPerFrameData()426 void HWCLayer::ResetPerFrameData() {
427   layer_->dst_rect = dst_rect_;
428   layer_->transform = layer_transform_;
429 }
430 
SetCursorPosition(int32_t x,int32_t y)431 HWC2::Error HWCLayer::SetCursorPosition(int32_t x, int32_t y) {
432   hwc_rect_t frame = {};
433   frame.left = x;
434   frame.top = y;
435   frame.right = x + INT(layer_->dst_rect.right - layer_->dst_rect.left);
436   frame.bottom = y + INT(layer_->dst_rect.bottom - layer_->dst_rect.top);
437   SetLayerDisplayFrame(frame);
438 
439   return HWC2::Error::None;
440 }
441 
SetLayerPlaneAlpha(float alpha)442 HWC2::Error HWCLayer::SetLayerPlaneAlpha(float alpha) {
443   if (alpha < 0.0f || alpha > 1.0f) {
444     return HWC2::Error::BadParameter;
445   }
446 
447   //  Conversion of float alpha in range 0.0 to 1.0 similar to the HWC Adapter
448   uint8_t plane_alpha = static_cast<uint8_t>(std::round(255.0f * alpha));
449 
450   if (layer_->plane_alpha != plane_alpha) {
451     geometry_changes_ |= kPlaneAlpha;
452     layer_->plane_alpha = plane_alpha;
453   }
454 
455   return HWC2::Error::None;
456 }
457 
SetLayerSourceCrop(hwc_frect_t crop)458 HWC2::Error HWCLayer::SetLayerSourceCrop(hwc_frect_t crop) {
459   LayerRect src_rect = {};
460   SetRect(crop, &src_rect);
461   non_integral_source_crop_ = ((crop.left != roundf(crop.left)) ||
462                               (crop.top != roundf(crop.top)) ||
463                               (crop.right != roundf(crop.right)) ||
464                               (crop.bottom != roundf(crop.bottom)));
465   if (non_integral_source_crop_) {
466     DLOGV_IF(kTagClient, "Crop: LTRB %f %f %f %f", crop.left, crop.top, crop.right, crop.bottom);
467   }
468   if (layer_->src_rect != src_rect) {
469     geometry_changes_ |= kSourceCrop;
470     layer_->src_rect = src_rect;
471   }
472 
473   return HWC2::Error::None;
474 }
475 
SetLayerTransform(HWC2::Transform transform)476 HWC2::Error HWCLayer::SetLayerTransform(HWC2::Transform transform) {
477   LayerTransform layer_transform = {};
478   switch (transform) {
479     case HWC2::Transform::FlipH:
480       layer_transform.flip_horizontal = true;
481       break;
482     case HWC2::Transform::FlipV:
483       layer_transform.flip_vertical = true;
484       break;
485     case HWC2::Transform::Rotate90:
486       layer_transform.rotation = 90.0f;
487       break;
488     case HWC2::Transform::Rotate180:
489       layer_transform.flip_horizontal = true;
490       layer_transform.flip_vertical = true;
491       break;
492     case HWC2::Transform::Rotate270:
493       layer_transform.rotation = 90.0f;
494       layer_transform.flip_horizontal = true;
495       layer_transform.flip_vertical = true;
496       break;
497     case HWC2::Transform::FlipHRotate90:
498       layer_transform.rotation = 90.0f;
499       layer_transform.flip_horizontal = true;
500       break;
501     case HWC2::Transform::FlipVRotate90:
502       layer_transform.rotation = 90.0f;
503       layer_transform.flip_vertical = true;
504       break;
505     case HWC2::Transform::None:
506       break;
507     default:
508       //  bad transform
509       return HWC2::Error::BadParameter;
510   }
511 
512   if (layer_transform_ != layer_transform) {
513     geometry_changes_ |= kTransform;
514     layer_transform_ = layer_transform;
515   }
516 
517   return HWC2::Error::None;
518 }
519 
SetLayerVisibleRegion(hwc_region_t visible)520 HWC2::Error HWCLayer::SetLayerVisibleRegion(hwc_region_t visible) {
521   layer_->visible_regions.clear();
522   for (uint32_t i = 0; i < visible.numRects; i++) {
523     LayerRect rect;
524     SetRect(visible.rects[i], &rect);
525     layer_->visible_regions.push_back(rect);
526   }
527 
528   return HWC2::Error::None;
529 }
530 
SetLayerZOrder(uint32_t z)531 HWC2::Error HWCLayer::SetLayerZOrder(uint32_t z) {
532   if (z_ != z) {
533     geometry_changes_ |= kZOrder;
534     z_ = z;
535   }
536 
537   return HWC2::Error::None;
538 }
539 
SetLayerType(IQtiComposerClient::LayerType type)540 HWC2::Error HWCLayer::SetLayerType(IQtiComposerClient::LayerType type) {
541   LayerTypes layer_type = kLayerUnknown;
542   switch (type) {
543     case IQtiComposerClient::LayerType::UNKNOWN:
544       layer_type = kLayerUnknown;
545       break;
546     case IQtiComposerClient::LayerType::APP:
547       layer_type = kLayerApp;
548       break;
549     case IQtiComposerClient::LayerType::GAME:
550       layer_type = kLayerGame;
551       break;
552     case IQtiComposerClient::LayerType::BROWSER:
553       layer_type = kLayerBrowser;
554       break;
555     default:
556       DLOGW("Unsupported layer type %d", layer_type);
557       break;
558   }
559 
560   type_ = layer_type;
561   return HWC2::Error::None;
562 }
563 
SetLayerColorTransform(const float * matrix)564 HWC2::Error HWCLayer::SetLayerColorTransform(const float *matrix) {
565   if (std::memcmp(matrix, layer_->color_transform_matrix, sizeof(layer_->color_transform_matrix))) {
566     std::memcpy(layer_->color_transform_matrix, matrix, sizeof(layer_->color_transform_matrix));
567     layer_->update_mask.set(kColorTransformUpdate);
568     color_transform_matrix_set_ = true;
569     if (!std::memcmp(matrix, kIdentityMatrix, sizeof(kIdentityMatrix))) {
570       color_transform_matrix_set_ = false;
571     }
572   }
573   return HWC2::Error::None;
574 }
575 
SetLayerPerFrameMetadata(uint32_t num_elements,const PerFrameMetadataKey * keys,const float * metadata)576 HWC2::Error HWCLayer::SetLayerPerFrameMetadata(uint32_t num_elements,
577                                                const PerFrameMetadataKey *keys,
578                                                const float *metadata) {
579   auto old_mastering_display = layer_->input_buffer.color_metadata.masteringDisplayInfo;
580   auto old_content_light = layer_->input_buffer.color_metadata.contentLightLevel;
581   auto &mastering_display = layer_->input_buffer.color_metadata.masteringDisplayInfo;
582   auto &content_light = layer_->input_buffer.color_metadata.contentLightLevel;
583   for (uint32_t i = 0; i < num_elements; i++) {
584     switch (keys[i]) {
585       case PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X:
586         mastering_display.colorVolumeSEIEnabled = true;
587         mastering_display.primaries.rgbPrimaries[0][0] = UINT32(metadata[i] * 50000);
588         break;
589       case PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y:
590         mastering_display.primaries.rgbPrimaries[0][1] = UINT32(metadata[i] * 50000);
591         break;
592       case PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X:
593         mastering_display.primaries.rgbPrimaries[1][0] = UINT32(metadata[i] * 50000);
594         break;
595       case PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y:
596         mastering_display.primaries.rgbPrimaries[1][1] = UINT32(metadata[i] * 50000);
597         break;
598       case PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X:
599         mastering_display.primaries.rgbPrimaries[2][0] = UINT32(metadata[i] * 50000);
600         break;
601       case PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y:
602         mastering_display.primaries.rgbPrimaries[2][1] = UINT32(metadata[i] * 50000);
603         break;
604       case PerFrameMetadataKey::WHITE_POINT_X:
605         mastering_display.primaries.whitePoint[0] = UINT32(metadata[i] * 50000);
606         break;
607       case PerFrameMetadataKey::WHITE_POINT_Y:
608         mastering_display.primaries.whitePoint[1] = UINT32(metadata[i] * 50000);
609         break;
610       case PerFrameMetadataKey::MAX_LUMINANCE:
611         mastering_display.maxDisplayLuminance = UINT32(metadata[i]);
612         break;
613       case PerFrameMetadataKey::MIN_LUMINANCE:
614         mastering_display.minDisplayLuminance = UINT32(metadata[i] * 10000);
615         break;
616       case PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL:
617         content_light.lightLevelSEIEnabled = true;
618         content_light.maxContentLightLevel = UINT32(metadata[i]);
619         break;
620       case PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL:
621         content_light.minPicAverageLightLevel = UINT32(metadata[i]);
622         break;
623       default:
624        break;
625     }
626   }
627   if ((!SameConfig(&old_mastering_display, &mastering_display, UINT32(sizeof(MasteringDisplay)))) ||
628       (!SameConfig(&old_content_light, &content_light, UINT32(sizeof(ContentLightLevel))))) {
629     layer_->update_mask.set(kMetadataUpdate);
630     geometry_changes_ |= kDataspace;
631   }
632   return HWC2::Error::None;
633 }
634 
SetLayerPerFrameMetadataBlobs(uint32_t num_elements,const PerFrameMetadataKey * keys,const uint32_t * sizes,const uint8_t * metadata)635 HWC2::Error HWCLayer::SetLayerPerFrameMetadataBlobs(uint32_t num_elements,
636                                                     const PerFrameMetadataKey *keys,
637                                                     const uint32_t *sizes,
638                                                     const uint8_t* metadata) {
639   if (!keys || !sizes || !metadata) {
640     DLOGE("metadata or sizes or keys is null");
641     return HWC2::Error::BadParameter;
642   }
643 
644   ColorMetaData &color_metadata = layer_->input_buffer.color_metadata;
645   for (uint32_t i = 0; i < num_elements; i++) {
646     switch (keys[i]) {
647       case PerFrameMetadataKey::HDR10_PLUS_SEI:
648         if (sizes[i] > HDR_DYNAMIC_META_DATA_SZ) {
649           DLOGE("Size of HDR10_PLUS_SEI = %d", sizes[i]);
650           return HWC2::Error::BadParameter;
651         }
652         // if dynamic metadata changes, store and set needs validate
653         if (!SameConfig(static_cast<const uint8_t*>(color_metadata.dynamicMetaDataPayload),
654                         metadata, sizes[i])) {
655           geometry_changes_ |= kDataspace;
656           color_metadata.dynamicMetaDataValid = true;
657           color_metadata.dynamicMetaDataLen = sizes[i];
658           std::memcpy(color_metadata.dynamicMetaDataPayload, metadata, sizes[i]);
659           layer_->update_mask.set(kMetadataUpdate);
660         }
661         break;
662       default:
663         DLOGW("Invalid key = %d", keys[i]);
664         return HWC2::Error::BadParameter;
665     }
666   }
667   return HWC2::Error::None;
668 }
669 
SetRect(const hwc_rect_t & source,LayerRect * target)670 void HWCLayer::SetRect(const hwc_rect_t &source, LayerRect *target) {
671   target->left = FLOAT(source.left);
672   target->top = FLOAT(source.top);
673   target->right = FLOAT(source.right);
674   target->bottom = FLOAT(source.bottom);
675 }
676 
SetRect(const hwc_frect_t & source,LayerRect * target)677 void HWCLayer::SetRect(const hwc_frect_t &source, LayerRect *target) {
678   // Recommended way of rounding as in hwcomposer2.h - SetLayerSourceCrop
679   target->left = std::ceil(source.left);
680   target->top = std::ceil(source.top);
681   target->right = std::floor(source.right);
682   target->bottom = std::floor(source.bottom);
683 }
684 
GetUint32Color(const hwc_color_t & source)685 uint32_t HWCLayer::GetUint32Color(const hwc_color_t &source) {
686   // Returns 32 bit ARGB
687   uint32_t a = UINT32(source.a) << 24;
688   uint32_t r = UINT32(source.r) << 16;
689   uint32_t g = UINT32(source.g) << 8;
690   uint32_t b = UINT32(source.b);
691   uint32_t color = a | r | g | b;
692   return color;
693 }
694 
GetSDMFormat(const int32_t & source,const int flags)695 LayerBufferFormat HWCLayer::GetSDMFormat(const int32_t &source, const int flags) {
696   LayerBufferFormat format = kFormatInvalid;
697   if (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
698     switch (source) {
699       case HAL_PIXEL_FORMAT_RGBA_8888:
700         format = kFormatRGBA8888Ubwc;
701         break;
702       case HAL_PIXEL_FORMAT_RGBX_8888:
703         format = kFormatRGBX8888Ubwc;
704         break;
705       case HAL_PIXEL_FORMAT_BGR_565:
706         format = kFormatBGR565Ubwc;
707         break;
708       case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
709       case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
710       case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
711         format = kFormatYCbCr420SPVenusUbwc;
712         break;
713       case HAL_PIXEL_FORMAT_RGBA_1010102:
714         format = kFormatRGBA1010102Ubwc;
715         break;
716       case HAL_PIXEL_FORMAT_RGBX_1010102:
717         format = kFormatRGBX1010102Ubwc;
718         break;
719       case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
720         format = kFormatYCbCr420TP10Ubwc;
721         break;
722       case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
723         format = kFormatYCbCr420P010Ubwc;
724         break;
725       default:
726         DLOGW("Unsupported format type for UBWC %s", qdutils::GetHALPixelFormatString(source));
727         return kFormatInvalid;
728     }
729     return format;
730   }
731 
732   switch (source) {
733     case HAL_PIXEL_FORMAT_RGBA_8888:
734       format = kFormatRGBA8888;
735       break;
736     case HAL_PIXEL_FORMAT_RGBA_5551:
737       format = kFormatRGBA5551;
738       break;
739     case HAL_PIXEL_FORMAT_RGBA_4444:
740       format = kFormatRGBA4444;
741       break;
742     case HAL_PIXEL_FORMAT_BGRA_8888:
743       format = kFormatBGRA8888;
744       break;
745     case HAL_PIXEL_FORMAT_RGBX_8888:
746       format = kFormatRGBX8888;
747       break;
748     case HAL_PIXEL_FORMAT_BGRX_8888:
749       format = kFormatBGRX8888;
750       break;
751     case HAL_PIXEL_FORMAT_RGB_888:
752       format = kFormatRGB888;
753       break;
754     case HAL_PIXEL_FORMAT_BGR_888:
755       format = kFormatBGR888;
756       break;
757     case HAL_PIXEL_FORMAT_RGB_565:
758       format = kFormatRGB565;
759       break;
760     case HAL_PIXEL_FORMAT_BGR_565:
761       format = kFormatBGR565;
762       break;
763     case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
764     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
765       format = kFormatYCbCr420SemiPlanarVenus;
766       break;
767     case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
768       format = kFormatYCrCb420SemiPlanarVenus;
769       break;
770     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
771       format = kFormatYCbCr420SPVenusUbwc;
772       break;
773     case HAL_PIXEL_FORMAT_YV12:
774       format = kFormatYCrCb420PlanarStride16;
775       break;
776     case HAL_PIXEL_FORMAT_YCrCb_420_SP:
777     case HAL_PIXEL_FORMAT_NV21_ZSL:
778       format = kFormatYCrCb420SemiPlanar;
779       break;
780     case HAL_PIXEL_FORMAT_YCbCr_420_SP:
781       format = kFormatYCbCr420SemiPlanar;
782       break;
783     case HAL_PIXEL_FORMAT_YCbCr_422_SP:
784       format = kFormatYCbCr422H2V1SemiPlanar;
785       break;
786     case HAL_PIXEL_FORMAT_YCbCr_422_I:
787       format = kFormatYCbCr422H2V1Packed;
788       break;
789     case HAL_PIXEL_FORMAT_CbYCrY_422_I:
790       format = kFormatCbYCrY422H2V1Packed;
791       break;
792     case HAL_PIXEL_FORMAT_RGBA_1010102:
793       format = kFormatRGBA1010102;
794       break;
795     case HAL_PIXEL_FORMAT_ARGB_2101010:
796       format = kFormatARGB2101010;
797       break;
798     case HAL_PIXEL_FORMAT_RGBX_1010102:
799       format = kFormatRGBX1010102;
800       break;
801     case HAL_PIXEL_FORMAT_XRGB_2101010:
802       format = kFormatXRGB2101010;
803       break;
804     case HAL_PIXEL_FORMAT_BGRA_1010102:
805       format = kFormatBGRA1010102;
806       break;
807     case HAL_PIXEL_FORMAT_ABGR_2101010:
808       format = kFormatABGR2101010;
809       break;
810     case HAL_PIXEL_FORMAT_BGRX_1010102:
811       format = kFormatBGRX1010102;
812       break;
813     case HAL_PIXEL_FORMAT_XBGR_2101010:
814       format = kFormatXBGR2101010;
815       break;
816     case HAL_PIXEL_FORMAT_YCbCr_420_P010:
817       format = kFormatYCbCr420P010;
818       break;
819     case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
820       format = kFormatYCbCr420TP10Ubwc;
821       break;
822     case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
823       format = kFormatYCbCr420P010Ubwc;
824       break;
825     case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
826       format = kFormatYCbCr420P010Venus;
827       break;
828     case HAL_PIXEL_FORMAT_RGBA_FP16:
829       format = kFormatInvalid;
830       break;
831     default:
832       DLOGW("Unsupported format type = %s", qdutils::GetHALPixelFormatString(source));
833       return kFormatInvalid;
834   }
835 
836   return format;
837 }
838 
GetUBWCStatsFromMetaData(UBWCStats * cr_stats,UbwcCrStatsVector * cr_vec)839 void HWCLayer::GetUBWCStatsFromMetaData(UBWCStats *cr_stats, UbwcCrStatsVector *cr_vec) {
840   // TODO(user): Check if we can use UBWCStats directly
841   // in layer_buffer or copy directly to Vector
842   if (cr_stats->bDataValid) {
843     switch (cr_stats->version) {
844       case UBWC_4_0:
845       case UBWC_3_0:
846       case UBWC_2_0:
847         cr_vec->push_back(std::make_pair(32, cr_stats->ubwc_stats.nCRStatsTile32));
848         cr_vec->push_back(std::make_pair(64, cr_stats->ubwc_stats.nCRStatsTile64));
849         cr_vec->push_back(std::make_pair(96, cr_stats->ubwc_stats.nCRStatsTile96));
850         cr_vec->push_back(std::make_pair(128, cr_stats->ubwc_stats.nCRStatsTile128));
851         cr_vec->push_back(std::make_pair(160, cr_stats->ubwc_stats.nCRStatsTile160));
852         cr_vec->push_back(std::make_pair(192, cr_stats->ubwc_stats.nCRStatsTile192));
853         cr_vec->push_back(std::make_pair(256, cr_stats->ubwc_stats.nCRStatsTile256));
854         break;
855       default:
856         DLOGW("Invalid UBWC Version %d", cr_stats->version);
857         break;
858     }  // switch(cr_stats->version)
859   }  // if (cr_stats->bDatvalid)
860 }
861 
SetMetaData(const private_handle_t * pvt_handle,Layer * layer)862 DisplayError HWCLayer::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) {
863   LayerBuffer *layer_buffer = &layer->input_buffer;
864   private_handle_t *handle = const_cast<private_handle_t *>(pvt_handle);
865 
866   float fps = 0;
867   uint32_t frame_rate = layer->frame_rate;
868   if (getMetaData(handle, GET_REFRESH_RATE, &fps) == 0) {
869     frame_rate = (fps != 0) ? RoundToStandardFPS(fps) : layer->frame_rate;
870     has_metadata_refresh_rate_ = true;
871   }
872 
873   int32_t interlaced = 0;
874   getMetaData(handle, GET_PP_PARAM_INTERLACED, &interlaced);
875   bool interlace = interlaced ? true : false;
876 
877   if (interlace != layer_buffer->flags.interlace) {
878     DLOGI("Layer buffer interlaced metadata has changed. old=%d, new=%d",
879           layer_buffer->flags.interlace, interlace);
880   }
881 
882   uint32_t linear_format = 0;
883   if (getMetaData(handle, GET_LINEAR_FORMAT, &linear_format) == 0) {
884     layer_buffer->format = GetSDMFormat(INT32(linear_format), 0);
885   }
886 
887   if ((interlace != layer_buffer->flags.interlace) || (frame_rate != layer->frame_rate)) {
888     // Layer buffer metadata has changed.
889     layer->frame_rate = frame_rate;
890     layer_buffer->flags.interlace = interlace;
891     layer_->update_mask.set(kMetadataUpdate);
892   }
893 
894   // Check if metadata is set
895   struct UBWCStats cr_stats[NUM_UBWC_CR_STATS_LAYERS] = {};
896 
897   for (int i = 0; i < NUM_UBWC_CR_STATS_LAYERS; i++) {
898     layer_buffer->ubwc_crstats[i].clear();
899   }
900 
901   if (getMetaData(handle, GET_UBWC_CR_STATS_INFO, cr_stats) == 0) {
902   // Only copy top layer for now as only top field for interlaced is used
903     GetUBWCStatsFromMetaData(&cr_stats[0], &(layer_buffer->ubwc_crstats[0]));
904   }  // if (getMetaData)
905 
906   uint32_t single_buffer = 0;
907   getMetaData(const_cast<private_handle_t *>(handle), GET_SINGLE_BUFFER_MODE, &single_buffer);
908   single_buffer_ = (single_buffer == 1);
909 
910   // Handle colorMetaData / Dataspace handling now
911   ValidateAndSetCSC(handle);
912 
913   return kErrorNone;
914 }
915 
IsDataSpaceSupported()916 bool HWCLayer::IsDataSpaceSupported() {
917   if (client_requested_ != HWC2::Composition::Device &&
918       client_requested_ != HWC2::Composition::Cursor) {
919     // Layers marked for GPU can have any dataspace
920     return true;
921   }
922 
923   return dataspace_supported_;
924 }
925 
ValidateAndSetCSC(const private_handle_t * handle)926 void HWCLayer::ValidateAndSetCSC(const private_handle_t *handle) {
927   LayerBuffer *layer_buffer = &layer_->input_buffer;
928   bool use_color_metadata = true;
929   ColorMetaData csc = {};
930   if (dataspace_ != HAL_DATASPACE_UNKNOWN) {
931     use_color_metadata = false;
932     bool valid_csc = GetSDMColorSpace(dataspace_, &csc);
933     if (!valid_csc) {
934       dataspace_supported_ = false;
935       return;
936     }
937 
938     if (layer_buffer->color_metadata.transfer != csc.transfer ||
939        layer_buffer->color_metadata.colorPrimaries != csc.colorPrimaries ||
940        layer_buffer->color_metadata.range != csc.range) {
941         // ColorMetadata updated. Needs validate.
942         layer_->update_mask.set(kMetadataUpdate);
943         // if we are here here, update the sdm layer csc.
944         layer_buffer->color_metadata.transfer = csc.transfer;
945         layer_buffer->color_metadata.colorPrimaries = csc.colorPrimaries;
946         layer_buffer->color_metadata.range = csc.range;
947     }
948   }
949 
950   if (IsBT2020(layer_buffer->color_metadata.colorPrimaries)) {
951      // android_dataspace_t doesnt support mastering display and light levels
952      // so retrieve it from metadata for BT2020(HDR)
953      use_color_metadata = true;
954   }
955 
956   if (use_color_metadata) {
957     ColorMetaData new_metadata = layer_buffer->color_metadata;
958     if (sdm::SetCSC(handle, &new_metadata) == kErrorNone) {
959       // If dataspace is KNOWN, overwrite the gralloc metadata CSC using the previously derived CSC
960       // from dataspace.
961       if (dataspace_ != HAL_DATASPACE_UNKNOWN) {
962         new_metadata.colorPrimaries = layer_buffer->color_metadata.colorPrimaries;
963         new_metadata.transfer = layer_buffer->color_metadata.transfer;
964         new_metadata.range = layer_buffer->color_metadata.range;
965       }
966       if ((layer_buffer->color_metadata.colorPrimaries != new_metadata.colorPrimaries) ||
967           (layer_buffer->color_metadata.transfer != new_metadata.transfer) ||
968           (layer_buffer->color_metadata.range != new_metadata.range)) {
969         layer_buffer->color_metadata.colorPrimaries = new_metadata.colorPrimaries;
970         layer_buffer->color_metadata.transfer = new_metadata.transfer;
971         layer_buffer->color_metadata.range = new_metadata.range;
972         layer_->update_mask.set(kMetadataUpdate);
973       }
974       if (layer_buffer->color_metadata.matrixCoefficients != new_metadata.matrixCoefficients) {
975         layer_buffer->color_metadata.matrixCoefficients = new_metadata.matrixCoefficients;
976         layer_->update_mask.set(kMetadataUpdate);
977       }
978       DLOGV_IF(kTagClient, "Layer id = %" PRIu64 " ColorVolEnabled = %d ContentLightLevelEnabled = %d "
979                "cRIEnabled = %d Dynamic Metadata valid = %d size = %d", id_,
980                new_metadata.masteringDisplayInfo.colorVolumeSEIEnabled,
981                new_metadata.contentLightLevel.lightLevelSEIEnabled,
982                new_metadata.cRI.criEnabled, new_metadata.dynamicMetaDataValid,
983                new_metadata.dynamicMetaDataLen);
984       // Read color metadata from gralloc handle if it's enabled by clients, this will override the
985       // values set using the Composer API's(SetLayerPerFrameMetaData)
986       if (new_metadata.masteringDisplayInfo.colorVolumeSEIEnabled &&
987           !SameConfig(&new_metadata.masteringDisplayInfo,
988           &layer_buffer->color_metadata.masteringDisplayInfo, UINT32(sizeof(MasteringDisplay)))) {
989         layer_buffer->color_metadata.masteringDisplayInfo = new_metadata.masteringDisplayInfo;
990         layer_->update_mask.set(kMetadataUpdate);
991       }
992       if (new_metadata.contentLightLevel.lightLevelSEIEnabled &&
993           !SameConfig(&new_metadata.contentLightLevel,
994           &layer_buffer->color_metadata.contentLightLevel, UINT32(sizeof(ContentLightLevel)))) {
995         layer_buffer->color_metadata.contentLightLevel = new_metadata.contentLightLevel;
996         layer_->update_mask.set(kMetadataUpdate);
997       }
998       if (new_metadata.cRI.criEnabled &&
999           !SameConfig(&new_metadata.cRI, &layer_buffer->color_metadata.cRI,
1000           UINT32(sizeof(ColorRemappingInfo)))) {
1001         layer_buffer->color_metadata.cRI = new_metadata.cRI;
1002         layer_->update_mask.set(kMetadataUpdate);
1003       }
1004       if (new_metadata.dynamicMetaDataValid &&
1005           !SameConfig(layer_buffer->color_metadata.dynamicMetaDataPayload,
1006           new_metadata.dynamicMetaDataPayload, HDR_DYNAMIC_META_DATA_SZ)) {
1007           layer_buffer->color_metadata.dynamicMetaDataValid = true;
1008           layer_buffer->color_metadata.dynamicMetaDataLen = new_metadata.dynamicMetaDataLen;
1009           std::memcpy(layer_buffer->color_metadata.dynamicMetaDataPayload,
1010                       new_metadata.dynamicMetaDataPayload, new_metadata.dynamicMetaDataLen);
1011         layer_->update_mask.set(kMetadataUpdate);
1012       }
1013     } else {
1014       dataspace_supported_ = false;
1015       return;
1016     }
1017   }
1018 
1019   dataspace_supported_ = true;
1020 }
1021 
1022 
RoundToStandardFPS(float fps)1023 uint32_t HWCLayer::RoundToStandardFPS(float fps) {
1024   static const int32_t standard_fps[4] = {24, 30, 48, 60};
1025   int32_t frame_rate = (uint32_t)(fps);
1026 
1027   int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
1028   for (int i = 0; i < count; i++) {
1029     if ((standard_fps[i] - frame_rate) < 2) {
1030       // Most likely used for video, the fps can fluctuate
1031       // Ex: b/w 29 and 30 for 30 fps clip
1032       return standard_fps[i];
1033     }
1034   }
1035 
1036   return frame_rate;
1037 }
1038 
SetComposition(const LayerComposition & sdm_composition)1039 void HWCLayer::SetComposition(const LayerComposition &sdm_composition) {
1040   auto hwc_composition = HWC2::Composition::Invalid;
1041   switch (sdm_composition) {
1042     case kCompositionGPU:
1043       hwc_composition = HWC2::Composition::Client;
1044       break;
1045     case kCompositionCursor:
1046       hwc_composition = HWC2::Composition::Cursor;
1047       break;
1048     default:
1049       hwc_composition = HWC2::Composition::Device;
1050       break;
1051   }
1052   // Update solid fill composition
1053   if (sdm_composition == kCompositionSDE && layer_->flags.solid_fill != 0) {
1054     hwc_composition = HWC2::Composition::SolidColor;
1055   }
1056   device_selected_ = hwc_composition;
1057 
1058   return;
1059 }
1060 
PushBackReleaseFence(const shared_ptr<Fence> & fence)1061 void HWCLayer::PushBackReleaseFence(const shared_ptr<Fence> &fence) {
1062   release_fences_.push_back(fence);
1063 }
1064 
PopBackReleaseFence(shared_ptr<Fence> * fence)1065 void HWCLayer::PopBackReleaseFence(shared_ptr<Fence> *fence) {
1066   if (release_fences_.empty()) {
1067     return;
1068   }
1069 
1070   *fence = release_fences_.back();
1071   release_fences_.pop_back();
1072 }
1073 
PopFrontReleaseFence(shared_ptr<Fence> * fence)1074 void HWCLayer::PopFrontReleaseFence(shared_ptr<Fence> *fence) {
1075   if (release_fences_.empty()) {
1076     return;
1077   }
1078 
1079   *fence = release_fences_.front();
1080   release_fences_.pop_front();
1081 }
1082 
IsRotationPresent()1083 bool HWCLayer::IsRotationPresent() {
1084   return ((layer_->transform.rotation != 0.0f) ||
1085          layer_->transform.flip_horizontal ||
1086          layer_->transform.flip_vertical);
1087 }
1088 
IsScalingPresent()1089 bool HWCLayer::IsScalingPresent() {
1090   uint32_t src_width  = static_cast<uint32_t>(layer_->src_rect.right - layer_->src_rect.left);
1091   uint32_t src_height = static_cast<uint32_t>(layer_->src_rect.bottom - layer_->src_rect.top);
1092   uint32_t dst_width  = static_cast<uint32_t>(layer_->dst_rect.right - layer_->dst_rect.left);
1093   uint32_t dst_height = static_cast<uint32_t>(layer_->dst_rect.bottom - layer_->dst_rect.top);
1094 
1095   if ((layer_->transform.rotation == 90.0) || (layer_->transform.rotation == 270.0)) {
1096     std::swap(src_width, src_height);
1097   }
1098 
1099   return ((src_width != dst_width) || (dst_height != src_height));
1100 }
1101 
SetDirtyRegions(hwc_region_t surface_damage)1102 void HWCLayer::SetDirtyRegions(hwc_region_t surface_damage) {
1103   layer_->dirty_regions.clear();
1104   for (uint32_t i = 0; i < surface_damage.numRects; i++) {
1105     LayerRect rect;
1106     SetRect(surface_damage.rects[i], &rect);
1107     layer_->dirty_regions.push_back(rect);
1108   }
1109 }
1110 
SetLayerAsMask()1111 void HWCLayer::SetLayerAsMask() {
1112   layer_->input_buffer.flags.mask_layer = true;
1113   DLOGV_IF(kTagClient, " Layer Id: ""[%" PRIu64 "]", id_);
1114 }
1115 
1116 }  // namespace sdm
1117