1/*
2 * Copyright (c) 2014-2017, 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 <stdint.h>
21#include <qdMetaData.h>
22
23#include "hwc_layers.h"
24#ifndef USE_GRALLOC1
25#include <gr.h>
26#endif
27#include <utils/debug.h>
28#include <cmath>
29
30#define __CLASS__ "HWCLayer"
31
32namespace sdm {
33
34std::atomic<hwc2_layer_t> HWCLayer::next_id_(1);
35
36DisplayError SetCSC(const private_handle_t *pvt_handle, ColorMetaData *color_metadata) {
37  if (getMetaData(const_cast<private_handle_t *>(pvt_handle), GET_COLOR_METADATA,
38                  color_metadata) != 0) {
39    ColorSpace_t csc = ITU_R_601;
40    if (getMetaData(const_cast<private_handle_t *>(pvt_handle),  GET_COLOR_SPACE,
41                    &csc) == 0) {
42      if (csc == ITU_R_601_FR || csc == ITU_R_2020_FR) {
43        color_metadata->range = Range_Full;
44      }
45
46      switch (csc) {
47      case ITU_R_601:
48      case ITU_R_601_FR:
49        // video and display driver uses 601_525
50        color_metadata->colorPrimaries = ColorPrimaries_BT601_6_525;
51        break;
52      case ITU_R_709:
53        color_metadata->colorPrimaries = ColorPrimaries_BT709_5;
54        break;
55      case ITU_R_2020:
56      case ITU_R_2020_FR:
57        color_metadata->colorPrimaries = ColorPrimaries_BT2020;
58        break;
59      default:
60        DLOGE("Unsupported CSC: %d", csc);
61        return kErrorNotSupported;
62      }
63    } else {
64      return kErrorNotSupported;
65    }
66  }
67
68  return kErrorNone;
69}
70
71// Returns true when color primary is supported
72bool GetColorPrimary(const int32_t &dataspace, ColorPrimaries *color_primary) {
73  auto standard = dataspace & HAL_DATASPACE_STANDARD_MASK;
74  bool supported_csc = true;
75  switch (standard) {
76    case  HAL_DATASPACE_STANDARD_BT709:
77      *color_primary = ColorPrimaries_BT709_5;
78      break;
79    case HAL_DATASPACE_STANDARD_BT601_525:
80    case HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED:
81      *color_primary = ColorPrimaries_BT601_6_525;
82      break;
83    case HAL_DATASPACE_STANDARD_BT601_625:
84    case HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED:
85      *color_primary = ColorPrimaries_BT601_6_625;
86      break;
87    case HAL_DATASPACE_STANDARD_DCI_P3:
88      *color_primary = ColorPrimaries_DCIP3;
89      break;
90    case HAL_DATASPACE_STANDARD_BT2020:
91      *color_primary = ColorPrimaries_BT2020;
92      break;
93    default:
94      DLOGV_IF(kTagStrategy, "Unsupported Standard Request = %d", standard);
95      supported_csc = false;
96  }
97  return supported_csc;
98}
99
100bool GetTransfer(const int32_t &dataspace, GammaTransfer *gamma_transfer) {
101  auto transfer = dataspace & HAL_DATASPACE_TRANSFER_MASK;
102  bool supported_transfer = true;
103  switch (transfer) {
104    case HAL_DATASPACE_TRANSFER_SRGB:
105      *gamma_transfer = Transfer_sRGB;
106      break;
107    case HAL_DATASPACE_TRANSFER_SMPTE_170M:
108      *gamma_transfer = Transfer_SMPTE_170M;
109      break;
110    case HAL_DATASPACE_TRANSFER_ST2084:
111      *gamma_transfer = Transfer_SMPTE_ST2084;
112      break;
113    case HAL_DATASPACE_TRANSFER_HLG:
114      *gamma_transfer = Transfer_HLG;
115      break;
116    case HAL_DATASPACE_TRANSFER_LINEAR:
117      *gamma_transfer = Transfer_Linear;
118      break;
119    case HAL_DATASPACE_TRANSFER_GAMMA2_2:
120      *gamma_transfer = Transfer_Gamma2_2;
121      break;
122    case HAL_DATASPACE_TRANSFER_GAMMA2_8:
123      *gamma_transfer = Transfer_Gamma2_8;
124      break;
125    default:
126      DLOGE("Unsupported Transfer Request = %d", transfer);
127      supported_transfer = false;
128  }
129  return supported_transfer;
130}
131
132void GetRange(const int32_t &dataspace, ColorRange *color_range) {
133  auto range = dataspace & HAL_DATASPACE_RANGE_MASK;
134  switch (range) {
135    case HAL_DATASPACE_RANGE_FULL:
136      *color_range = Range_Full;
137      break;
138    case HAL_DATASPACE_RANGE_LIMITED:
139      *color_range = Range_Limited;
140      break;
141    default:
142      DLOGV_IF(kTagStrategy, "Unsupported Range Request = %d", range);
143      break;
144  }
145}
146
147bool IsBT2020(const ColorPrimaries &color_primary) {
148  switch (color_primary) {
149  case ColorPrimaries_BT2020:
150    return true;
151    break;
152  default:
153    return false;
154  }
155}
156
157// Retrieve ColorMetaData from android_data_space_t (STANDARD|TRANSFER|RANGE)
158bool GetSDMColorSpace(const int32_t &dataspace, ColorMetaData *color_metadata) {
159  bool valid = false;
160  valid = GetColorPrimary(dataspace, &(color_metadata->colorPrimaries));
161  if (!valid) {
162    return valid;
163  }
164  valid = GetTransfer(dataspace, &(color_metadata->transfer));
165  if (!valid) {
166    return valid;
167  }
168  GetRange(dataspace, &(color_metadata->range));
169
170  return true;
171}
172
173// Layer operations
174HWCLayer::HWCLayer(hwc2_display_t display_id, HWCBufferAllocator *buf_allocator)
175  : id_(next_id_++), display_id_(display_id), buffer_allocator_(buf_allocator) {
176  layer_ = new Layer();
177  // Fences are deferred, so the first time this layer is presented, return -1
178  // TODO(user): Verify that fences are properly obtained on suspend/resume
179  release_fences_.push(-1);
180}
181
182HWCLayer::~HWCLayer() {
183  // Close any fences left for this layer
184  while (!release_fences_.empty()) {
185    close(release_fences_.front());
186    release_fences_.pop();
187  }
188  close(ion_fd_);
189  if (layer_) {
190    delete layer_;
191  }
192}
193
194HWC2::Error HWCLayer::SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence) {
195  if (!buffer) {
196    if (client_requested_ == HWC2::Composition::Device ||
197        client_requested_ == HWC2::Composition::Cursor) {
198      DLOGE("Invalid buffer handle: %p on layer: %d", buffer, id_);
199      return HWC2::Error::BadParameter;
200    } else {
201      return HWC2::Error::None;
202    }
203  }
204
205  if (acquire_fence == 0) {
206    DLOGE("acquire_fence is zero");
207    return HWC2::Error::BadParameter;
208  }
209
210  const private_handle_t *handle = static_cast<const private_handle_t *>(buffer);
211
212  // Validate and dup ion fd from surfaceflinger
213  // This works around bug 30281222
214  if (handle->fd < 0) {
215    return HWC2::Error::BadParameter;
216  } else {
217    close(ion_fd_);
218    ion_fd_ = dup(handle->fd);
219  }
220
221  LayerBuffer *layer_buffer = &layer_->input_buffer;
222  int aligned_width, aligned_height;
223#ifdef USE_GRALLOC1
224  buffer_allocator_->GetCustomWidthAndHeight(handle, &aligned_width, &aligned_height);
225#else
226  AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(handle, aligned_width, aligned_height);
227#endif
228
229  LayerBufferFormat format = GetSDMFormat(handle->format, handle->flags);
230  if ((format != layer_buffer->format) || (UINT32(aligned_width) != layer_buffer->width) ||
231      (UINT32(aligned_height) != layer_buffer->height)) {
232    // Layer buffer geometry has changed.
233    geometry_changes_ |= kBufferGeometry;
234  }
235
236  layer_buffer->format = format;
237  layer_buffer->width = UINT32(aligned_width);
238  layer_buffer->height = UINT32(aligned_height);
239  layer_buffer->unaligned_width = UINT32(handle->unaligned_width);
240  layer_buffer->unaligned_height = UINT32(handle->unaligned_height);
241
242  if (SetMetaData(const_cast<private_handle_t *>(handle), layer_) != kErrorNone) {
243    return HWC2::Error::BadLayer;
244  }
245
246  layer_buffer->flags.video = (handle->buffer_type == BUFFER_TYPE_VIDEO) ? true : false;
247
248  // TZ Protected Buffer - L1
249  bool secure = (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER);
250  bool secure_camera = secure && (handle->flags & private_handle_t::PRIV_FLAGS_CAMERA_WRITE);
251  bool secure_display = (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY);
252  if (secure != layer_buffer->flags.secure || secure_camera != layer_buffer->flags.secure_camera ||
253      secure_display != layer_buffer->flags.secure_display) {
254    // Secure attribute of layer buffer has changed.
255    needs_validate_ = true;
256  }
257
258  layer_buffer->flags.secure = secure;
259  layer_buffer->flags.secure_camera = secure_camera;
260  layer_buffer->flags.secure_display = secure_display;
261
262  if (layer_buffer->acquire_fence_fd >= 0) {
263    close(layer_buffer->acquire_fence_fd);
264  }
265  layer_buffer->acquire_fence_fd = acquire_fence;
266  layer_buffer->planes[0].fd = ion_fd_;
267  layer_buffer->planes[0].offset = handle->offset;
268  layer_buffer->planes[0].stride = UINT32(handle->width);
269  layer_buffer->size = handle->size;
270  layer_buffer->buffer_id = reinterpret_cast<uint64_t>(handle);
271  layer_buffer->fb_id = 0;
272
273  return HWC2::Error::None;
274}
275
276HWC2::Error HWCLayer::SetLayerSurfaceDamage(hwc_region_t damage) {
277  // Check if there is an update in SurfaceDamage rects
278  if (layer_->dirty_regions.size() != damage.numRects) {
279    needs_validate_ = true;
280  } else {
281    for (uint32_t j = 0; j < damage.numRects; j++) {
282      LayerRect damage_rect;
283      SetRect(damage.rects[j], &damage_rect);
284      if (damage_rect != layer_->dirty_regions.at(j)) {
285        needs_validate_ = true;
286        break;
287      }
288    }
289  }
290
291  layer_->dirty_regions.clear();
292  for (uint32_t i = 0; i < damage.numRects; i++) {
293    LayerRect rect;
294    SetRect(damage.rects[i], &rect);
295    layer_->dirty_regions.push_back(rect);
296  }
297  return HWC2::Error::None;
298}
299
300HWC2::Error HWCLayer::SetLayerBlendMode(HWC2::BlendMode mode) {
301  LayerBlending blending = kBlendingPremultiplied;
302  switch (mode) {
303    case HWC2::BlendMode::Coverage:
304      blending = kBlendingCoverage;
305      break;
306    case HWC2::BlendMode::Premultiplied:
307      blending = kBlendingPremultiplied;
308      break;
309    case HWC2::BlendMode::None:
310      blending = kBlendingOpaque;
311      break;
312    default:
313      return HWC2::Error::BadParameter;
314  }
315
316  if (layer_->blending != blending) {
317    geometry_changes_ |= kBlendMode;
318    layer_->blending = blending;
319  }
320  return HWC2::Error::None;
321}
322
323HWC2::Error HWCLayer::SetLayerColor(hwc_color_t color) {
324  if (client_requested_ != HWC2::Composition::SolidColor) {
325    return HWC2::Error::None;
326  }
327  layer_->solid_fill_color = GetUint32Color(color);
328  layer_->input_buffer.format = kFormatARGB8888;
329  DLOGV_IF(kTagCompManager, "[%" PRIu64 "][%" PRIu64 "] Layer color set to %x", display_id_, id_,
330           layer_->solid_fill_color);
331  return HWC2::Error::None;
332}
333
334HWC2::Error HWCLayer::SetLayerCompositionType(HWC2::Composition type) {
335  // Validation is required when the client changes the composition type
336  if (client_requested_ != type) {
337    needs_validate_ = true;
338  }
339  client_requested_ = type;
340  switch (type) {
341    case HWC2::Composition::Client:
342      break;
343    case HWC2::Composition::Device:
344      // We try and default to this in SDM
345      break;
346    case HWC2::Composition::SolidColor:
347      break;
348    case HWC2::Composition::Cursor:
349      break;
350    case HWC2::Composition::Invalid:
351      return HWC2::Error::BadParameter;
352    default:
353      return HWC2::Error::Unsupported;
354  }
355
356  return HWC2::Error::None;
357}
358
359HWC2::Error HWCLayer::SetLayerDataspace(int32_t dataspace) {
360  // Map deprecated dataspace values to appropriate
361  // new enums
362  if (dataspace & 0xffff) {
363    switch (dataspace & 0xffff) {
364      case HAL_DATASPACE_SRGB:
365        dataspace = HAL_DATASPACE_V0_SRGB;
366        break;
367      case HAL_DATASPACE_JFIF:
368        dataspace = HAL_DATASPACE_V0_JFIF;
369        break;
370      case HAL_DATASPACE_SRGB_LINEAR:
371        dataspace = HAL_DATASPACE_V0_SRGB_LINEAR;
372        break;
373      case HAL_DATASPACE_BT601_625:
374        dataspace = HAL_DATASPACE_V0_BT601_625;
375        break;
376      case HAL_DATASPACE_BT601_525:
377        dataspace = HAL_DATASPACE_V0_BT601_525;
378        break;
379      case HAL_DATASPACE_BT709:
380        dataspace = HAL_DATASPACE_V0_BT709;
381        break;
382      default:
383        // unknown legacy dataspace
384        DLOGW_IF(kTagQDCM, "Unsupported dataspace type %d", dataspace);
385    }
386  }
387
388  // cache the dataspace, to be used later to update SDM ColorMetaData
389  if (dataspace_ != dataspace) {
390    geometry_changes_ |= kDataspace;
391    dataspace_ = dataspace;
392  }
393  return HWC2::Error::None;
394}
395
396HWC2::Error HWCLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
397  LayerRect dst_rect = {};
398  SetRect(frame, &dst_rect);
399  if (layer_->dst_rect != dst_rect) {
400    geometry_changes_ |= kDisplayFrame;
401    layer_->dst_rect = dst_rect;
402  }
403  return HWC2::Error::None;
404}
405
406HWC2::Error HWCLayer::SetLayerPlaneAlpha(float alpha) {
407  // Conversion of float alpha in range 0.0 to 1.0 similar to the HWC Adapter
408  uint8_t plane_alpha = static_cast<uint8_t>(std::round(255.0f * alpha));
409  if (layer_->plane_alpha != plane_alpha) {
410    geometry_changes_ |= kPlaneAlpha;
411    layer_->plane_alpha = plane_alpha;
412  }
413
414  return HWC2::Error::None;
415}
416
417HWC2::Error HWCLayer::SetLayerSourceCrop(hwc_frect_t crop) {
418  LayerRect src_rect = {};
419  SetRect(crop, &src_rect);
420  if (layer_->src_rect != src_rect) {
421    geometry_changes_ |= kSourceCrop;
422    layer_->src_rect = src_rect;
423  }
424
425  return HWC2::Error::None;
426}
427
428HWC2::Error HWCLayer::SetLayerTransform(HWC2::Transform transform) {
429  LayerTransform layer_transform = {};
430  switch (transform) {
431    case HWC2::Transform::FlipH:
432      layer_transform.flip_horizontal = true;
433      break;
434    case HWC2::Transform::FlipV:
435      layer_transform.flip_vertical = true;
436      break;
437    case HWC2::Transform::Rotate90:
438      layer_transform.rotation = 90.0f;
439      break;
440    case HWC2::Transform::Rotate180:
441      layer_transform.flip_horizontal = true;
442      layer_transform.flip_vertical = true;
443      break;
444    case HWC2::Transform::Rotate270:
445      layer_transform.rotation = 90.0f;
446      layer_transform.flip_horizontal = true;
447      layer_transform.flip_vertical = true;
448      break;
449    case HWC2::Transform::FlipHRotate90:
450      layer_transform.rotation = 90.0f;
451      layer_transform.flip_horizontal = true;
452      break;
453    case HWC2::Transform::FlipVRotate90:
454      layer_transform.rotation = 90.0f;
455      layer_transform.flip_vertical = true;
456      break;
457    case HWC2::Transform::None:
458      // do nothing
459      break;
460  }
461
462  if (layer_->transform != layer_transform) {
463    geometry_changes_ |= kTransform;
464    layer_->transform = layer_transform;
465  }
466  return HWC2::Error::None;
467}
468
469HWC2::Error HWCLayer::SetLayerVisibleRegion(hwc_region_t visible) {
470  layer_->visible_regions.clear();
471  for (uint32_t i = 0; i < visible.numRects; i++) {
472    LayerRect rect;
473    SetRect(visible.rects[i], &rect);
474    layer_->visible_regions.push_back(rect);
475  }
476
477  return HWC2::Error::None;
478}
479
480HWC2::Error HWCLayer::SetLayerZOrder(uint32_t z) {
481  if (z_ != z) {
482    geometry_changes_ |= kZOrder;
483    z_ = z;
484  }
485  return HWC2::Error::None;
486}
487
488void HWCLayer::SetRect(const hwc_rect_t &source, LayerRect *target) {
489  target->left = FLOAT(source.left);
490  target->top = FLOAT(source.top);
491  target->right = FLOAT(source.right);
492  target->bottom = FLOAT(source.bottom);
493}
494
495void HWCLayer::SetRect(const hwc_frect_t &source, LayerRect *target) {
496  // Recommended way of rounding as in hwcomposer2.h - SetLayerSourceCrop
497  target->left = std::ceil(source.left);
498  target->top = std::ceil(source.top);
499  target->right = std::floor(source.right);
500  target->bottom = std::floor(source.bottom);
501}
502
503uint32_t HWCLayer::GetUint32Color(const hwc_color_t &source) {
504  // Returns 32 bit ARGB
505  uint32_t a = UINT32(source.a) << 24;
506  uint32_t r = UINT32(source.r) << 16;
507  uint32_t g = UINT32(source.g) << 8;
508  uint32_t b = UINT32(source.b);
509  uint32_t color = a | r | g | b;
510  return color;
511}
512
513LayerBufferFormat HWCLayer::GetSDMFormat(const int32_t &source, const int flags) {
514  LayerBufferFormat format = kFormatInvalid;
515  if (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
516    switch (source) {
517      case HAL_PIXEL_FORMAT_RGBA_8888:
518        format = kFormatRGBA8888Ubwc;
519        break;
520      case HAL_PIXEL_FORMAT_RGBX_8888:
521        format = kFormatRGBX8888Ubwc;
522        break;
523      case HAL_PIXEL_FORMAT_BGR_565:
524        format = kFormatBGR565Ubwc;
525        break;
526      case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
527      case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
528      case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
529        format = kFormatYCbCr420SPVenusUbwc;
530        break;
531      case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
532        format = kFormatYCbCr420TP10Ubwc;
533        break;
534      default:
535        DLOGE("Unsupported format type for UBWC %d", source);
536        return kFormatInvalid;
537    }
538    return format;
539  }
540
541  switch (source) {
542    case HAL_PIXEL_FORMAT_RGBA_8888:
543      format = kFormatRGBA8888;
544      break;
545    case HAL_PIXEL_FORMAT_RGBA_5551:
546      format = kFormatRGBA5551;
547      break;
548    case HAL_PIXEL_FORMAT_RGBA_4444:
549      format = kFormatRGBA4444;
550      break;
551    case HAL_PIXEL_FORMAT_BGRA_8888:
552      format = kFormatBGRA8888;
553      break;
554    case HAL_PIXEL_FORMAT_RGBX_8888:
555      format = kFormatRGBX8888;
556      break;
557    case HAL_PIXEL_FORMAT_BGRX_8888:
558      format = kFormatBGRX8888;
559      break;
560    case HAL_PIXEL_FORMAT_RGB_888:
561      format = kFormatRGB888;
562      break;
563    case HAL_PIXEL_FORMAT_RGB_565:
564      format = kFormatRGB565;
565      break;
566    case HAL_PIXEL_FORMAT_BGR_565:
567      format = kFormatBGR565;
568      break;
569    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
570    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
571      format = kFormatYCbCr420SemiPlanarVenus;
572      break;
573    case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
574      format = kFormatYCrCb420SemiPlanarVenus;
575      break;
576    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
577      format = kFormatYCbCr420SPVenusUbwc;
578      break;
579    case HAL_PIXEL_FORMAT_YV12:
580      format = kFormatYCrCb420PlanarStride16;
581      break;
582    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
583      format = kFormatYCrCb420SemiPlanar;
584      break;
585    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
586      format = kFormatYCbCr420SemiPlanar;
587      break;
588    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
589      format = kFormatYCbCr422H2V1SemiPlanar;
590      break;
591    case HAL_PIXEL_FORMAT_YCbCr_422_I:
592      format = kFormatYCbCr422H2V1Packed;
593      break;
594    case HAL_PIXEL_FORMAT_RGBA_1010102:
595      format = kFormatRGBA1010102;
596      break;
597    case HAL_PIXEL_FORMAT_ARGB_2101010:
598      format = kFormatARGB2101010;
599      break;
600    case HAL_PIXEL_FORMAT_RGBX_1010102:
601      format = kFormatRGBX1010102;
602      break;
603    case HAL_PIXEL_FORMAT_XRGB_2101010:
604      format = kFormatXRGB2101010;
605      break;
606    case HAL_PIXEL_FORMAT_BGRA_1010102:
607      format = kFormatBGRA1010102;
608      break;
609    case HAL_PIXEL_FORMAT_ABGR_2101010:
610      format = kFormatABGR2101010;
611      break;
612    case HAL_PIXEL_FORMAT_BGRX_1010102:
613      format = kFormatBGRX1010102;
614      break;
615    case HAL_PIXEL_FORMAT_XBGR_2101010:
616      format = kFormatXBGR2101010;
617      break;
618    case HAL_PIXEL_FORMAT_YCbCr_420_P010:
619      format = kFormatYCbCr420P010;
620      break;
621    case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
622      format = kFormatYCbCr420TP10Ubwc;
623      break;
624    case HAL_PIXEL_FORMAT_RGBA_FP16:
625      format = kFormatInvalid;
626      break;
627    default:
628      DLOGW("Unsupported format type = %d", source);
629      return kFormatInvalid;
630  }
631
632  return format;
633}
634
635LayerBufferS3DFormat HWCLayer::GetS3DFormat(uint32_t s3d_format) {
636  LayerBufferS3DFormat sdm_s3d_format = kS3dFormatNone;
637  switch (s3d_format) {
638    case HAL_NO_3D:
639      sdm_s3d_format = kS3dFormatNone;
640      break;
641    case HAL_3D_SIDE_BY_SIDE_L_R:
642      sdm_s3d_format = kS3dFormatLeftRight;
643      break;
644    case HAL_3D_SIDE_BY_SIDE_R_L:
645      sdm_s3d_format = kS3dFormatRightLeft;
646      break;
647    case HAL_3D_TOP_BOTTOM:
648      sdm_s3d_format = kS3dFormatTopBottom;
649      break;
650    default:
651      DLOGW("Invalid S3D format %d", s3d_format);
652  }
653  return sdm_s3d_format;
654}
655
656DisplayError HWCLayer::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) {
657  LayerBuffer *layer_buffer = &layer->input_buffer;
658  private_handle_t *handle = const_cast<private_handle_t *>(pvt_handle);
659  IGC_t igc = {};
660  LayerIGC layer_igc = layer_buffer->igc;
661  if (getMetaData(handle, GET_IGC, &igc) == 0) {
662    if (SetIGC(igc, &layer_igc) != kErrorNone) {
663      return kErrorNotSupported;
664    }
665  }
666
667  uint32_t fps = 0;
668  uint32_t frame_rate = layer->frame_rate;
669  if (getMetaData(handle, GET_REFRESH_RATE, &fps) == 0) {
670    frame_rate = RoundToStandardFPS(fps);
671  }
672
673  int32_t interlaced = 0;
674  bool interlace = layer_buffer->flags.interlace;
675  if (getMetaData(handle, GET_PP_PARAM_INTERLACED, &interlaced) == 0) {
676    interlace = interlaced ? true : false;
677  }
678
679  uint32_t linear_format = 0;
680  if (getMetaData(handle, GET_LINEAR_FORMAT, &linear_format) == 0) {
681    layer_buffer->format = GetSDMFormat(INT32(linear_format), 0);
682  }
683
684  uint32_t s3d = 0;
685  LayerBufferS3DFormat s3d_format = layer_buffer->s3d_format;
686  if (getMetaData(handle, GET_S3D_FORMAT, &s3d) == 0) {
687    s3d_format = GetS3DFormat(s3d);
688  }
689
690  if ((layer_igc != layer_buffer->igc) || (interlace != layer_buffer->flags.interlace) ||
691      (frame_rate != layer->frame_rate) || (s3d_format != layer_buffer->s3d_format)) {
692    // Layer buffer metadata has changed.
693    needs_validate_ = true;
694    layer_buffer->igc = layer_igc;
695    layer->frame_rate = frame_rate;
696    layer_buffer->s3d_format = s3d_format;
697    layer_buffer->flags.interlace = interlace;
698  }
699
700  return kErrorNone;
701}
702
703DisplayError HWCLayer::SetIGC(IGC_t source, LayerIGC *target) {
704  switch (source) {
705    case IGC_NotSpecified:
706      *target = kIGCNotSpecified;
707      break;
708    case IGC_sRGB:
709      *target = kIGCsRGB;
710      break;
711    default:
712      DLOGE("Unsupported IGC: %d", source);
713      return kErrorNotSupported;
714  }
715
716  return kErrorNone;
717}
718
719
720
721bool HWCLayer::SupportLocalConversion(ColorPrimaries working_primaries) {
722  if (layer_->input_buffer.color_metadata.colorPrimaries <= ColorPrimaries_BT601_6_525 &&
723      working_primaries <= ColorPrimaries_BT601_6_525) {
724    return true;
725  }
726  return false;
727}
728
729bool HWCLayer::ValidateAndSetCSC() {
730  if (client_requested_ != HWC2::Composition::Device &&
731      client_requested_ != HWC2::Composition::Cursor) {
732    // Check the layers which are configured to Device
733    return true;
734  }
735
736  LayerBuffer *layer_buffer = &layer_->input_buffer;
737  bool use_color_metadata = true;
738#ifdef FEATURE_WIDE_COLOR
739  ColorMetaData csc = {};
740  if (dataspace_ != HAL_DATASPACE_UNKNOWN) {
741    use_color_metadata = false;
742    bool valid_csc = GetSDMColorSpace(dataspace_, &csc);
743    if (!valid_csc) {
744      return false;
745    }
746    // if we are here here, update the sdm layer csc.
747    layer_buffer->color_metadata.transfer = csc.transfer;
748    layer_buffer->color_metadata.colorPrimaries = csc.colorPrimaries;
749    layer_buffer->color_metadata.range = csc.range;
750  }
751#endif
752
753  if (IsBT2020(layer_buffer->color_metadata.colorPrimaries)) {
754     // android_dataspace_t doesnt support mastering display and light levels
755     // so retrieve it from metadata for BT2020(HDR)
756     use_color_metadata = true;
757  }
758
759  if (use_color_metadata) {
760    const private_handle_t *handle =
761      reinterpret_cast<const private_handle_t *>(layer_buffer->buffer_id);
762    if (sdm::SetCSC(handle, &layer_buffer->color_metadata) != kErrorNone) {
763      return false;
764    }
765  }
766
767  return true;
768}
769
770
771uint32_t HWCLayer::RoundToStandardFPS(float fps) {
772  static const uint32_t standard_fps[4] = {24, 30, 48, 60};
773  uint32_t frame_rate = (uint32_t)(fps);
774
775  int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
776  for (int i = 0; i < count; i++) {
777    if ((standard_fps[i] - frame_rate) < 2) {
778      // Most likely used for video, the fps can fluctuate
779      // Ex: b/w 29 and 30 for 30 fps clip
780      return standard_fps[i];
781    }
782  }
783
784  return frame_rate;
785}
786
787void HWCLayer::SetComposition(const LayerComposition &sdm_composition) {
788  auto hwc_composition = HWC2::Composition::Invalid;
789  switch (sdm_composition) {
790    case kCompositionGPU:
791      hwc_composition = HWC2::Composition::Client;
792      break;
793    case kCompositionHWCursor:
794      hwc_composition = HWC2::Composition::Cursor;
795      break;
796    default:
797      hwc_composition = HWC2::Composition::Device;
798      break;
799  }
800  // Update solid fill composition
801  if (sdm_composition == kCompositionSDE && layer_->flags.solid_fill != 0) {
802    hwc_composition = HWC2::Composition::SolidColor;
803  }
804  device_selected_ = hwc_composition;
805
806  return;
807}
808void HWCLayer::PushReleaseFence(int32_t fence) {
809  release_fences_.push(fence);
810}
811int32_t HWCLayer::PopReleaseFence(void) {
812  if (release_fences_.empty())
813    return -1;
814  auto fence = release_fences_.front();
815  release_fences_.pop();
816  return fence;
817}
818
819}  // namespace sdm
820