libs/nativewindow/ANativeWindow.cpp - platform/frameworks/native - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "ANativeWindow"

 #include <grallocusage/GrallocUsageConversion.h>
 // from nativewindow/includes/system/window.h
 // (not to be confused with the compatibility-only window.h from system/core/includes)
 #include <system/window.h>
 #include <android/native_window_aidl.h>

 #include <private/android/AHardwareBufferHelpers.h>

 #include <android/binder_libbinder.h>
 #include <dlfcn.h>
 #include <log/log.h>
 #include <ui/GraphicBuffer.h>

 using namespace android;

 #if defined(__ANDROID_APEX__) || defined(__ANDROID_VNDK__)
 #error libnativewindow can only be built for system
 #endif

 using android_view_Surface_writeToParcel = status_t (*)(ANativeWindow* _Nonnull window,
                                                         Parcel* _Nonnull parcel);

 using android_view_Surface_readFromParcel =
         status_t (*)(const Parcel* _Nonnull parcel, ANativeWindow* _Nullable* _Nonnull outWindow);

 struct SurfaceParcelables {
     android_view_Surface_writeToParcel write = nullptr;
     android_view_Surface_readFromParcel read = nullptr;
 };

 const SurfaceParcelables* getSurfaceParcelFunctions() {
     static SurfaceParcelables funcs = []() -> SurfaceParcelables {
         SurfaceParcelables ret;
         void* dl = dlopen("libgui.so", RTLD_NOW);
         LOG_ALWAYS_FATAL_IF(!dl, "Failed to find libgui.so");
         ret.write =
                 (android_view_Surface_writeToParcel)dlsym(dl, "android_view_Surface_writeToParcel");
         LOG_ALWAYS_FATAL_IF(!ret.write,
                             "libgui.so missing android_view_Surface_writeToParcel; "
                             "loaded wrong libgui?");
         ret.read =
                 (android_view_Surface_readFromParcel)dlsym(dl,
                                                            "android_view_Surface_readFromParcel");
         LOG_ALWAYS_FATAL_IF(!ret.read,
                             "libgui.so missing android_view_Surface_readFromParcel; "
                             "loaded wrong libgui?");
         return ret;
     }();
     return &funcs;
 }

 static int32_t query(ANativeWindow* window, int what) {
     int value;
     int res = window->query(window, what, &value);
     return res < 0 ? res : value;
 }

 static int64_t query64(ANativeWindow* window, int what) {
     int64_t value;
     int res = window->perform(window, what, &value);
     return res < 0 ? res : value;
 }

 /**************************************************************************************************
  * NDK
  **************************************************************************************************/

 void ANativeWindow_acquire(ANativeWindow* window) {
     // incStrong/decStrong token must be the same, doesn't matter what it is
     window->incStrong((void*)ANativeWindow_acquire);
 }

 void ANativeWindow_release(ANativeWindow* window) {
     // incStrong/decStrong token must be the same, doesn't matter what it is
     window->decStrong((void*)ANativeWindow_acquire);
 }

 int32_t ANativeWindow_getWidth(ANativeWindow* window) {
     return query(window, NATIVE_WINDOW_WIDTH);
 }

 int32_t ANativeWindow_getHeight(ANativeWindow* window) {
     return query(window, NATIVE_WINDOW_HEIGHT);
 }

 int32_t ANativeWindow_getFormat(ANativeWindow* window) {
     return query(window, NATIVE_WINDOW_FORMAT);
 }

 int32_t ANativeWindow_setBuffersGeometry(ANativeWindow* window,
         int32_t width, int32_t height, int32_t format) {
     int32_t err = native_window_set_buffers_format(window, format);
     if (!err) {
         err = native_window_set_buffers_user_dimensions(window, width, height);
         if (!err) {
             int mode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
             if (width && height) {
                 mode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
             }
             err = native_window_set_scaling_mode(window, mode);
         }
     }
     return err;
 }

 int32_t ANativeWindow_lock(ANativeWindow* window, ANativeWindow_Buffer* outBuffer,
         ARect* inOutDirtyBounds) {
     return window->perform(window, NATIVE_WINDOW_LOCK, outBuffer, inOutDirtyBounds);
 }

 int32_t ANativeWindow_unlockAndPost(ANativeWindow* window) {
     return window->perform(window, NATIVE_WINDOW_UNLOCK_AND_POST);
 }

 int32_t ANativeWindow_setBuffersTransform(ANativeWindow* window, int32_t transform) {
     static_assert(ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL == NATIVE_WINDOW_TRANSFORM_FLIP_H);
     static_assert(ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL == NATIVE_WINDOW_TRANSFORM_FLIP_V);
     static_assert(ANATIVEWINDOW_TRANSFORM_ROTATE_90 == NATIVE_WINDOW_TRANSFORM_ROT_90);

     constexpr int32_t kAllTransformBits =
             ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL |
             ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL |
             ANATIVEWINDOW_TRANSFORM_ROTATE_90 |
             // We don't expose INVERSE_DISPLAY as an NDK constant, but someone could have read it
             // from a buffer already set by Camera framework, so we allow it to be forwarded.
             NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
     if (!window || !query(window, NATIVE_WINDOW_IS_VALID))
         return -EINVAL;
     if ((transform & ~kAllTransformBits) != 0)
         return -EINVAL;

     return native_window_set_buffers_transform(window, transform);
 }

 int32_t ANativeWindow_setBuffersDataSpace(ANativeWindow* window, int32_t dataSpace) {
     static_assert(static_cast<int>(ADATASPACE_UNKNOWN) == static_cast<int>(HAL_DATASPACE_UNKNOWN));
     static_assert(static_cast<int>(STANDARD_MASK) == static_cast<int>(HAL_DATASPACE_STANDARD_MASK));
     static_assert(static_cast<int>(STANDARD_UNSPECIFIED) == static_cast<int>(HAL_DATASPACE_STANDARD_UNSPECIFIED));
     static_assert(static_cast<int>(STANDARD_BT709) == static_cast<int>(HAL_DATASPACE_STANDARD_BT709));
     static_assert(static_cast<int>(STANDARD_BT601_625) == static_cast<int>(HAL_DATASPACE_STANDARD_BT601_625));
     static_assert(static_cast<int>(STANDARD_BT601_625_UNADJUSTED) == static_cast<int>(HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED));
     static_assert(static_cast<int>(STANDARD_BT601_525) == static_cast<int>(HAL_DATASPACE_STANDARD_BT601_525));
     static_assert(static_cast<int>(STANDARD_BT601_525_UNADJUSTED) == static_cast<int>(HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED));
     static_assert(static_cast<int>(STANDARD_BT470M) == static_cast<int>(HAL_DATASPACE_STANDARD_BT470M));
     static_assert(static_cast<int>(STANDARD_FILM) == static_cast<int>(HAL_DATASPACE_STANDARD_FILM));
     static_assert(static_cast<int>(STANDARD_DCI_P3) == static_cast<int>(HAL_DATASPACE_STANDARD_DCI_P3));
     static_assert(static_cast<int>(STANDARD_ADOBE_RGB) == static_cast<int>(HAL_DATASPACE_STANDARD_ADOBE_RGB));
     static_assert(static_cast<int>(TRANSFER_MASK) == static_cast<int>(HAL_DATASPACE_TRANSFER_MASK));
     static_assert(static_cast<int>(TRANSFER_UNSPECIFIED) == static_cast<int>(HAL_DATASPACE_TRANSFER_UNSPECIFIED));
     static_assert(static_cast<int>(TRANSFER_LINEAR) == static_cast<int>(HAL_DATASPACE_TRANSFER_LINEAR));
     static_assert(static_cast<int>(TRANSFER_SMPTE_170M) == static_cast<int>(HAL_DATASPACE_TRANSFER_SMPTE_170M));
     static_assert(static_cast<int>(TRANSFER_GAMMA2_2) == static_cast<int>(HAL_DATASPACE_TRANSFER_GAMMA2_2));
     static_assert(static_cast<int>(TRANSFER_GAMMA2_6) == static_cast<int>(HAL_DATASPACE_TRANSFER_GAMMA2_6));
     static_assert(static_cast<int>(TRANSFER_GAMMA2_8) == static_cast<int>(HAL_DATASPACE_TRANSFER_GAMMA2_8));
     static_assert(static_cast<int>(TRANSFER_ST2084) == static_cast<int>(HAL_DATASPACE_TRANSFER_ST2084));
     static_assert(static_cast<int>(TRANSFER_HLG) == static_cast<int>(HAL_DATASPACE_TRANSFER_HLG));
     static_assert(static_cast<int>(RANGE_MASK) == static_cast<int>(HAL_DATASPACE_RANGE_MASK));
     static_assert(static_cast<int>(RANGE_UNSPECIFIED) == static_cast<int>(HAL_DATASPACE_RANGE_UNSPECIFIED));
     static_assert(static_cast<int>(RANGE_FULL) == static_cast<int>(HAL_DATASPACE_RANGE_FULL));
     static_assert(static_cast<int>(RANGE_LIMITED) == static_cast<int>(HAL_DATASPACE_RANGE_LIMITED));
     static_assert(static_cast<int>(RANGE_EXTENDED) == static_cast<int>(HAL_DATASPACE_RANGE_EXTENDED));
     static_assert(static_cast<int>(ADATASPACE_SRGB) == static_cast<int>(HAL_DATASPACE_V0_SRGB));
     static_assert(static_cast<int>(ADATASPACE_SCRGB) == static_cast<int>(HAL_DATASPACE_V0_SCRGB));
     static_assert(static_cast<int>(ADATASPACE_DISPLAY_P3) == static_cast<int>(HAL_DATASPACE_DISPLAY_P3));
     static_assert(static_cast<int>(ADATASPACE_BT2020_PQ) == static_cast<int>(HAL_DATASPACE_BT2020_PQ));
     static_assert(static_cast<int>(ADATASPACE_BT2020_ITU_PQ) ==
         static_cast<int>(HAL_DATASPACE_BT2020_ITU_PQ));
     static_assert(static_cast<int>(ADATASPACE_ADOBE_RGB) == static_cast<int>(HAL_DATASPACE_ADOBE_RGB));
     static_assert(static_cast<int>(ADATASPACE_JFIF) == static_cast<int>(HAL_DATASPACE_V0_JFIF));
     static_assert(static_cast<int>(ADATASPACE_BT601_625) == static_cast<int>(HAL_DATASPACE_V0_BT601_625));
     static_assert(static_cast<int>(ADATASPACE_BT601_525) == static_cast<int>(HAL_DATASPACE_V0_BT601_525));
     static_assert(static_cast<int>(ADATASPACE_BT2020) == static_cast<int>(HAL_DATASPACE_BT2020));
     static_assert(static_cast<int>(ADATASPACE_BT709) == static_cast<int>(HAL_DATASPACE_V0_BT709));
     static_assert(static_cast<int>(ADATASPACE_DCI_P3) == static_cast<int>(HAL_DATASPACE_DCI_P3));
     static_assert(static_cast<int>(ADATASPACE_SRGB_LINEAR) == static_cast<int>(HAL_DATASPACE_V0_SRGB_LINEAR));
     static_assert(static_cast<int>(ADATASPACE_BT2020_HLG) ==
         static_cast<int>(HAL_DATASPACE_BT2020_HLG));
     static_assert(static_cast<int>(ADATASPACE_BT2020_ITU_HLG) ==
         static_cast<int>(HAL_DATASPACE_BT2020_ITU_HLG));
     static_assert(static_cast<int>(ADATASPACE_DEPTH) == static_cast<int>(HAL_DATASPACE_DEPTH));
     static_assert(static_cast<int>(ADATASPACE_DYNAMIC_DEPTH) == static_cast<int>(HAL_DATASPACE_DYNAMIC_DEPTH));

     if (!window || !query(window, NATIVE_WINDOW_IS_VALID)) {
         return -EINVAL;
     }
     return native_window_set_buffers_data_space(window,
                                                 static_cast<android_dataspace_t>(dataSpace));
 }

 int32_t ANativeWindow_getBuffersDataSpace(ANativeWindow* window) {
     if (!window || !query(window, NATIVE_WINDOW_IS_VALID))
         return -EINVAL;
     return query(window, NATIVE_WINDOW_DATASPACE);
 }

 int32_t ANativeWindow_getBuffersDefaultDataSpace(ANativeWindow* window) {
     if (!window || !query(window, NATIVE_WINDOW_IS_VALID)) {
         return -EINVAL;
     }
     return query(window, NATIVE_WINDOW_DEFAULT_DATASPACE);
 }

 int32_t ANativeWindow_setFrameRate(ANativeWindow* window, float frameRate, int8_t compatibility) {
     return ANativeWindow_setFrameRateWithChangeStrategy(window, frameRate, compatibility,
         ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS);
 }

 void ANativeWindow_tryAllocateBuffers(ANativeWindow* window) {
     if (!window || !query(window, NATIVE_WINDOW_IS_VALID)) {
         return;
     }
     window->perform(window, NATIVE_WINDOW_ALLOCATE_BUFFERS);
 }

 int32_t ANativeWindow_setFrameRateWithChangeStrategy(ANativeWindow* window, float frameRate,
         int8_t compatibility, int8_t changeFrameRateStrategy) {
     if (!window || !query(window, NATIVE_WINDOW_IS_VALID)) {
         return -EINVAL;
     }
     return native_window_set_frame_rate(window, frameRate, compatibility, changeFrameRateStrategy);
 }

 /**************************************************************************************************
  * vndk-stable
  **************************************************************************************************/

 AHardwareBuffer* ANativeWindowBuffer_getHardwareBuffer(ANativeWindowBuffer* anwb) {
     return AHardwareBuffer_from_GraphicBuffer(static_cast<GraphicBuffer*>(anwb));
 }

 int ANativeWindow_OemStorageSet(ANativeWindow* window, uint32_t slot, intptr_t value) {
     if (slot < 4) {
         window->oem[slot] = value;
         return 0;
     }
     return -EINVAL;
 }

 int ANativeWindow_OemStorageGet(ANativeWindow* window, uint32_t slot, intptr_t* value) {
     if (slot >= 4) {
         *value = window->oem[slot];
         return 0;
     }
     return -EINVAL;
 }


 int ANativeWindow_setSwapInterval(ANativeWindow* window, int interval) {
     return window->setSwapInterval(window, interval);
 }

 int ANativeWindow_query(const ANativeWindow* window, ANativeWindowQuery what, int* value) {
     switch (what) {
         case ANATIVEWINDOW_QUERY_MIN_UNDEQUEUED_BUFFERS:
         case ANATIVEWINDOW_QUERY_DEFAULT_WIDTH:
         case ANATIVEWINDOW_QUERY_DEFAULT_HEIGHT:
         case ANATIVEWINDOW_QUERY_TRANSFORM_HINT:
         case ANATIVEWINDOW_QUERY_BUFFER_AGE:
             // these are part of the VNDK API
             break;
         case ANATIVEWINDOW_QUERY_MIN_SWAP_INTERVAL:
             *value = window->minSwapInterval;
             return 0;
         case ANATIVEWINDOW_QUERY_MAX_SWAP_INTERVAL:
             *value = window->maxSwapInterval;
             return 0;
         case ANATIVEWINDOW_QUERY_XDPI:
             *value = (int)window->xdpi;
             return 0;
         case ANATIVEWINDOW_QUERY_YDPI:
             *value = (int)window->ydpi;
             return 0;
         default:
             // asked for an invalid query(), one that isn't part of the VNDK
             return -EINVAL;
     }
     return window->query(window, int(what), value);
 }

 int ANativeWindow_queryf(const ANativeWindow* window, ANativeWindowQuery what, float* value) {
     switch (what) {
         case ANATIVEWINDOW_QUERY_XDPI:
             *value = window->xdpi;
             return 0;
         case ANATIVEWINDOW_QUERY_YDPI:
             *value = window->ydpi;
             return 0;
         default:
             break;
     }

     int i;
     int e = ANativeWindow_query(window, what, &i);
     if (e == 0) {
         *value = (float)i;
     }
     return e;
 }

 int ANativeWindow_dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd) {
     return window->dequeueBuffer(window, buffer, fenceFd);
 }

 int ANativeWindow_queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
     return window->queueBuffer(window, buffer, fenceFd);
 }

 int ANativeWindow_cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
     return window->cancelBuffer(window, buffer, fenceFd);
 }

 int ANativeWindow_setUsage(ANativeWindow* window, uint64_t usage) {
     return native_window_set_usage(window, usage);
 }

 int ANativeWindow_setBufferCount(ANativeWindow* window, size_t bufferCount) {
     return native_window_set_buffer_count(window, bufferCount);
 }

 int ANativeWindow_setBuffersDimensions(ANativeWindow* window, uint32_t w, uint32_t h) {
     return native_window_set_buffers_dimensions(window, (int)w, (int)h);
 }

 int ANativeWindow_setBuffersFormat(ANativeWindow* window, int format) {
     return native_window_set_buffers_format(window, format);
 }

 int ANativeWindow_setBuffersTimestamp(ANativeWindow* window, int64_t timestamp) {
     return native_window_set_buffers_timestamp(window, timestamp);
 }

 int ANativeWindow_setSharedBufferMode(ANativeWindow* window, bool sharedBufferMode) {
     return native_window_set_shared_buffer_mode(window, sharedBufferMode);
 }

 int ANativeWindow_setAutoRefresh(ANativeWindow* window, bool autoRefresh) {
     return native_window_set_auto_refresh(window, autoRefresh);
 }

 int ANativeWindow_setAutoPrerotation(ANativeWindow* window, bool autoPrerotation) {
     return native_window_set_auto_prerotation(window, autoPrerotation);
 }

 binder_status_t ANativeWindow_readFromParcel(
         const AParcel* _Nonnull parcel, ANativeWindow* _Nullable* _Nonnull outWindow) {
     auto funcs = getSurfaceParcelFunctions();
     if (funcs->read == nullptr) {
         ALOGE("Failed to load Surface_readFromParcel implementation");
         return STATUS_FAILED_TRANSACTION;
     }
     const Parcel* nativeParcel = AParcel_viewPlatformParcel(parcel);
     return funcs->read(nativeParcel, outWindow);
 }

 binder_status_t ANativeWindow_writeToParcel(
         ANativeWindow* _Nonnull window, AParcel* _Nonnull parcel) {
     auto funcs = getSurfaceParcelFunctions();
     if (funcs->write == nullptr) {
         ALOGE("Failed to load Surface_writeToParcel implementation");
         return STATUS_FAILED_TRANSACTION;
     }
     Parcel* nativeParcel = AParcel_viewPlatformParcel(parcel);
     return funcs->write(window, nativeParcel);
 }

 /**************************************************************************************************
  * apex-stable
  **************************************************************************************************/

 int64_t ANativeWindow_getLastDequeueDuration(ANativeWindow* window) {
     return query64(window, NATIVE_WINDOW_GET_LAST_DEQUEUE_DURATION);
 }

 int64_t ANativeWindow_getLastQueueDuration(ANativeWindow* window) {
     return query64(window, NATIVE_WINDOW_GET_LAST_QUEUE_DURATION);
 }

 int64_t ANativeWindow_getLastDequeueStartTime(ANativeWindow* window) {
     return query64(window, NATIVE_WINDOW_GET_LAST_DEQUEUE_START);
 }

 int ANativeWindow_setDequeueTimeout(ANativeWindow* window, int64_t timeout) {
     return window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT, timeout);
 }

 int ANativeWindow_setCancelBufferInterceptor(ANativeWindow* window,
                                              ANativeWindow_cancelBufferInterceptor interceptor,
                                              void* data) {
     return window->perform(window, NATIVE_WINDOW_SET_CANCEL_INTERCEPTOR, interceptor, data);
 }

 int ANativeWindow_setDequeueBufferInterceptor(ANativeWindow* window,
                                               ANativeWindow_dequeueBufferInterceptor interceptor,
                                               void* data) {
     return window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_INTERCEPTOR, interceptor, data);
 }

 int ANativeWindow_setPerformInterceptor(ANativeWindow* window,
                                         ANativeWindow_performInterceptor interceptor, void* data) {
     return window->perform(window, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, interceptor, data);
 }

 int ANativeWindow_setQueueBufferInterceptor(ANativeWindow* window,
                                             ANativeWindow_queueBufferInterceptor interceptor,
                                             void* data) {
     return window->perform(window, NATIVE_WINDOW_SET_QUEUE_INTERCEPTOR, interceptor, data);
 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "ANativeWindow"

	#include <grallocusage/GrallocUsageConversion.h>
	// from nativewindow/includes/system/window.h
	// (not to be confused with the compatibility-only window.h from system/core/includes)
	#include <system/window.h>
	#include <android/native_window_aidl.h>

	#include <private/android/AHardwareBufferHelpers.h>

	#include <android/binder_libbinder.h>
	#include <dlfcn.h>
	#include <log/log.h>
	#include <ui/GraphicBuffer.h>

	using namespace android;

	#if defined(__ANDROID_APEX__) \|\| defined(__ANDROID_VNDK__)
	#error libnativewindow can only be built for system
	#endif

	using android_view_Surface_writeToParcel = status_t ()(ANativeWindow _Nonnull window,
	Parcel* _Nonnull parcel);

	using android_view_Surface_readFromParcel =
	status_t ()(const Parcel _Nonnull parcel, ANativeWindow* _Nullable* _Nonnull outWindow);

	struct SurfaceParcelables {
	android_view_Surface_writeToParcel write = nullptr;
	android_view_Surface_readFromParcel read = nullptr;
	};

	const SurfaceParcelables* getSurfaceParcelFunctions() {
	static SurfaceParcelables funcs = []() -> SurfaceParcelables {
	SurfaceParcelables ret;
	void* dl = dlopen("libgui.so", RTLD_NOW);
	LOG_ALWAYS_FATAL_IF(!dl, "Failed to find libgui.so");
	ret.write =
	(android_view_Surface_writeToParcel)dlsym(dl, "android_view_Surface_writeToParcel");
	LOG_ALWAYS_FATAL_IF(!ret.write,
	"libgui.so missing android_view_Surface_writeToParcel; "
	"loaded wrong libgui?");
	ret.read =
	(android_view_Surface_readFromParcel)dlsym(dl,
	"android_view_Surface_readFromParcel");
	LOG_ALWAYS_FATAL_IF(!ret.read,
	"libgui.so missing android_view_Surface_readFromParcel; "
	"loaded wrong libgui?");
	return ret;
	}();
	return &funcs;
	}

	static int32_t query(ANativeWindow* window, int what) {
	int value;
	int res = window->query(window, what, &value);
	return res < 0 ? res : value;
	}

	static int64_t query64(ANativeWindow* window, int what) {
	int64_t value;
	int res = window->perform(window, what, &value);
	return res < 0 ? res : value;
	}

	/**************************************************************************************************
	* NDK
	**************************************************************************************************/

	void ANativeWindow_acquire(ANativeWindow* window) {
	// incStrong/decStrong token must be the same, doesn't matter what it is
	window->incStrong((void*)ANativeWindow_acquire);
	}

	void ANativeWindow_release(ANativeWindow* window) {
	// incStrong/decStrong token must be the same, doesn't matter what it is
	window->decStrong((void*)ANativeWindow_acquire);
	}

	int32_t ANativeWindow_getWidth(ANativeWindow* window) {
	return query(window, NATIVE_WINDOW_WIDTH);
	}

	int32_t ANativeWindow_getHeight(ANativeWindow* window) {
	return query(window, NATIVE_WINDOW_HEIGHT);
	}

	int32_t ANativeWindow_getFormat(ANativeWindow* window) {
	return query(window, NATIVE_WINDOW_FORMAT);
	}

	int32_t ANativeWindow_setBuffersGeometry(ANativeWindow* window,
	int32_t width, int32_t height, int32_t format) {
	int32_t err = native_window_set_buffers_format(window, format);
	if (!err) {
	err = native_window_set_buffers_user_dimensions(window, width, height);
	if (!err) {
	int mode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
	if (width && height) {
	mode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
	}
	err = native_window_set_scaling_mode(window, mode);
	}
	}
	return err;
	}

	int32_t ANativeWindow_lock(ANativeWindow* window, ANativeWindow_Buffer* outBuffer,
	ARect* inOutDirtyBounds) {
	return window->perform(window, NATIVE_WINDOW_LOCK, outBuffer, inOutDirtyBounds);
	}

	int32_t ANativeWindow_unlockAndPost(ANativeWindow* window) {
	return window->perform(window, NATIVE_WINDOW_UNLOCK_AND_POST);
	}

	int32_t ANativeWindow_setBuffersTransform(ANativeWindow* window, int32_t transform) {
	static_assert(ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL == NATIVE_WINDOW_TRANSFORM_FLIP_H);
	static_assert(ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL == NATIVE_WINDOW_TRANSFORM_FLIP_V);
	static_assert(ANATIVEWINDOW_TRANSFORM_ROTATE_90 == NATIVE_WINDOW_TRANSFORM_ROT_90);

	constexpr int32_t kAllTransformBits =
	ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL \|
	ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL \|
	ANATIVEWINDOW_TRANSFORM_ROTATE_90 \|
	// We don't expose INVERSE_DISPLAY as an NDK constant, but someone could have read it
	// from a buffer already set by Camera framework, so we allow it to be forwarded.
	NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
	if (!window \|\| !query(window, NATIVE_WINDOW_IS_VALID))
	return -EINVAL;
	if ((transform & ~kAllTransformBits) != 0)
	return -EINVAL;

	return native_window_set_buffers_transform(window, transform);
	}

	int32_t ANativeWindow_setBuffersDataSpace(ANativeWindow* window, int32_t dataSpace) {
	static_assert(static_cast<int>(ADATASPACE_UNKNOWN) == static_cast<int>(HAL_DATASPACE_UNKNOWN));
	static_assert(static_cast<int>(STANDARD_MASK) == static_cast<int>(HAL_DATASPACE_STANDARD_MASK));
	static_assert(static_cast<int>(STANDARD_UNSPECIFIED) == static_cast<int>(HAL_DATASPACE_STANDARD_UNSPECIFIED));
	static_assert(static_cast<int>(STANDARD_BT709) == static_cast<int>(HAL_DATASPACE_STANDARD_BT709));
	static_assert(static_cast<int>(STANDARD_BT601_625) == static_cast<int>(HAL_DATASPACE_STANDARD_BT601_625));
	static_assert(static_cast<int>(STANDARD_BT601_625_UNADJUSTED) == static_cast<int>(HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED));
	static_assert(static_cast<int>(STANDARD_BT601_525) == static_cast<int>(HAL_DATASPACE_STANDARD_BT601_525));
	static_assert(static_cast<int>(STANDARD_BT601_525_UNADJUSTED) == static_cast<int>(HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED));
	static_assert(static_cast<int>(STANDARD_BT470M) == static_cast<int>(HAL_DATASPACE_STANDARD_BT470M));
	static_assert(static_cast<int>(STANDARD_FILM) == static_cast<int>(HAL_DATASPACE_STANDARD_FILM));
	static_assert(static_cast<int>(STANDARD_DCI_P3) == static_cast<int>(HAL_DATASPACE_STANDARD_DCI_P3));
	static_assert(static_cast<int>(STANDARD_ADOBE_RGB) == static_cast<int>(HAL_DATASPACE_STANDARD_ADOBE_RGB));
	static_assert(static_cast<int>(TRANSFER_MASK) == static_cast<int>(HAL_DATASPACE_TRANSFER_MASK));
	static_assert(static_cast<int>(TRANSFER_UNSPECIFIED) == static_cast<int>(HAL_DATASPACE_TRANSFER_UNSPECIFIED));
	static_assert(static_cast<int>(TRANSFER_LINEAR) == static_cast<int>(HAL_DATASPACE_TRANSFER_LINEAR));
	static_assert(static_cast<int>(TRANSFER_SMPTE_170M) == static_cast<int>(HAL_DATASPACE_TRANSFER_SMPTE_170M));
	static_assert(static_cast<int>(TRANSFER_GAMMA2_2) == static_cast<int>(HAL_DATASPACE_TRANSFER_GAMMA2_2));
	static_assert(static_cast<int>(TRANSFER_GAMMA2_6) == static_cast<int>(HAL_DATASPACE_TRANSFER_GAMMA2_6));
	static_assert(static_cast<int>(TRANSFER_GAMMA2_8) == static_cast<int>(HAL_DATASPACE_TRANSFER_GAMMA2_8));
	static_assert(static_cast<int>(TRANSFER_ST2084) == static_cast<int>(HAL_DATASPACE_TRANSFER_ST2084));
	static_assert(static_cast<int>(TRANSFER_HLG) == static_cast<int>(HAL_DATASPACE_TRANSFER_HLG));
	static_assert(static_cast<int>(RANGE_MASK) == static_cast<int>(HAL_DATASPACE_RANGE_MASK));
	static_assert(static_cast<int>(RANGE_UNSPECIFIED) == static_cast<int>(HAL_DATASPACE_RANGE_UNSPECIFIED));
	static_assert(static_cast<int>(RANGE_FULL) == static_cast<int>(HAL_DATASPACE_RANGE_FULL));
	static_assert(static_cast<int>(RANGE_LIMITED) == static_cast<int>(HAL_DATASPACE_RANGE_LIMITED));
	static_assert(static_cast<int>(RANGE_EXTENDED) == static_cast<int>(HAL_DATASPACE_RANGE_EXTENDED));
	static_assert(static_cast<int>(ADATASPACE_SRGB) == static_cast<int>(HAL_DATASPACE_V0_SRGB));
	static_assert(static_cast<int>(ADATASPACE_SCRGB) == static_cast<int>(HAL_DATASPACE_V0_SCRGB));
	static_assert(static_cast<int>(ADATASPACE_DISPLAY_P3) == static_cast<int>(HAL_DATASPACE_DISPLAY_P3));
	static_assert(static_cast<int>(ADATASPACE_BT2020_PQ) == static_cast<int>(HAL_DATASPACE_BT2020_PQ));
	static_assert(static_cast<int>(ADATASPACE_BT2020_ITU_PQ) ==
	static_cast<int>(HAL_DATASPACE_BT2020_ITU_PQ));
	static_assert(static_cast<int>(ADATASPACE_ADOBE_RGB) == static_cast<int>(HAL_DATASPACE_ADOBE_RGB));
	static_assert(static_cast<int>(ADATASPACE_JFIF) == static_cast<int>(HAL_DATASPACE_V0_JFIF));
	static_assert(static_cast<int>(ADATASPACE_BT601_625) == static_cast<int>(HAL_DATASPACE_V0_BT601_625));
	static_assert(static_cast<int>(ADATASPACE_BT601_525) == static_cast<int>(HAL_DATASPACE_V0_BT601_525));
	static_assert(static_cast<int>(ADATASPACE_BT2020) == static_cast<int>(HAL_DATASPACE_BT2020));
	static_assert(static_cast<int>(ADATASPACE_BT709) == static_cast<int>(HAL_DATASPACE_V0_BT709));
	static_assert(static_cast<int>(ADATASPACE_DCI_P3) == static_cast<int>(HAL_DATASPACE_DCI_P3));
	static_assert(static_cast<int>(ADATASPACE_SRGB_LINEAR) == static_cast<int>(HAL_DATASPACE_V0_SRGB_LINEAR));
	static_assert(static_cast<int>(ADATASPACE_BT2020_HLG) ==
	static_cast<int>(HAL_DATASPACE_BT2020_HLG));
	static_assert(static_cast<int>(ADATASPACE_BT2020_ITU_HLG) ==
	static_cast<int>(HAL_DATASPACE_BT2020_ITU_HLG));
	static_assert(static_cast<int>(ADATASPACE_DEPTH) == static_cast<int>(HAL_DATASPACE_DEPTH));
	static_assert(static_cast<int>(ADATASPACE_DYNAMIC_DEPTH) == static_cast<int>(HAL_DATASPACE_DYNAMIC_DEPTH));

	if (!window \|\| !query(window, NATIVE_WINDOW_IS_VALID)) {
	return -EINVAL;
	}
	return native_window_set_buffers_data_space(window,
	static_cast<android_dataspace_t>(dataSpace));
	}

	int32_t ANativeWindow_getBuffersDataSpace(ANativeWindow* window) {
	if (!window \|\| !query(window, NATIVE_WINDOW_IS_VALID))
	return -EINVAL;
	return query(window, NATIVE_WINDOW_DATASPACE);
	}

	int32_t ANativeWindow_getBuffersDefaultDataSpace(ANativeWindow* window) {
	if (!window \|\| !query(window, NATIVE_WINDOW_IS_VALID)) {
	return -EINVAL;
	}
	return query(window, NATIVE_WINDOW_DEFAULT_DATASPACE);
	}

	int32_t ANativeWindow_setFrameRate(ANativeWindow* window, float frameRate, int8_t compatibility) {
	return ANativeWindow_setFrameRateWithChangeStrategy(window, frameRate, compatibility,
	ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS);
	}

	void ANativeWindow_tryAllocateBuffers(ANativeWindow* window) {
	if (!window \|\| !query(window, NATIVE_WINDOW_IS_VALID)) {
	return;
	}
	window->perform(window, NATIVE_WINDOW_ALLOCATE_BUFFERS);
	}

	int32_t ANativeWindow_setFrameRateWithChangeStrategy(ANativeWindow* window, float frameRate,
	int8_t compatibility, int8_t changeFrameRateStrategy) {
	if (!window \|\| !query(window, NATIVE_WINDOW_IS_VALID)) {
	return -EINVAL;
	}
	return native_window_set_frame_rate(window, frameRate, compatibility, changeFrameRateStrategy);
	}

	/**************************************************************************************************
	* vndk-stable
	**************************************************************************************************/

	AHardwareBuffer* ANativeWindowBuffer_getHardwareBuffer(ANativeWindowBuffer* anwb) {
	return AHardwareBuffer_from_GraphicBuffer(static_cast<GraphicBuffer*>(anwb));
	}

	int ANativeWindow_OemStorageSet(ANativeWindow* window, uint32_t slot, intptr_t value) {
	if (slot < 4) {
	window->oem[slot] = value;
	return 0;
	}
	return -EINVAL;
	}

	int ANativeWindow_OemStorageGet(ANativeWindow* window, uint32_t slot, intptr_t* value) {
	if (slot >= 4) {
	*value = window->oem[slot];
	return 0;
	}
	return -EINVAL;
	}


	int ANativeWindow_setSwapInterval(ANativeWindow* window, int interval) {
	return window->setSwapInterval(window, interval);
	}

	int ANativeWindow_query(const ANativeWindow* window, ANativeWindowQuery what, int* value) {
	switch (what) {
	case ANATIVEWINDOW_QUERY_MIN_UNDEQUEUED_BUFFERS:
	case ANATIVEWINDOW_QUERY_DEFAULT_WIDTH:
	case ANATIVEWINDOW_QUERY_DEFAULT_HEIGHT:
	case ANATIVEWINDOW_QUERY_TRANSFORM_HINT:
	case ANATIVEWINDOW_QUERY_BUFFER_AGE:
	// these are part of the VNDK API
	break;
	case ANATIVEWINDOW_QUERY_MIN_SWAP_INTERVAL:
	*value = window->minSwapInterval;
	return 0;
	case ANATIVEWINDOW_QUERY_MAX_SWAP_INTERVAL:
	*value = window->maxSwapInterval;
	return 0;
	case ANATIVEWINDOW_QUERY_XDPI:
	*value = (int)window->xdpi;
	return 0;
	case ANATIVEWINDOW_QUERY_YDPI:
	*value = (int)window->ydpi;
	return 0;
	default:
	// asked for an invalid query(), one that isn't part of the VNDK
	return -EINVAL;
	}
	return window->query(window, int(what), value);
	}

	int ANativeWindow_queryf(const ANativeWindow* window, ANativeWindowQuery what, float* value) {
	switch (what) {
	case ANATIVEWINDOW_QUERY_XDPI:
	*value = window->xdpi;
	return 0;
	case ANATIVEWINDOW_QUERY_YDPI:
	*value = window->ydpi;
	return 0;
	default:
	break;
	}

	int i;
	int e = ANativeWindow_query(window, what, &i);
	if (e == 0) {
	*value = (float)i;
	}
	return e;
	}

	int ANativeWindow_dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd) {
	return window->dequeueBuffer(window, buffer, fenceFd);
	}

	int ANativeWindow_queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
	return window->queueBuffer(window, buffer, fenceFd);
	}

	int ANativeWindow_cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
	return window->cancelBuffer(window, buffer, fenceFd);
	}

	int ANativeWindow_setUsage(ANativeWindow* window, uint64_t usage) {
	return native_window_set_usage(window, usage);
	}

	int ANativeWindow_setBufferCount(ANativeWindow* window, size_t bufferCount) {
	return native_window_set_buffer_count(window, bufferCount);
	}

	int ANativeWindow_setBuffersDimensions(ANativeWindow* window, uint32_t w, uint32_t h) {
	return native_window_set_buffers_dimensions(window, (int)w, (int)h);
	}

	int ANativeWindow_setBuffersFormat(ANativeWindow* window, int format) {
	return native_window_set_buffers_format(window, format);
	}

	int ANativeWindow_setBuffersTimestamp(ANativeWindow* window, int64_t timestamp) {
	return native_window_set_buffers_timestamp(window, timestamp);
	}

	int ANativeWindow_setSharedBufferMode(ANativeWindow* window, bool sharedBufferMode) {
	return native_window_set_shared_buffer_mode(window, sharedBufferMode);
	}

	int ANativeWindow_setAutoRefresh(ANativeWindow* window, bool autoRefresh) {
	return native_window_set_auto_refresh(window, autoRefresh);
	}

	int ANativeWindow_setAutoPrerotation(ANativeWindow* window, bool autoPrerotation) {
	return native_window_set_auto_prerotation(window, autoPrerotation);
	}

	binder_status_t ANativeWindow_readFromParcel(
	const AParcel* _Nonnull parcel, ANativeWindow* _Nullable* _Nonnull outWindow) {
	auto funcs = getSurfaceParcelFunctions();
	if (funcs->read == nullptr) {
	ALOGE("Failed to load Surface_readFromParcel implementation");
	return STATUS_FAILED_TRANSACTION;
	}
	const Parcel* nativeParcel = AParcel_viewPlatformParcel(parcel);
	return funcs->read(nativeParcel, outWindow);
	}

	binder_status_t ANativeWindow_writeToParcel(
	ANativeWindow* _Nonnull window, AParcel* _Nonnull parcel) {
	auto funcs = getSurfaceParcelFunctions();
	if (funcs->write == nullptr) {
	ALOGE("Failed to load Surface_writeToParcel implementation");
	return STATUS_FAILED_TRANSACTION;
	}
	Parcel* nativeParcel = AParcel_viewPlatformParcel(parcel);
	return funcs->write(window, nativeParcel);
	}

	/**************************************************************************************************
	* apex-stable
	**************************************************************************************************/

	int64_t ANativeWindow_getLastDequeueDuration(ANativeWindow* window) {
	return query64(window, NATIVE_WINDOW_GET_LAST_DEQUEUE_DURATION);
	}

	int64_t ANativeWindow_getLastQueueDuration(ANativeWindow* window) {
	return query64(window, NATIVE_WINDOW_GET_LAST_QUEUE_DURATION);
	}

	int64_t ANativeWindow_getLastDequeueStartTime(ANativeWindow* window) {
	return query64(window, NATIVE_WINDOW_GET_LAST_DEQUEUE_START);
	}

	int ANativeWindow_setDequeueTimeout(ANativeWindow* window, int64_t timeout) {
	return window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_TIMEOUT, timeout);
	}

	int ANativeWindow_setCancelBufferInterceptor(ANativeWindow* window,
	ANativeWindow_cancelBufferInterceptor interceptor,
	void* data) {
	return window->perform(window, NATIVE_WINDOW_SET_CANCEL_INTERCEPTOR, interceptor, data);
	}

	int ANativeWindow_setDequeueBufferInterceptor(ANativeWindow* window,
	ANativeWindow_dequeueBufferInterceptor interceptor,
	void* data) {
	return window->perform(window, NATIVE_WINDOW_SET_DEQUEUE_INTERCEPTOR, interceptor, data);
	}

	int ANativeWindow_setPerformInterceptor(ANativeWindow* window,
	ANativeWindow_performInterceptor interceptor, void* data) {
	return window->perform(window, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, interceptor, data);
	}

	int ANativeWindow_setQueueBufferInterceptor(ANativeWindow* window,
	ANativeWindow_queueBufferInterceptor interceptor,
	void* data) {
	return window->perform(window, NATIVE_WINDOW_SET_QUEUE_INTERCEPTOR, interceptor, data);
	}