1/* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include "native_window.h" 17 18#include <cstdint> 19#include <map> 20#include <cinttypes> 21#include <securec.h> 22#include "buffer_log.h" 23#include "window.h" 24#include "surface_type.h" 25#include "surface_utils.h" 26#include "sync_fence.h" 27#include "ipc_inner_object.h" 28#include "external_window.h" 29#include "hebc_white_list.h" 30#include "metadata_helper.h" 31 32#ifndef WEAK_ALIAS 33 #define WEAK_ALIAS(old, new) \ 34 extern __typeof(old) new __attribute__((__weak__, __alias__(#old))) 35#endif 36 37using namespace OHOS; 38using namespace HDI::Display::Graphic::Common::V1_0; 39static std::unordered_map<OH_NativeBuffer_ColorSpace, CM_ColorSpaceType> NATIVE_COLORSPACE_TO_HDI_MAP = { 40 {OH_COLORSPACE_NONE, CM_COLORSPACE_NONE}, 41 {OH_COLORSPACE_BT601_EBU_FULL, CM_BT601_EBU_FULL}, 42 {OH_COLORSPACE_BT601_SMPTE_C_FULL, CM_BT601_SMPTE_C_FULL}, 43 {OH_COLORSPACE_BT709_FULL, CM_BT709_FULL}, 44 {OH_COLORSPACE_BT2020_HLG_FULL, CM_BT2020_HLG_FULL}, 45 {OH_COLORSPACE_BT2020_PQ_FULL, CM_BT2020_PQ_FULL}, 46 {OH_COLORSPACE_BT601_EBU_LIMIT, CM_BT601_EBU_LIMIT}, 47 {OH_COLORSPACE_BT601_SMPTE_C_LIMIT, CM_BT601_SMPTE_C_LIMIT}, 48 {OH_COLORSPACE_BT709_LIMIT, CM_BT709_LIMIT}, 49 {OH_COLORSPACE_BT2020_HLG_LIMIT, CM_BT2020_HLG_LIMIT}, 50 {OH_COLORSPACE_BT2020_PQ_LIMIT, CM_BT2020_PQ_LIMIT}, 51 {OH_COLORSPACE_SRGB_FULL, CM_SRGB_FULL}, 52 {OH_COLORSPACE_P3_FULL, CM_P3_FULL}, 53 {OH_COLORSPACE_P3_HLG_FULL, CM_P3_HLG_FULL}, 54 {OH_COLORSPACE_P3_PQ_FULL, CM_P3_PQ_FULL}, 55 {OH_COLORSPACE_ADOBERGB_FULL, CM_ADOBERGB_FULL}, 56 {OH_COLORSPACE_SRGB_LIMIT, CM_SRGB_LIMIT}, 57 {OH_COLORSPACE_P3_LIMIT, CM_P3_LIMIT}, 58 {OH_COLORSPACE_P3_HLG_LIMIT, CM_P3_HLG_LIMIT}, 59 {OH_COLORSPACE_P3_PQ_LIMIT, CM_P3_PQ_LIMIT}, 60 {OH_COLORSPACE_ADOBERGB_LIMIT, CM_ADOBERGB_LIMIT}, 61 {OH_COLORSPACE_LINEAR_SRGB, CM_LINEAR_SRGB}, 62 {OH_COLORSPACE_LINEAR_BT709, CM_LINEAR_BT709}, 63 {OH_COLORSPACE_LINEAR_P3, CM_LINEAR_P3}, 64 {OH_COLORSPACE_LINEAR_BT2020, CM_LINEAR_BT2020}, 65 {OH_COLORSPACE_DISPLAY_SRGB, CM_DISPLAY_SRGB}, 66 {OH_COLORSPACE_DISPLAY_P3_SRGB, CM_DISPLAY_P3_SRGB}, 67 {OH_COLORSPACE_DISPLAY_P3_HLG, CM_DISPLAY_P3_HLG}, 68 {OH_COLORSPACE_DISPLAY_P3_PQ, CM_DISPLAY_P3_PQ}, 69 {OH_COLORSPACE_DISPLAY_BT2020_SRGB, CM_DISPLAY_BT2020_SRGB}, 70 {OH_COLORSPACE_DISPLAY_BT2020_HLG, CM_DISPLAY_BT2020_HLG}, 71 {OH_COLORSPACE_DISPLAY_BT2020_PQ, CM_DISPLAY_BT2020_PQ} 72}; 73 74static std::unordered_map<OH_NativeBuffer_MetadataType, CM_HDR_Metadata_Type> NATIVE_METADATATYPE_TO_HDI_MAP = { 75 {OH_VIDEO_HDR_HLG, CM_VIDEO_HLG}, 76 {OH_VIDEO_HDR_HDR10, CM_VIDEO_HDR10}, 77 {OH_VIDEO_HDR_VIVID, CM_VIDEO_HDR_VIVID}, 78}; 79 80namespace { 81 constexpr int32_t INVALID_PARAM = -1; 82 constexpr int32_t META_DATA_MAX_SIZE = 3000; 83} 84 85OHNativeWindow* CreateNativeWindowFromSurface(void* pSurface) 86{ 87 if (pSurface == nullptr) { 88 return nullptr; 89 } 90 91 OHNativeWindow* nativeWindow = new OHNativeWindow(); 92 nativeWindow->surface = 93 *reinterpret_cast<OHOS::sptr<OHOS::Surface> *>(pSurface); 94 if (nativeWindow->surface == nullptr) { 95 BLOGE("window surface is null"); 96 delete nativeWindow; 97 return nullptr; 98 } 99 OHOS::BufferRequestConfig windowConfig; 100 windowConfig.width = nativeWindow->surface->GetDefaultWidth(); 101 windowConfig.height = nativeWindow->surface->GetDefaultHeight(); 102 windowConfig.usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_MEM_DMA; 103 windowConfig.format = GRAPHIC_PIXEL_FMT_RGBA_8888; 104 windowConfig.strideAlignment = 8; // default stride is 8 105 windowConfig.timeout = 3000; // default timeout is 3000 ms 106 windowConfig.colorGamut = GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB; 107 windowConfig.transform = GraphicTransformType::GRAPHIC_ROTATE_NONE; 108 109 // if the application is in the hebc list, remove BUFFER_USAGE_CPU_READ flag 110 if (nativeWindow->surface->IsInHebcList()) { 111 windowConfig.usage &= ~BUFFER_USAGE_CPU_READ; 112 } 113 nativeWindow->surface->SetWindowConfig(windowConfig); 114 115 NativeObjectReference(nativeWindow); 116 auto utils = SurfaceUtils::GetInstance(); 117 utils->AddNativeWindow(nativeWindow->surface->GetUniqueId(), nativeWindow); 118 nativeWindow->surface->SetWptrNativeWindowToPSurface(nativeWindow); 119 return nativeWindow; 120} 121 122void DestoryNativeWindow(OHNativeWindow *window) 123{ 124 if (window == nullptr) { 125 return; 126 } 127 // unreference nativewindow object 128 NativeObjectUnreference(window); 129} 130 131OHNativeWindowBuffer* CreateNativeWindowBufferFromSurfaceBuffer(void* pSurfaceBuffer) 132{ 133 if (pSurfaceBuffer == nullptr) { 134 return nullptr; 135 } 136 OHNativeWindowBuffer *nwBuffer = new OHNativeWindowBuffer(); 137 nwBuffer->sfbuffer = *reinterpret_cast<OHOS::sptr<OHOS::SurfaceBuffer> *>(pSurfaceBuffer); 138 NativeObjectReference(nwBuffer); 139 return nwBuffer; 140} 141 142OHNativeWindowBuffer* CreateNativeWindowBufferFromNativeBuffer(OH_NativeBuffer* nativeBuffer) 143{ 144 if (nativeBuffer == nullptr) { 145 return nullptr; 146 } 147 OHNativeWindowBuffer *nwBuffer = new OHNativeWindowBuffer(); 148 OHOS::sptr<OHOS::SurfaceBuffer> surfaceBuffer(reinterpret_cast<OHOS::SurfaceBuffer *>(nativeBuffer)); 149 nwBuffer->sfbuffer = surfaceBuffer; 150 151 NativeObjectReference(nwBuffer); 152 return nwBuffer; 153} 154 155void DestroyNativeWindowBuffer(OHNativeWindowBuffer* buffer) 156{ 157 if (buffer == nullptr) { 158 return; 159 } 160 NativeObjectUnreference(buffer); 161} 162 163int32_t NativeWindowRequestBuffer(OHNativeWindow *window, 164 OHNativeWindowBuffer **buffer, int *fenceFd) 165{ 166 if (window == nullptr || buffer == nullptr || fenceFd == nullptr) { 167 return OHOS::SURFACE_ERROR_INVALID_PARAM; 168 } 169 OHOS::sptr<OHOS::SurfaceBuffer> sfbuffer; 170 OHOS::sptr<OHOS::SyncFence> releaseFence = OHOS::SyncFence::InvalidFence(); 171 BLOGE_CHECK_AND_RETURN_RET(window->surface != nullptr, SURFACE_ERROR_ERROR, "window surface is null"); 172 int32_t ret; 173 int32_t requestWidth = window->surface->GetRequestWidth(); 174 int32_t requestHeight = window->surface->GetRequestHeight(); 175 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 176 if (requestWidth != 0 && requestHeight != 0) { 177 OHOS::BufferRequestConfig config = windowConfig; 178 config.width = requestWidth; 179 config.height = requestHeight; 180 ret = window->surface->RequestBuffer(sfbuffer, releaseFence, config); 181 } else { 182 ret = window->surface->RequestBuffer(sfbuffer, releaseFence, windowConfig); 183 } 184 if (ret != OHOS::GSError::SURFACE_ERROR_OK || sfbuffer == nullptr) { 185 BLOGE("RequestBuffer ret:%{public}d, uniqueId: %{public}" PRIu64 ".", 186 ret, window->surface->GetUniqueId()); 187 return ret; 188 } 189 uint32_t seqNum = sfbuffer->GetSeqNum(); 190 auto iter = window->bufferCache_.find(seqNum); 191 if (iter == window->bufferCache_.end()) { 192 OHNativeWindowBuffer *nwBuffer = new OHNativeWindowBuffer(); 193 nwBuffer->sfbuffer = sfbuffer; 194 nwBuffer->uiTimestamp = window->uiTimestamp; 195 *buffer = nwBuffer; 196 // Add to cache 197 NativeObjectReference(nwBuffer); 198 window->bufferCache_[seqNum] = nwBuffer; 199 } else { 200 *buffer = iter->second; 201 (*buffer)->uiTimestamp = window->uiTimestamp; 202 } 203 *fenceFd = releaseFence->Dup(); 204 return OHOS::SURFACE_ERROR_OK; 205} 206 207int32_t NativeWindowFlushBuffer(OHNativeWindow *window, OHNativeWindowBuffer *buffer, 208 int fenceFd, struct Region region) 209{ 210 if (window == nullptr || buffer == nullptr || window->surface == nullptr) { 211 return OHOS::SURFACE_ERROR_INVALID_PARAM; 212 } 213 214 OHOS::BufferFlushConfigWithDamages config; 215 if ((region.rectNumber != 0) && (region.rects != nullptr)) { 216 config.damages.reserve(region.rectNumber); 217 for (int32_t i = 0; i < region.rectNumber; i++) { 218 OHOS::Rect damage = { 219 .x = region.rects[i].x, 220 .y = region.rects[i].y, 221 .w = static_cast<int32_t>(region.rects[i].w), 222 .h = static_cast<int32_t>(region.rects[i].h), 223 }; 224 config.damages.emplace_back(damage); 225 } 226 config.timestamp = buffer->uiTimestamp; 227 } else { 228 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 229 config.damages.reserve(1); 230 OHOS::Rect damage = { 231 .x = 0, 232 .y = 0, 233 .w = windowConfig.width, 234 .h = windowConfig.height, 235 }; 236 config.damages.emplace_back(damage); 237 config.timestamp = buffer->uiTimestamp; 238 } 239 config.desiredPresentTimestamp = window->desiredPresentTimestamp; 240 OHOS::sptr<OHOS::SyncFence> acquireFence = new OHOS::SyncFence(fenceFd); 241 int32_t ret = window->surface->FlushBuffer(buffer->sfbuffer, acquireFence, config); 242 if (ret != OHOS::GSError::SURFACE_ERROR_OK) { 243 BLOGE("FlushBuffer failed, ret:%{public}d, uniqueId: %{public}" PRIu64 ".", 244 ret, window->surface->GetUniqueId()); 245 return ret; 246 } 247 248 auto it = std::find_if(window->bufferCache_.begin(), window->bufferCache_.end(), 249 [buffer](const std::pair<uint32_t, NativeWindowBuffer*>& element) { 250 return element.second == buffer; 251 }); 252 if (it != window->bufferCache_.end()) { 253 window->lastBufferSeqNum = it->first; 254 } 255 256 return OHOS::SURFACE_ERROR_OK; 257} 258 259int32_t GetLastFlushedBuffer(OHNativeWindow *window, OHNativeWindowBuffer **buffer, int *fenceFd, float matrix[16]) 260{ 261 if (window == nullptr || buffer == nullptr || fenceFd == nullptr || window->surface == nullptr) { 262 return OHOS::SURFACE_ERROR_INVALID_PARAM; 263 } 264 OHNativeWindowBuffer *nwBuffer = new OHNativeWindowBuffer(); 265 OHOS::sptr<OHOS::SyncFence> acquireFence = OHOS::SyncFence::InvalidFence(); 266 int32_t ret = window->surface->GetLastFlushedBuffer(nwBuffer->sfbuffer, acquireFence, matrix, false); 267 if (ret != OHOS::GSError::SURFACE_ERROR_OK || nwBuffer->sfbuffer == nullptr) { 268 BLOGE("GetLastFlushedBuffer fail, uniqueId: %{public}" PRIu64 ".", window->surface->GetUniqueId()); 269 delete nwBuffer; 270 nwBuffer = nullptr; 271 return ret; 272 } 273 *buffer = nwBuffer; 274 NativeObjectReference(nwBuffer); 275 *fenceFd = acquireFence->Dup(); 276 return OHOS::SURFACE_ERROR_OK; 277} 278 279int32_t NativeWindowAttachBuffer(OHNativeWindow *window, OHNativeWindowBuffer *buffer) 280{ 281 if (window == nullptr || buffer == nullptr) { 282 return OHOS::SURFACE_ERROR_INVALID_PARAM; 283 } 284 BLOGE_CHECK_AND_RETURN_RET(window->surface != nullptr, SURFACE_ERROR_INVALID_PARAM, "window surface is null"); 285 return window->surface->AttachBufferToQueue(buffer->sfbuffer); 286} 287 288int32_t NativeWindowDetachBuffer(OHNativeWindow *window, OHNativeWindowBuffer *buffer) 289{ 290 if (window == nullptr || buffer == nullptr) { 291 return OHOS::SURFACE_ERROR_INVALID_PARAM; 292 } 293 BLOGE_CHECK_AND_RETURN_RET(window->surface != nullptr, SURFACE_ERROR_INVALID_PARAM, "window surface is null"); 294 return window->surface->DetachBufferFromQueue(buffer->sfbuffer); 295} 296 297int32_t NativeWindowCancelBuffer(OHNativeWindow *window, OHNativeWindowBuffer *buffer) 298{ 299 if (window == nullptr || buffer == nullptr) { 300 return OHOS::SURFACE_ERROR_INVALID_PARAM; 301 } 302 BLOGE_CHECK_AND_RETURN_RET(window->surface != nullptr, SURFACE_ERROR_INVALID_PARAM, "window surface is null"); 303 return window->surface->CancelBuffer(buffer->sfbuffer); 304} 305 306static void HandleNativeWindowSetUsage(OHNativeWindow *window, va_list args) 307{ 308 uint64_t usage = va_arg(args, uint64_t); 309 window->surface->SetWindowConfigUsage(usage); 310} 311 312static void HandleNativeWindowSetBufferGeometry(OHNativeWindow *window, va_list args) 313{ 314 int32_t width = va_arg(args, int32_t); 315 int32_t height = va_arg(args, int32_t); 316 window->surface->SetWindowConfigWidthAndHeight(width, height); 317} 318 319static void HandleNativeWindowSetFormat(OHNativeWindow *window, va_list args) 320{ 321 int32_t format = va_arg(args, int32_t); 322 window->surface->SetWindowConfigFormat(format); 323} 324 325static void HandleNativeWindowSetStride(OHNativeWindow *window, va_list args) 326{ 327 int32_t stride = va_arg(args, int32_t); 328 window->surface->SetWindowConfigStride(stride); 329} 330 331static void HandleNativeWindowSetTimeout(OHNativeWindow *window, va_list args) 332{ 333 int32_t timeout = va_arg(args, int32_t); 334 window->surface->SetWindowConfigTimeout(timeout); 335} 336 337static void HandleNativeWindowSetColorGamut(OHNativeWindow *window, va_list args) 338{ 339 int32_t colorGamut = va_arg(args, int32_t); 340 window->surface->SetWindowConfigColorGamut(static_cast<GraphicColorGamut>(colorGamut)); 341} 342 343static void HandleNativeWindowSetTransform(OHNativeWindow *window, va_list args) 344{ 345 int32_t transform = va_arg(args, int32_t); 346 window->surface->SetTransform(static_cast<GraphicTransformType>(transform)); 347 window->surface->SetWindowConfigTransform(static_cast<GraphicTransformType>(transform)); 348} 349 350static void HandleNativeWindowSetUiTimestamp(OHNativeWindow *window, va_list args) 351{ 352 uint64_t uiTimestamp = va_arg(args, uint64_t); 353 window->uiTimestamp = static_cast<int64_t>(uiTimestamp); 354} 355 356static void HandleNativeWindowSetDesiredPresentTimestamp(OHNativeWindow *window, va_list args) 357{ 358 int64_t desiredPresentTimestamp = va_arg(args, int64_t); 359 window->desiredPresentTimestamp = desiredPresentTimestamp; 360} 361 362static void HandleNativeWindowSetSurfaceSourceType(OHNativeWindow *window, va_list args) 363{ 364 OHSurfaceSource sourceType = va_arg(args, OHSurfaceSource); 365 window->surface->SetSurfaceSourceType(sourceType); 366} 367 368static void HandleNativeWindowSetSurfaceAppFrameworkType(OHNativeWindow *window, va_list args) 369{ 370 char* appFrameworkType = va_arg(args, char*); 371 if (appFrameworkType != nullptr) { 372 std::string typeStr(appFrameworkType); 373 window->surface->SetSurfaceAppFrameworkType(typeStr); 374 } 375} 376 377static void HandleNativeWindowGetUsage(OHNativeWindow *window, va_list args) 378{ 379 uint64_t *value = va_arg(args, uint64_t*); 380 if (value != nullptr) { 381 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 382 *value = static_cast<uint64_t>(windowConfig.usage); 383 } 384} 385 386static void HandleNativeWindowGetBufferGeometry(OHNativeWindow *window, va_list args) 387{ 388 int32_t *height = va_arg(args, int32_t*); 389 int32_t *width = va_arg(args, int32_t*); 390 if (height != nullptr && width != nullptr) { 391 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 392 *height = windowConfig.height; 393 *width = windowConfig.width; 394 } 395} 396 397static void HandleNativeWindowGetFormat(OHNativeWindow *window, va_list args) 398{ 399 int32_t *format = va_arg(args, int32_t*); 400 if (format != nullptr) { 401 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 402 *format = windowConfig.format; 403 } 404} 405 406static void HandleNativeWindowGetStride(OHNativeWindow *window, va_list args) 407{ 408 int32_t *stride = va_arg(args, int32_t*); 409 if (stride != nullptr) { 410 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 411 *stride = windowConfig.strideAlignment; 412 } 413} 414 415static void HandleNativeWindowGetTimeout(OHNativeWindow *window, va_list args) 416{ 417 int32_t *timeout = va_arg(args, int32_t*); 418 if (timeout != nullptr) { 419 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 420 *timeout = windowConfig.timeout; 421 } 422} 423 424static void HandleNativeWindowGetColorGamut(OHNativeWindow *window, va_list args) 425{ 426 int32_t *colorGamut = va_arg(args, int32_t*); 427 if (colorGamut != nullptr) { 428 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 429 *colorGamut = static_cast<int32_t>(windowConfig.colorGamut); 430 } 431} 432 433static void HandleNativeWindowGetTransform(OHNativeWindow *window, va_list args) 434{ 435 int32_t *transform = va_arg(args, int32_t*); 436 if (transform != nullptr) { 437 *transform = static_cast<int32_t>(window->surface->GetTransform()); 438 } 439} 440 441static void HandleNativeWindowGetBufferQueueSize(OHNativeWindow *window, va_list args) 442{ 443 int32_t *bufferQueueSize = va_arg(args, int32_t*); 444 if (bufferQueueSize != nullptr) { 445 *bufferQueueSize = static_cast<int32_t>(window->surface->GetQueueSize()); 446 } 447} 448 449static void HandleNativeWindowGetSurfaceSourceType(OHNativeWindow *window, va_list args) 450{ 451 OHSurfaceSource *sourceType = va_arg(args, OHSurfaceSource*); 452 if (sourceType != nullptr) { 453 *sourceType = window->surface->GetSurfaceSourceType(); 454 } 455} 456 457static void HandleNativeWindowGetSurfaceAppFrameworkType(OHNativeWindow *window, va_list args) 458{ 459 const char **appFrameworkType = va_arg(args, const char**); 460 if (appFrameworkType != nullptr) { 461 std::string typeStr = window->surface->GetSurfaceAppFrameworkType(); 462 *appFrameworkType = typeStr.c_str(); 463 } 464} 465 466static void HandleNativeWindowSetHdrWhitePointBrightness(OHNativeWindow *window, va_list args) 467{ 468 float hdrWhitePointBrightness = static_cast<float>(va_arg(args, double)); 469 window->surface->SetHdrWhitePointBrightness(hdrWhitePointBrightness); 470} 471 472static void HandleNativeWindowSetSdrWhitePointBrightness(OHNativeWindow *window, va_list args) 473{ 474 float sdrWhitePointBrightness = static_cast<float>(va_arg(args, double)); 475 window->surface->SetSdrWhitePointBrightness(sdrWhitePointBrightness); 476} 477 478static std::map<int, std::function<void(OHNativeWindow*, va_list)>> operationMap = { 479 {SET_USAGE, HandleNativeWindowSetUsage}, 480 {SET_BUFFER_GEOMETRY, HandleNativeWindowSetBufferGeometry}, 481 {SET_FORMAT, HandleNativeWindowSetFormat}, 482 {SET_STRIDE, HandleNativeWindowSetStride}, 483 {SET_TIMEOUT, HandleNativeWindowSetTimeout}, 484 {SET_COLOR_GAMUT, HandleNativeWindowSetColorGamut}, 485 {SET_TRANSFORM, HandleNativeWindowSetTransform}, 486 {SET_UI_TIMESTAMP, HandleNativeWindowSetUiTimestamp}, 487 {SET_SOURCE_TYPE, HandleNativeWindowSetSurfaceSourceType}, 488 {SET_APP_FRAMEWORK_TYPE, HandleNativeWindowSetSurfaceAppFrameworkType}, 489 {GET_USAGE, HandleNativeWindowGetUsage}, 490 {GET_BUFFER_GEOMETRY, HandleNativeWindowGetBufferGeometry}, 491 {GET_FORMAT, HandleNativeWindowGetFormat}, 492 {GET_STRIDE, HandleNativeWindowGetStride}, 493 {GET_TIMEOUT, HandleNativeWindowGetTimeout}, 494 {GET_COLOR_GAMUT, HandleNativeWindowGetColorGamut}, 495 {GET_TRANSFORM, HandleNativeWindowGetTransform}, 496 {GET_BUFFERQUEUE_SIZE, HandleNativeWindowGetBufferQueueSize}, 497 {GET_SOURCE_TYPE, HandleNativeWindowGetSurfaceSourceType}, 498 {GET_APP_FRAMEWORK_TYPE, HandleNativeWindowGetSurfaceAppFrameworkType}, 499 {SET_HDR_WHITE_POINT_BRIGHTNESS, HandleNativeWindowSetHdrWhitePointBrightness}, 500 {SET_SDR_WHITE_POINT_BRIGHTNESS, HandleNativeWindowSetSdrWhitePointBrightness}, 501 {SET_DESIRED_PRESENT_TIMESTAMP, HandleNativeWindowSetDesiredPresentTimestamp}, 502}; 503 504static int32_t InternalHandleNativeWindowOpt(OHNativeWindow *window, int code, va_list args) 505{ 506 auto it = operationMap.find(code); 507 if (it != operationMap.end()) { 508 it->second(window, args); 509 } 510 return OHOS::GSERROR_OK; 511} 512 513int32_t NativeWindowHandleOpt(OHNativeWindow *window, int code, ...) 514{ 515 if (window == nullptr || window->surface == nullptr) { 516 return OHOS::SURFACE_ERROR_INVALID_PARAM; 517 } 518 va_list args; 519 va_start(args, code); 520 InternalHandleNativeWindowOpt(window, code, args); 521 va_end(args); 522 return OHOS::GSERROR_OK; 523} 524 525BufferHandle *GetBufferHandleFromNative(OHNativeWindowBuffer *buffer) 526{ 527 if (buffer == nullptr || buffer->sfbuffer == nullptr) { 528 return nullptr; 529 } 530 531 return buffer->sfbuffer->GetBufferHandle(); 532} 533 534int32_t GetNativeObjectMagic(void *obj) 535{ 536 if (obj == nullptr) { 537 return INVALID_PARAM; 538 } 539 NativeWindowMagic* nativeWindowMagic = reinterpret_cast<NativeWindowMagic *>(obj); 540 return nativeWindowMagic->magic; 541} 542 543int32_t NativeObjectReference(void *obj) 544{ 545 if (obj == nullptr) { 546 return OHOS::SURFACE_ERROR_INVALID_PARAM; 547 } 548 switch (GetNativeObjectMagic(obj)) { 549 case NATIVE_OBJECT_MAGIC_WINDOW: 550 case NATIVE_OBJECT_MAGIC_WINDOW_BUFFER: 551 break; 552 default: 553 BLOGE("magic illegal: %{public}d", GetNativeObjectMagic(obj)); 554 return OHOS::SURFACE_ERROR_INVALID_PARAM; 555 } 556 OHOS::RefBase *ref = reinterpret_cast<OHOS::RefBase *>(obj); 557 ref->IncStrongRef(ref); 558 return OHOS::GSERROR_OK; 559} 560 561int32_t NativeObjectUnreference(void *obj) 562{ 563 if (obj == nullptr) { 564 return OHOS::SURFACE_ERROR_INVALID_PARAM; 565 } 566 switch (GetNativeObjectMagic(obj)) { 567 case NATIVE_OBJECT_MAGIC_WINDOW: 568 case NATIVE_OBJECT_MAGIC_WINDOW_BUFFER: 569 break; 570 default: 571 BLOGE("magic illegal: %{public}d", GetNativeObjectMagic(obj)); 572 return OHOS::SURFACE_ERROR_INVALID_PARAM; 573 } 574 OHOS::RefBase *ref = reinterpret_cast<OHOS::RefBase *>(obj); 575 ref->DecStrongRef(ref); 576 return OHOS::GSERROR_OK; 577} 578 579int32_t NativeWindowSetScalingMode(OHNativeWindow *window, uint32_t sequence, OHScalingMode scalingMode) 580{ 581 if (window == nullptr || window->surface == nullptr || 582 scalingMode < OHScalingMode::OH_SCALING_MODE_FREEZE || 583 scalingMode > OHScalingMode::OH_SCALING_MODE_NO_SCALE_CROP) { 584 return OHOS::SURFACE_ERROR_INVALID_PARAM; 585 } 586 return window->surface->SetScalingMode(sequence, static_cast<ScalingMode>(scalingMode)); 587} 588 589int32_t NativeWindowSetScalingModeV2(OHNativeWindow *window, OHScalingModeV2 scalingMode) 590{ 591 if (window == nullptr || window->surface == nullptr || 592 scalingMode < OHScalingModeV2::OH_SCALING_MODE_FREEZE_V2 || 593 scalingMode > OHScalingModeV2::OH_SCALING_MODE_SCALE_FIT_V2) { 594 return OHOS::GSERROR_INVALID_ARGUMENTS; 595 } 596 return window->surface->SetScalingMode(static_cast<ScalingMode>(scalingMode)); 597} 598 599int32_t NativeWindowSetMetaData(OHNativeWindow *window, uint32_t sequence, int32_t size, 600 const OHHDRMetaData *metaData) 601{ 602 if (window == nullptr || window->surface == nullptr || 603 size <= 0 ||size > META_DATA_MAX_SIZE || metaData == nullptr) { 604 return OHOS::SURFACE_ERROR_INVALID_PARAM; 605 } 606 607 std::vector<GraphicHDRMetaData> data(reinterpret_cast<const GraphicHDRMetaData *>(metaData), 608 reinterpret_cast<const GraphicHDRMetaData *>(metaData) + size); 609 return window->surface->SetMetaData(sequence, data); 610} 611 612int32_t NativeWindowSetMetaDataSet(OHNativeWindow *window, uint32_t sequence, OHHDRMetadataKey key, 613 int32_t size, const uint8_t *metaData) 614{ 615 if (window == nullptr || window->surface == nullptr || 616 key < OHHDRMetadataKey::OH_METAKEY_RED_PRIMARY_X || key > OHHDRMetadataKey::OH_METAKEY_HDR_VIVID || 617 size <= 0 || size > META_DATA_MAX_SIZE || metaData == nullptr) { 618 return OHOS::SURFACE_ERROR_INVALID_PARAM; 619 } 620 std::vector<uint8_t> data(metaData, metaData + size); 621 return window->surface->SetMetaDataSet(sequence, static_cast<GraphicHDRMetadataKey>(key), data); 622} 623 624int32_t NativeWindowSetTunnelHandle(OHNativeWindow *window, const OHExtDataHandle *handle) 625{ 626 if (window == nullptr || window->surface == nullptr || handle == nullptr) { 627 return OHOS::SURFACE_ERROR_INVALID_PARAM; 628 } 629 return window->surface->SetTunnelHandle(reinterpret_cast<const OHOS::GraphicExtDataHandle*>(handle)); 630} 631 632int32_t GetSurfaceId(OHNativeWindow *window, uint64_t *surfaceId) 633{ 634 if (window == nullptr || window->surface == nullptr || surfaceId == nullptr) { 635 return OHOS::SURFACE_ERROR_INVALID_PARAM; 636 } 637 638 *surfaceId = window->surface->GetUniqueId(); 639 return OHOS::GSERROR_OK; 640} 641 642int32_t CreateNativeWindowFromSurfaceId(uint64_t surfaceId, OHNativeWindow **window) 643{ 644 if (window == nullptr) { 645 return OHOS::SURFACE_ERROR_INVALID_PARAM; 646 } 647 648 auto utils = SurfaceUtils::GetInstance(); 649 *window = reinterpret_cast<OHNativeWindow*>(utils->GetNativeWindow(surfaceId)); 650 if (*window != nullptr) { 651 NativeObjectReference(*window); 652 BLOGD("get nativeWindow from cache, uniqueId: %{public}" PRIu64 ".", surfaceId); 653 return OHOS::GSERROR_OK; 654 } 655 656 OHNativeWindow *nativeWindow = new OHNativeWindow(); 657 nativeWindow->surface = utils->GetSurface(surfaceId); 658 if (nativeWindow->surface == nullptr) { 659 BLOGE("window surface is null, surfaceId: %{public}" PRIu64 ".", surfaceId); 660 delete nativeWindow; 661 return OHOS::SURFACE_ERROR_INVALID_PARAM; 662 } 663 664 NativeObjectReference(nativeWindow); 665 utils->AddNativeWindow(nativeWindow->surface->GetUniqueId(), nativeWindow); 666 nativeWindow->surface->SetWptrNativeWindowToPSurface(nativeWindow); 667 *window = nativeWindow; 668 return OHOS::GSERROR_OK; 669} 670 671int32_t NativeWindowGetTransformHint(OHNativeWindow *window, OH_NativeBuffer_TransformType *transform) 672{ 673 if (window == nullptr || window->surface == nullptr || transform == nullptr) { 674 return OHOS::SURFACE_ERROR_INVALID_PARAM; 675 } 676 *transform = static_cast<OH_NativeBuffer_TransformType>(window->surface->GetTransformHint()); 677 return OHOS::GSERROR_OK; 678} 679 680int32_t NativeWindowSetTransformHint(OHNativeWindow *window, OH_NativeBuffer_TransformType transform) 681{ 682 if (window == nullptr || window->surface == nullptr) { 683 return OHOS::SURFACE_ERROR_INVALID_PARAM; 684 } 685 return window->surface->SetTransformHint(static_cast<OHOS::GraphicTransformType>(transform)); 686} 687 688int32_t NativeWindowGetDefaultWidthAndHeight(OHNativeWindow *window, int32_t *width, int32_t *height) 689{ 690 if (window == nullptr || window->surface == nullptr || width == nullptr || height == nullptr) { 691 return OHOS::SURFACE_ERROR_INVALID_PARAM; 692 } 693 OHOS::BufferRequestConfig windowConfig = window->surface->GetWindowConfig(); 694 if (windowConfig.width != 0 && windowConfig.height != 0) { 695 *width = windowConfig.width; 696 *height = windowConfig.height; 697 } else { 698 *width = window->surface->GetDefaultWidth(); 699 *height = window->surface->GetDefaultHeight(); 700 } 701 return OHOS::GSERROR_OK; 702} 703 704int32_t NativeWindowSetRequestWidthAndHeight(OHNativeWindow *window, int32_t width, int32_t height) 705{ 706 if (window == nullptr || window->surface == nullptr) { 707 return OHOS::SURFACE_ERROR_INVALID_PARAM; 708 } 709 window->surface->SetRequestWidthAndHeight(width, height); 710 return OHOS::GSERROR_OK; 711} 712 713void NativeWindowSetBufferHold(OHNativeWindow *window) 714{ 715 if (window == nullptr || window->surface == nullptr) { 716 return; 717 } 718 window->surface->SetBufferHold(true); 719} 720 721int32_t NativeWindowWriteToParcel(OHNativeWindow *window, OHIPCParcel *parcel) 722{ 723 if (window == nullptr) { 724 return OHOS::SURFACE_ERROR_INVALID_PARAM; 725 } 726 if (parcel == nullptr || parcel->msgParcel == nullptr) { 727 return OHOS::SURFACE_ERROR_INVALID_PARAM; 728 } 729 sptr<OHOS::Surface> windowSurface = window->surface; 730 if (windowSurface == nullptr) { 731 BLOGE("windowSurface is nullptr"); 732 return OHOS::SURFACE_ERROR_INVALID_PARAM; 733 } 734 auto producer = windowSurface->GetProducer(); 735 if (producer == nullptr) { 736 return OHOS::SURFACE_ERROR_INVALID_PARAM; 737 } 738 if (!(parcel->msgParcel)->WriteRemoteObject(producer->AsObject())) { 739 return OHOS::SURFACE_ERROR_INVALID_PARAM; 740 } 741 return OHOS::GSERROR_OK; 742} 743 744int32_t NativeWindowReadFromParcel(OHIPCParcel *parcel, OHNativeWindow **window) 745{ 746 if (parcel == nullptr || parcel->msgParcel == nullptr || window == nullptr) { 747 return OHOS::SURFACE_ERROR_INVALID_PARAM; 748 } 749 sptr<OHOS::IRemoteObject> surfaceObject = (parcel->msgParcel)->ReadRemoteObject(); 750 if (surfaceObject == nullptr) { 751 BLOGE("surfaceObject is nullptr"); 752 return OHOS::SURFACE_ERROR_INVALID_PARAM; 753 } 754 sptr<OHOS::IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject); 755 sptr <OHOS::Surface> windowSurface = OHOS::Surface::CreateSurfaceAsProducer(bp); 756 if (windowSurface == nullptr) { 757 BLOGE("windowSurface is nullptr"); 758 return OHOS::SURFACE_ERROR_INVALID_PARAM; 759 } 760 auto utils = SurfaceUtils::GetInstance(); 761 *window = reinterpret_cast<OHNativeWindow*>(utils->GetNativeWindow(windowSurface->GetUniqueId())); 762 if (*window == nullptr) { 763 *window = CreateNativeWindowFromSurface(&windowSurface); 764 } 765 return OHOS::GSERROR_OK; 766} 767 768int32_t GetLastFlushedBufferV2(OHNativeWindow *window, OHNativeWindowBuffer **buffer, int *fenceFd, float matrix[16]) 769{ 770 if (window == nullptr || buffer == nullptr || fenceFd == nullptr || window->surface == nullptr) { 771 return OHOS::SURFACE_ERROR_INVALID_PARAM; 772 } 773 OHNativeWindowBuffer *nwBuffer = new OHNativeWindowBuffer(); 774 OHOS::sptr<OHOS::SyncFence> acquireFence = OHOS::SyncFence::InvalidFence(); 775 int32_t ret = window->surface->GetLastFlushedBuffer(nwBuffer->sfbuffer, acquireFence, matrix, true); 776 if (ret != OHOS::GSError::SURFACE_ERROR_OK || nwBuffer->sfbuffer == nullptr) { 777 BLOGE("GetLastFlushedBuffer fail, ret: %{public}d, uniqueId: %{public}" PRIu64 ".", 778 ret, window->surface->GetUniqueId()); 779 delete nwBuffer; 780 nwBuffer = nullptr; 781 return ret; 782 } 783 *buffer = nwBuffer; 784 NativeObjectReference(nwBuffer); 785 *fenceFd = acquireFence->Dup(); 786 return OHOS::SURFACE_ERROR_OK; 787} 788 789int32_t NativeWindowDisconnect(OHNativeWindow *window) 790{ 791 if (window == nullptr || window->surface == nullptr) { 792 return OHOS::SURFACE_ERROR_INVALID_PARAM; 793 } 794 return window->surface->Disconnect(); 795} 796 797int32_t OH_NativeWindow_SetColorSpace(OHNativeWindow *window, OH_NativeBuffer_ColorSpace colorSpace) 798{ 799 auto iter = NATIVE_COLORSPACE_TO_HDI_MAP.find(colorSpace); 800 if (window == nullptr || iter == NATIVE_COLORSPACE_TO_HDI_MAP.end()) { 801 return OHOS::SURFACE_ERROR_INVALID_PARAM; 802 } 803 std::string param = std::to_string(iter->second); 804 GSError ret = GSERROR_OK; 805 if (window->surface != nullptr && param != window->surface->GetUserData("ATTRKEY_COLORSPACE_INFO")) { 806 ret = window->surface->SetUserData("ATTRKEY_COLORSPACE_INFO", param); 807 } 808 if (ret != OHOS::SURFACE_ERROR_OK) { 809 BLOGE("SetColorSpaceType failed!, ret: %{public}d", ret); 810 return OHOS::SURFACE_ERROR_UNKOWN; 811 } 812 return OHOS::SURFACE_ERROR_OK; 813} 814 815int32_t OH_NativeWindow_GetColorSpace(OHNativeWindow *window, OH_NativeBuffer_ColorSpace *colorSpace) 816{ 817 if (window == nullptr || colorSpace == nullptr) { 818 return OHOS::SURFACE_ERROR_INVALID_PARAM; 819 } 820 CM_ColorSpaceType colorSpaceType = CM_COLORSPACE_NONE; 821 if (window->surface != nullptr) { 822 std::string value = window->surface->GetUserData("ATTRKEY_COLORSPACE_INFO"); 823 if (value.empty()) { 824 BLOGE("no colorspace!"); 825 return OHOS::SURFACE_ERROR_UNKOWN; 826 } 827 colorSpaceType = static_cast<CM_ColorSpaceType>(atoi(value.c_str())); 828 auto it = std::find_if(NATIVE_COLORSPACE_TO_HDI_MAP.begin(), NATIVE_COLORSPACE_TO_HDI_MAP.end(), 829 [colorSpaceType](const std::pair<OH_NativeBuffer_ColorSpace, CM_ColorSpaceType>& element) { 830 return element.second == colorSpaceType; 831 }); 832 if (it != NATIVE_COLORSPACE_TO_HDI_MAP.end()) { 833 *colorSpace = it->first; 834 return OHOS::SURFACE_ERROR_OK; 835 } 836 } 837 BLOGE("the colorSpace does not support it."); 838 return OHOS::SURFACE_ERROR_UNKOWN; 839} 840 841int32_t OH_NativeWindow_SetMetadataValue(OHNativeWindow *window, OH_NativeBuffer_MetadataKey metadataKey, 842 int32_t size, uint8_t *metadata) 843{ 844 if (window == nullptr || metadata == nullptr || size <= 0 || size > META_DATA_MAX_SIZE || 845 window->surface == nullptr) { 846 return OHOS::SURFACE_ERROR_INVALID_PARAM; 847 } 848 GSError ret = GSERROR_OK; 849 std::vector<uint8_t> mD(metadata, metadata + size); 850 std::string param; 851 if (metadataKey == OH_HDR_DYNAMIC_METADATA) { 852 param.assign(mD.begin(), mD.end()); 853 if (param != window->surface->GetUserData("OH_HDR_DYNAMIC_METADATA")) { 854 ret = window->surface->SetUserData("OH_HDR_DYNAMIC_METADATA", param); 855 } 856 } else if (metadataKey == OH_HDR_STATIC_METADATA) { 857 param.assign(mD.begin(), mD.end()); 858 if (param != window->surface->GetUserData("OH_HDR_STATIC_METADATA")) { 859 ret = window->surface->SetUserData("OH_HDR_STATIC_METADATA", param); 860 } 861 } else if (metadataKey == OH_HDR_METADATA_TYPE) { 862 OH_NativeBuffer_MetadataType hdrMetadataType = static_cast<OH_NativeBuffer_MetadataType>(*metadata); 863 param = std::to_string(NATIVE_METADATATYPE_TO_HDI_MAP[hdrMetadataType]); 864 if (param != window->surface->GetUserData("OH_HDR_METADATA_TYPE")) { 865 ret = window->surface->SetUserData("OH_HDR_METADATA_TYPE", param); 866 } 867 } else { 868 BLOGE("the metadataKey does not support it."); 869 return OHOS::SURFACE_ERROR_NOT_SUPPORT; 870 } 871 if (GSErrorStr(ret) == "<500 api call failed>with low error <Not supported>") { 872 return OHOS::SURFACE_ERROR_NOT_SUPPORT; 873 } else if (ret != OHOS::SURFACE_ERROR_OK) { 874 BLOGE("SetHDRMetadata failed!, ret: %{public}d", ret); 875 return OHOS::SURFACE_ERROR_UNKOWN; 876 } 877 return OHOS::SURFACE_ERROR_OK; 878} 879 880static GSError OH_NativeWindow_GetMatedataValueType(OHNativeWindow *window, int32_t *size, uint8_t **metadata) 881{ 882 std::string value = window->surface->GetUserData("OH_HDR_METADATA_TYPE"); 883 CM_HDR_Metadata_Type hdrMetadataType = CM_METADATA_NONE; 884 hdrMetadataType = static_cast<CM_HDR_Metadata_Type>(atoi(value.c_str())); 885 auto it = std::find_if(NATIVE_METADATATYPE_TO_HDI_MAP.begin(), NATIVE_METADATATYPE_TO_HDI_MAP.end(), 886 [hdrMetadataType](const std::pair<OH_NativeBuffer_MetadataType, CM_HDR_Metadata_Type>& element) { 887 return element.second == hdrMetadataType; 888 }); 889 if (it != NATIVE_METADATATYPE_TO_HDI_MAP.end()) { 890 *size = sizeof(OH_NativeBuffer_MetadataType); 891 *metadata = new uint8_t[*size]; 892 errno_t err = memcpy_s(*metadata, *size, &(it->first), *size); 893 if (err != 0) { 894 delete[] *metadata; 895 *metadata = nullptr; 896 BLOGE("memcpy_s failed! , ret: %{public}d", err); 897 return OHOS::SURFACE_ERROR_UNKOWN; 898 } 899 return OHOS::SURFACE_ERROR_OK; 900 } 901 BLOGE("the hdrMetadataType does not support it."); 902 return OHOS::SURFACE_ERROR_NOT_SUPPORT; 903} 904 905int32_t OH_NativeWindow_GetMetadataValue(OHNativeWindow *window, OH_NativeBuffer_MetadataKey metadataKey, 906 int32_t *size, uint8_t **metadata) 907{ 908 if (window == nullptr || metadata == nullptr || size == nullptr || window->surface == nullptr) { 909 return OHOS::SURFACE_ERROR_INVALID_PARAM; 910 } 911 GSError ret = GSERROR_OK; 912 std::vector<uint8_t> mD; 913 if (metadataKey == OH_HDR_DYNAMIC_METADATA) { 914 std::string value = window->surface->GetUserData("OH_HDR_DYNAMIC_METADATA"); 915 mD.resize(value.size()); 916 mD.assign(value.begin(), value.end()); 917 } else if (metadataKey == OH_HDR_STATIC_METADATA) { 918 std::string value = window->surface->GetUserData("OH_HDR_STATIC_METADATA"); 919 mD.resize(value.size()); 920 mD.assign(value.begin(), value.end()); 921 } else if (metadataKey == OH_HDR_METADATA_TYPE) { 922 ret = OH_NativeWindow_GetMatedataValueType(window, size, metadata); 923 return ret; 924 } else { 925 BLOGE("the metadataKey does not support it."); 926 return OHOS::SURFACE_ERROR_UNKOWN; 927 } 928 if (GSErrorStr(ret) == "<500 api call failed>with low error <Not supported>") { 929 return OHOS::SURFACE_ERROR_NOT_SUPPORT; 930 } else if (ret != OHOS::SURFACE_ERROR_OK) { 931 BLOGE("SetHDRSMetadata failed! , ret: %{public}d", ret); 932 return OHOS::SURFACE_ERROR_UNKOWN; 933 } 934 *size = mD.size(); 935 *metadata = new uint8_t[mD.size()]; 936 if (!mD.empty()) { 937 errno_t err = memcpy_s(*metadata, mD.size(), &mD[0], mD.size()); 938 if (err != 0) { 939 delete[] *metadata; 940 *metadata = nullptr; 941 BLOGE("memcpy_s failed! , ret: %{public}d", err); 942 return OHOS::SURFACE_ERROR_UNKOWN; 943 } 944 } else { 945 delete[] *metadata; 946 *metadata = nullptr; 947 BLOGE("new metadata failed!"); 948 return OHOS::SURFACE_ERROR_UNKOWN; 949 } 950 return OHOS::SURFACE_ERROR_OK; 951} 952 953NativeWindow::NativeWindow() : NativeWindowMagic(NATIVE_OBJECT_MAGIC_WINDOW), surface(nullptr) 954{ 955} 956 957NativeWindow::~NativeWindow() 958{ 959 if (surface != nullptr) { 960 auto utils = SurfaceUtils::GetInstance(); 961 utils->RemoveNativeWindow(surface->GetUniqueId()); 962 } 963 964 for (auto &[seqNum, buffer] : bufferCache_) { 965 NativeObjectUnreference(buffer); 966 } 967 surface = nullptr; 968 bufferCache_.clear(); 969} 970 971NativeWindowBuffer::~NativeWindowBuffer() 972{ 973 sfbuffer = nullptr; 974} 975 976NativeWindowBuffer::NativeWindowBuffer() : NativeWindowMagic(NATIVE_OBJECT_MAGIC_WINDOW_BUFFER), sfbuffer(nullptr) 977{ 978} 979 980WEAK_ALIAS(CreateNativeWindowFromSurface, OH_NativeWindow_CreateNativeWindow); 981WEAK_ALIAS(DestoryNativeWindow, OH_NativeWindow_DestroyNativeWindow); 982WEAK_ALIAS(CreateNativeWindowBufferFromSurfaceBuffer, OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer); 983WEAK_ALIAS(CreateNativeWindowBufferFromNativeBuffer, OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer); 984WEAK_ALIAS(DestroyNativeWindowBuffer, OH_NativeWindow_DestroyNativeWindowBuffer); 985WEAK_ALIAS(NativeWindowRequestBuffer, OH_NativeWindow_NativeWindowRequestBuffer); 986WEAK_ALIAS(NativeWindowFlushBuffer, OH_NativeWindow_NativeWindowFlushBuffer); 987WEAK_ALIAS(GetLastFlushedBuffer, OH_NativeWindow_GetLastFlushedBuffer); 988WEAK_ALIAS(NativeWindowAttachBuffer, OH_NativeWindow_NativeWindowAttachBuffer); 989WEAK_ALIAS(NativeWindowDetachBuffer, OH_NativeWindow_NativeWindowDetachBuffer); 990WEAK_ALIAS(NativeWindowCancelBuffer, OH_NativeWindow_NativeWindowAbortBuffer); 991WEAK_ALIAS(NativeWindowHandleOpt, OH_NativeWindow_NativeWindowHandleOpt); 992WEAK_ALIAS(GetBufferHandleFromNative, OH_NativeWindow_GetBufferHandleFromNative); 993WEAK_ALIAS(NativeObjectReference, OH_NativeWindow_NativeObjectReference); 994WEAK_ALIAS(NativeObjectUnreference, OH_NativeWindow_NativeObjectUnreference); 995WEAK_ALIAS(GetNativeObjectMagic, OH_NativeWindow_GetNativeObjectMagic); 996WEAK_ALIAS(NativeWindowSetScalingMode, OH_NativeWindow_NativeWindowSetScalingMode); 997WEAK_ALIAS(NativeWindowSetScalingModeV2, OH_NativeWindow_NativeWindowSetScalingModeV2); 998WEAK_ALIAS(NativeWindowSetMetaData, OH_NativeWindow_NativeWindowSetMetaData); 999WEAK_ALIAS(NativeWindowSetMetaDataSet, OH_NativeWindow_NativeWindowSetMetaDataSet); 1000WEAK_ALIAS(NativeWindowSetTunnelHandle, OH_NativeWindow_NativeWindowSetTunnelHandle); 1001WEAK_ALIAS(GetSurfaceId, OH_NativeWindow_GetSurfaceId); 1002WEAK_ALIAS(CreateNativeWindowFromSurfaceId, OH_NativeWindow_CreateNativeWindowFromSurfaceId); 1003WEAK_ALIAS(NativeWindowSetBufferHold, OH_NativeWindow_SetBufferHold); 1004WEAK_ALIAS(NativeWindowWriteToParcel, OH_NativeWindow_WriteToParcel); 1005WEAK_ALIAS(NativeWindowReadFromParcel, OH_NativeWindow_ReadFromParcel); 1006WEAK_ALIAS(GetLastFlushedBufferV2, OH_NativeWindow_GetLastFlushedBufferV2); 1007