diff options
51 files changed, 7714 insertions, 9 deletions
diff --git a/bin/update-android-headers.sh b/bin/update-android-headers.sh new file mode 100755 index 00000000000..df5cf16a328 --- /dev/null +++ b/bin/update-android-headers.sh @@ -0,0 +1,53 @@ +#!/bin/sh + +set -eu + +if [ ! -e .git ]; then + echo must run from top-level directory; + exit 1 +fi + +if [ ! -d platform-hardware-libhardware ]; then + git clone --depth 1 https://android.googlesource.com/platform/hardware/libhardware platform-hardware-libhardware + git clone --depth 1 https://android.googlesource.com/platform/system/core platform-system-core + git clone --depth 1 https://android.googlesource.com/platform/frameworks/native platform-frameworks-native +fi + +dest=include/android_stub + +rm -rf ${dest} +mkdir ${dest} + + +# These directories contains mostly only the files we need, so copy wholesale + +cp -av platform-frameworks-native/libs/nativewindow/include/vndk \ + platform-system-core/libsync/include/sync \ + platform-system-core/libsync/include/ndk \ + platform-system-core/libbacktrace/include/backtrace \ + platform-system-core/libsystem/include/system \ + platform-system-core/liblog/include/log \ + platform-frameworks-native/libs/nativewindow/include/system \ + platform-frameworks-native/libs/nativebase/include/nativebase \ + ${dest} + + +# We only need a few files from these big directories so just copy those + +mkdir ${dest}/hardware +cp -av platform-hardware-libhardware/include/hardware/{hardware,gralloc,fb}.h ${dest}/hardware +cp -av platform-frameworks-native/vulkan/include/hardware/hwvulkan.h ${dest}/hardware + +mkdir ${dest}/cutils +cp -av platform-system-core/libcutils/include/cutils/{log,native_handle,properties}.h ${dest}/cutils + + +# include/android has files from a few different projects + +mkdir ${dest}/android +cp -av platform-frameworks-native/libs/nativewindow/include/android/* \ + platform-frameworks-native/libs/arect/include/android/* \ + platform-system-core/liblog/include/android/* \ + platform-system-core/libsync/include/android/* \ + ${dest}/android + diff --git a/include/android_stub/android/data_space.h b/include/android_stub/android/data_space.h new file mode 100644 index 00000000000..2899bcf1f79 --- /dev/null +++ b/include/android_stub/android/data_space.h @@ -0,0 +1,108 @@ +/* + * Copyright 2018 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. + */ + +/** + * @file data_space.h + */ + +#ifndef ANDROID_DATA_SPACE_H +#define ANDROID_DATA_SPACE_H + +#include <inttypes.h> + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +/** + * ADataSpace. + */ +enum ADataSpace { + /** + * Default-assumption data space, when not explicitly specified. + * + * It is safest to assume the buffer is an image with sRGB primaries and + * encoding ranges, but the consumer and/or the producer of the data may + * simply be using defaults. No automatic gamma transform should be + * expected, except for a possible display gamma transform when drawn to a + * screen. + */ + ADATASPACE_UNKNOWN = 0, + + /** + * scRGB linear encoding: + * + * The red, green, and blue components are stored in extended sRGB space, + * but are linear, not gamma-encoded. + * The RGB primaries and the white point are the same as BT.709. + * + * The values are floating point. + * A pixel value of 1.0, 1.0, 1.0 corresponds to sRGB white (D65) at 80 nits. + * Values beyond the range [0.0 - 1.0] would correspond to other colors + * spaces and/or HDR content. + */ + ADATASPACE_SCRGB_LINEAR = 406913024, // STANDARD_BT709 | TRANSFER_LINEAR | RANGE_EXTENDED + + /** + * sRGB gamma encoding: + * + * The red, green and blue components are stored in sRGB space, and + * converted to linear space when read, using the SRGB transfer function + * for each of the R, G and B components. When written, the inverse + * transformation is performed. + * + * The alpha component, if present, is always stored in linear space and + * is left unmodified when read or written. + * + * Use full range and BT.709 standard. + */ + ADATASPACE_SRGB = 142671872, // STANDARD_BT709 | TRANSFER_SRGB | RANGE_FULL + + /** + * scRGB: + * + * The red, green, and blue components are stored in extended sRGB space, + * and gamma-encoded using the SRGB transfer function. + * The RGB primaries and the white point are the same as BT.709. + * + * The values are floating point. + * A pixel value of 1.0, 1.0, 1.0 corresponds to sRGB white (D65) at 80 nits. + * Values beyond the range [0.0 - 1.0] would correspond to other colors + * spaces and/or HDR content. + */ + ADATASPACE_SCRGB = 411107328, // STANDARD_BT709 | TRANSFER_SRGB | RANGE_EXTENDED + + /** + * Display P3 + * + * Use same primaries and white-point as DCI-P3 + * but sRGB transfer function. + */ + ADATASPACE_DISPLAY_P3 = 143261696, // STANDARD_DCI_P3 | TRANSFER_SRGB | RANGE_FULL + + /** + * ITU-R Recommendation 2020 (BT.2020) + * + * Ultra High-definition television + * + * Use full range, SMPTE 2084 (PQ) transfer and BT2020 standard + */ + ADATASPACE_BT2020_PQ = 163971072, // STANDARD_BT2020 | TRANSFER_ST2084 | RANGE_FULL +}; + +__END_DECLS + +#endif // ANDROID_DATA_SPACE_H diff --git a/include/android_stub/android/hardware_buffer.h b/include/android_stub/android/hardware_buffer.h new file mode 100644 index 00000000000..ae5e47ba97f --- /dev/null +++ b/include/android_stub/android/hardware_buffer.h @@ -0,0 +1,549 @@ +/* + * Copyright 2017 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. + */ + +/** + * @file hardware_buffer.h + * @brief API for native hardware buffers. + */ +/** + * @defgroup AHardwareBuffer Native Hardware Buffer + * + * AHardwareBuffer objects represent chunks of memory that can be + * accessed by various hardware components in the system. It can be + * easily converted to the Java counterpart + * android.hardware.HardwareBuffer and passed between processes using + * Binder. All operations involving AHardwareBuffer and HardwareBuffer + * are zero-copy, i.e., passing AHardwareBuffer to another process + * creates a shared view of the same region of memory. + * + * AHardwareBuffers can be bound to EGL/OpenGL and Vulkan primitives. + * For EGL, use the extension function eglGetNativeClientBufferANDROID + * to obtain an EGLClientBuffer and pass it directly to + * eglCreateImageKHR. Refer to the EGL extensions + * EGL_ANDROID_get_native_client_buffer and + * EGL_ANDROID_image_native_buffer for more information. In Vulkan, + * the contents of the AHardwareBuffer can be accessed as external + * memory. See the VK_ANDROID_external_memory_android_hardware_buffer + * extension for details. + * + * @{ + */ + +#ifndef ANDROID_HARDWARE_BUFFER_H +#define ANDROID_HARDWARE_BUFFER_H + +#include <inttypes.h> + +#include <sys/cdefs.h> + +#include <android/rect.h> + +__BEGIN_DECLS + +/** + * Buffer pixel formats. + */ +enum AHardwareBuffer_Format { + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_R8G8B8A8_UNORM + * OpenGL ES: GL_RGBA8 + */ + AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM = 1, + + /** + * 32 bits per pixel, 8 bits per channel format where alpha values are + * ignored (always opaque). + * Corresponding formats: + * Vulkan: VK_FORMAT_R8G8B8A8_UNORM + * OpenGL ES: GL_RGB8 + */ + AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM = 2, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_R8G8B8_UNORM + * OpenGL ES: GL_RGB8 + */ + AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM = 3, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_R5G6B5_UNORM_PACK16 + * OpenGL ES: GL_RGB565 + */ + AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM = 4, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_R16G16B16A16_SFLOAT + * OpenGL ES: GL_RGBA16F + */ + AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT = 0x16, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_A2B10G10R10_UNORM_PACK32 + * OpenGL ES: GL_RGB10_A2 + */ + AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM = 0x2b, + + /** + * Opaque binary blob format. + * Must have height 1 and one layer, with width equal to the buffer + * size in bytes. Corresponds to Vulkan buffers and OpenGL buffer + * objects. Can be bound to the latter using GL_EXT_external_buffer. + */ + AHARDWAREBUFFER_FORMAT_BLOB = 0x21, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_D16_UNORM + * OpenGL ES: GL_DEPTH_COMPONENT16 + */ + AHARDWAREBUFFER_FORMAT_D16_UNORM = 0x30, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_X8_D24_UNORM_PACK32 + * OpenGL ES: GL_DEPTH_COMPONENT24 + */ + AHARDWAREBUFFER_FORMAT_D24_UNORM = 0x31, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_D24_UNORM_S8_UINT + * OpenGL ES: GL_DEPTH24_STENCIL8 + */ + AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT = 0x32, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_D32_SFLOAT + * OpenGL ES: GL_DEPTH_COMPONENT32F + */ + AHARDWAREBUFFER_FORMAT_D32_FLOAT = 0x33, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_D32_SFLOAT_S8_UINT + * OpenGL ES: GL_DEPTH32F_STENCIL8 + */ + AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT = 0x34, + + /** + * Corresponding formats: + * Vulkan: VK_FORMAT_S8_UINT + * OpenGL ES: GL_STENCIL_INDEX8 + */ + AHARDWAREBUFFER_FORMAT_S8_UINT = 0x35, + + /** + * YUV 420 888 format. + * Must have an even width and height. Can be accessed in OpenGL + * shaders through an external sampler. Does not support mip-maps + * cube-maps or multi-layered textures. + */ + AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 = 0x23, +}; + +/** + * Buffer usage flags, specifying how the buffer will be accessed. + */ +enum AHardwareBuffer_UsageFlags { + /// The buffer will never be locked for direct CPU reads using the + /// AHardwareBuffer_lock() function. Note that reading the buffer + /// using OpenGL or Vulkan functions or memory mappings is still + /// allowed. + AHARDWAREBUFFER_USAGE_CPU_READ_NEVER = 0UL, + /// The buffer will sometimes be locked for direct CPU reads using + /// the AHardwareBuffer_lock() function. Note that reading the + /// buffer using OpenGL or Vulkan functions or memory mappings + /// does not require the presence of this flag. + AHARDWAREBUFFER_USAGE_CPU_READ_RARELY = 2UL, + /// The buffer will often be locked for direct CPU reads using + /// the AHardwareBuffer_lock() function. Note that reading the + /// buffer using OpenGL or Vulkan functions or memory mappings + /// does not require the presence of this flag. + AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN = 3UL, + /// CPU read value mask. + AHARDWAREBUFFER_USAGE_CPU_READ_MASK = 0xFUL, + + /// The buffer will never be locked for direct CPU writes using the + /// AHardwareBuffer_lock() function. Note that writing the buffer + /// using OpenGL or Vulkan functions or memory mappings is still + /// allowed. + AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER = 0UL << 4, + /// The buffer will sometimes be locked for direct CPU writes using + /// the AHardwareBuffer_lock() function. Note that writing the + /// buffer using OpenGL or Vulkan functions or memory mappings + /// does not require the presence of this flag. + AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY = 2UL << 4, + /// The buffer will often be locked for direct CPU writes using + /// the AHardwareBuffer_lock() function. Note that writing the + /// buffer using OpenGL or Vulkan functions or memory mappings + /// does not require the presence of this flag. + AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN = 3UL << 4, + /// CPU write value mask. + AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK = 0xFUL << 4, + + /// The buffer will be read from by the GPU as a texture. + AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE = 1UL << 8, + /// The buffer will be written to by the GPU as a framebuffer attachment. + AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER = 1UL << 9, + /** + * The buffer will be written to by the GPU as a framebuffer + * attachment. + * + * Note that the name of this flag is somewhat misleading: it does + * not imply that the buffer contains a color format. A buffer with + * depth or stencil format that will be used as a framebuffer + * attachment should also have this flag. Use the equivalent flag + * AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER to avoid this confusion. + */ + AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT = AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER, + /** + * The buffer will be used as a composer HAL overlay layer. + * + * This flag is currently only needed when using ASurfaceTransaction_setBuffer + * to set a buffer. In all other cases, the framework adds this flag + * internally to buffers that could be presented in a composer overlay. + * ASurfaceTransaction_setBuffer is special because it uses buffers allocated + * directly through AHardwareBuffer_allocate instead of buffers allocated + * by the framework. + */ + AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY = 1ULL << 11, + /** + * The buffer is protected from direct CPU access or being read by + * non-secure hardware, such as video encoders. + * + * This flag is incompatible with CPU read and write flags. It is + * mainly used when handling DRM video. Refer to the EGL extension + * EGL_EXT_protected_content and GL extension + * GL_EXT_protected_textures for more information on how these + * buffers are expected to behave. + */ + AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT = 1UL << 14, + /// The buffer will be read by a hardware video encoder. + AHARDWAREBUFFER_USAGE_VIDEO_ENCODE = 1UL << 16, + /** + * The buffer will be used for direct writes from sensors. + * When this flag is present, the format must be AHARDWAREBUFFER_FORMAT_BLOB. + */ + AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA = 1UL << 23, + /** + * The buffer will be used as a shader storage or uniform buffer object. + * When this flag is present, the format must be AHARDWAREBUFFER_FORMAT_BLOB. + */ + AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER = 1UL << 24, + /** + * The buffer will be used as a cube map texture. + * When this flag is present, the buffer must have a layer count + * that is a multiple of 6. Note that buffers with this flag must be + * bound to OpenGL textures using the extension + * GL_EXT_EGL_image_storage instead of GL_KHR_EGL_image. + */ + AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP = 1UL << 25, + /** + * The buffer contains a complete mipmap hierarchy. + * Note that buffers with this flag must be bound to OpenGL textures using + * the extension GL_EXT_EGL_image_storage instead of GL_KHR_EGL_image. + */ + AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE = 1UL << 26, + + AHARDWAREBUFFER_USAGE_VENDOR_0 = 1ULL << 28, + AHARDWAREBUFFER_USAGE_VENDOR_1 = 1ULL << 29, + AHARDWAREBUFFER_USAGE_VENDOR_2 = 1ULL << 30, + AHARDWAREBUFFER_USAGE_VENDOR_3 = 1ULL << 31, + AHARDWAREBUFFER_USAGE_VENDOR_4 = 1ULL << 48, + AHARDWAREBUFFER_USAGE_VENDOR_5 = 1ULL << 49, + AHARDWAREBUFFER_USAGE_VENDOR_6 = 1ULL << 50, + AHARDWAREBUFFER_USAGE_VENDOR_7 = 1ULL << 51, + AHARDWAREBUFFER_USAGE_VENDOR_8 = 1ULL << 52, + AHARDWAREBUFFER_USAGE_VENDOR_9 = 1ULL << 53, + AHARDWAREBUFFER_USAGE_VENDOR_10 = 1ULL << 54, + AHARDWAREBUFFER_USAGE_VENDOR_11 = 1ULL << 55, + AHARDWAREBUFFER_USAGE_VENDOR_12 = 1ULL << 56, + AHARDWAREBUFFER_USAGE_VENDOR_13 = 1ULL << 57, + AHARDWAREBUFFER_USAGE_VENDOR_14 = 1ULL << 58, + AHARDWAREBUFFER_USAGE_VENDOR_15 = 1ULL << 59, + AHARDWAREBUFFER_USAGE_VENDOR_16 = 1ULL << 60, + AHARDWAREBUFFER_USAGE_VENDOR_17 = 1ULL << 61, + AHARDWAREBUFFER_USAGE_VENDOR_18 = 1ULL << 62, + AHARDWAREBUFFER_USAGE_VENDOR_19 = 1ULL << 63, +}; + +/** + * Buffer description. Used for allocating new buffers and querying + * parameters of existing ones. + */ +typedef struct AHardwareBuffer_Desc { + uint32_t width; ///< Width in pixels. + uint32_t height; ///< Height in pixels. + /** + * Number of images in an image array. AHardwareBuffers with one + * layer correspond to regular 2D textures. AHardwareBuffers with + * more than layer correspond to texture arrays. If the layer count + * is a multiple of 6 and the usage flag + * AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP is present, the buffer is + * a cube map or a cube map array. + */ + uint32_t layers; + uint32_t format; ///< One of AHardwareBuffer_Format. + uint64_t usage; ///< Combination of AHardwareBuffer_UsageFlags. + uint32_t stride; ///< Row stride in pixels, ignored for AHardwareBuffer_allocate() + uint32_t rfu0; ///< Initialize to zero, reserved for future use. + uint64_t rfu1; ///< Initialize to zero, reserved for future use. +} AHardwareBuffer_Desc; + +/** + * Holds data for a single image plane. + */ +typedef struct AHardwareBuffer_Plane { + void* data; ///< Points to first byte in plane + uint32_t pixelStride; ///< Distance in bytes from the color channel of one pixel to the next + uint32_t rowStride; ///< Distance in bytes from the first value of one row of the image to + /// the first value of the next row. +} AHardwareBuffer_Plane; + +/** + * Holds all image planes that contain the pixel data. + */ +typedef struct AHardwareBuffer_Planes { + uint32_t planeCount; ///< Number of distinct planes + AHardwareBuffer_Plane planes[4]; ///< Array of image planes +} AHardwareBuffer_Planes; + +/** + * Opaque handle for a native hardware buffer. + */ +typedef struct AHardwareBuffer AHardwareBuffer; + +#if __ANDROID_API__ >= 26 + +/** + * Allocates a buffer that matches the passed AHardwareBuffer_Desc. + * + * If allocation succeeds, the buffer can be used according to the + * usage flags specified in its description. If a buffer is used in ways + * not compatible with its usage flags, the results are undefined and + * may include program termination. + * + * Available since API level 26. + * + * \return 0 on success, or an error number of the allocation fails for + * any reason. The returned buffer has a reference count of 1. + */ +int AHardwareBuffer_allocate(const AHardwareBuffer_Desc* desc, + AHardwareBuffer** outBuffer) __INTRODUCED_IN(26); +/** + * Acquire a reference on the given AHardwareBuffer object. + * + * This prevents the object from being deleted until the last reference + * is removed. + * + * Available since API level 26. + */ +void AHardwareBuffer_acquire(AHardwareBuffer* buffer) __INTRODUCED_IN(26); + +/** + * Remove a reference that was previously acquired with + * AHardwareBuffer_acquire() or AHardwareBuffer_allocate(). + * + * Available since API level 26. + */ +void AHardwareBuffer_release(AHardwareBuffer* buffer) __INTRODUCED_IN(26); + +/** + * Return a description of the AHardwareBuffer in the passed + * AHardwareBuffer_Desc struct. + * + * Available since API level 26. + */ +void AHardwareBuffer_describe(const AHardwareBuffer* buffer, + AHardwareBuffer_Desc* outDesc) __INTRODUCED_IN(26); + +/** + * Lock the AHardwareBuffer for direct CPU access. + * + * This function can lock the buffer for either reading or writing. + * It may block if the hardware needs to finish rendering, if CPU caches + * need to be synchronized, or possibly for other implementation- + * specific reasons. + * + * The passed AHardwareBuffer must have one layer, otherwise the call + * will fail. + * + * If \a fence is not negative, it specifies a fence file descriptor on + * which to wait before locking the buffer. If it's negative, the caller + * is responsible for ensuring that writes to the buffer have completed + * before calling this function. Using this parameter is more efficient + * than waiting on the fence and then calling this function. + * + * The \a usage parameter may only specify AHARDWAREBUFFER_USAGE_CPU_*. + * If set, then outVirtualAddress is filled with the address of the + * buffer in virtual memory. The flags must also be compatible with + * usage flags specified at buffer creation: if a read flag is passed, + * the buffer must have been created with + * AHARDWAREBUFFER_USAGE_CPU_READ_RARELY or + * AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN. If a write flag is passed, it + * must have been created with AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY or + * AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN. + * + * If \a rect is not NULL, the caller promises to modify only data in + * the area specified by rect. If rect is NULL, the caller may modify + * the contents of the entire buffer. The content of the buffer outside + * of the specified rect is NOT modified by this call. + * + * It is legal for several different threads to lock a buffer for read + * access; none of the threads are blocked. + * + * Locking a buffer simultaneously for write or read/write is undefined, + * but will neither terminate the process nor block the caller. + * AHardwareBuffer_lock may return an error or leave the buffer's + * content in an indeterminate state. + * + * If the buffer has AHARDWAREBUFFER_FORMAT_BLOB, it is legal lock it + * for reading and writing in multiple threads and/or processes + * simultaneously, and the contents of the buffer behave like shared + * memory. + * + * Available since API level 26. + * + * \return 0 on success. -EINVAL if \a buffer is NULL, the usage flags + * are not a combination of AHARDWAREBUFFER_USAGE_CPU_*, or the buffer + * has more than one layer. Error number if the lock fails for any other + * reason. + */ +int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage, + int32_t fence, const ARect* rect, void** outVirtualAddress) __INTRODUCED_IN(26); + +/** + * Lock a potentially multi-planar AHardwareBuffer for direct CPU access. + * + * This function is similar to AHardwareBuffer_lock, but can lock multi-planar + * formats. The locked planes are returned in the \a outPlanes argument. Note, + * that multi-planar should not be confused with multi-layer images, which this + * locking function does not support. + * + * YUV formats are always represented by three separate planes of data, one for + * each color plane. The order of planes in the array is guaranteed such that + * plane #0 is always Y, plane #1 is always U (Cb), and plane #2 is always V + * (Cr). All other formats are represented by a single plane. + * + * Additional information always accompanies the buffers, describing the row + * stride and the pixel stride for each plane. + * + * In case the buffer cannot be locked, \a outPlanes will contain zero planes. + * + * See the AHardwareBuffer_lock documentation for all other locking semantics. + * + * Available since API level 29. + * + * \return 0 on success. -EINVAL if \a buffer is NULL, the usage flags + * are not a combination of AHARDWAREBUFFER_USAGE_CPU_*, or the buffer + * has more than one layer. Error number if the lock fails for any other + * reason. + */ +int AHardwareBuffer_lockPlanes(AHardwareBuffer* buffer, uint64_t usage, + int32_t fence, const ARect* rect, AHardwareBuffer_Planes* outPlanes) __INTRODUCED_IN(29); + +/** + * Unlock the AHardwareBuffer from direct CPU access. + * + * Must be called after all changes to the buffer are completed by the + * caller. If \a fence is NULL, the function will block until all work + * is completed. Otherwise, \a fence will be set either to a valid file + * descriptor or to -1. The file descriptor will become signaled once + * the unlocking is complete and buffer contents are updated. + * The caller is responsible for closing the file descriptor once it's + * no longer needed. The value -1 indicates that unlocking has already + * completed before the function returned and no further operations are + * necessary. + * + * Available since API level 26. + * + * \return 0 on success. -EINVAL if \a buffer is NULL. Error number if + * the unlock fails for any reason. + */ +int AHardwareBuffer_unlock(AHardwareBuffer* buffer, int32_t* fence) __INTRODUCED_IN(26); + +/** + * Send the AHardwareBuffer to an AF_UNIX socket. + * + * Available since API level 26. + * + * \return 0 on success, -EINVAL if \a buffer is NULL, or an error + * number if the operation fails for any reason. + */ +int AHardwareBuffer_sendHandleToUnixSocket(const AHardwareBuffer* buffer, int socketFd) __INTRODUCED_IN(26); + +/** + * Receive an AHardwareBuffer from an AF_UNIX socket. + * + * Available since API level 26. + * + * \return 0 on success, -EINVAL if \a outBuffer is NULL, or an error + * number if the operation fails for any reason. + */ +int AHardwareBuffer_recvHandleFromUnixSocket(int socketFd, AHardwareBuffer** outBuffer) __INTRODUCED_IN(26); + +#endif // __ANDROID_API__ >= 26 + +#if __ANDROID_API__ >= 29 + +/** + * Test whether the given format and usage flag combination is + * allocatable. + * + * If this function returns true, it means that a buffer with the given + * description can be allocated on this implementation, unless resource + * exhaustion occurs. If this function returns false, it means that the + * allocation of the given description will never succeed. + * + * The return value of this function may depend on all fields in the + * description, except stride, which is always ignored. For example, + * some implementations have implementation-defined limits on texture + * size and layer count. + * + * Available since API level 29. + * + * \return 1 if the format and usage flag combination is allocatable, + * 0 otherwise. + */ +int AHardwareBuffer_isSupported(const AHardwareBuffer_Desc* desc) __INTRODUCED_IN(29); + +/** + * Lock an AHardwareBuffer for direct CPU access. + * + * This function is the same as the above lock function, but passes back + * additional information about the bytes per pixel and the bytes per stride + * of the locked buffer. If the bytes per pixel or bytes per stride are unknown + * or variable, or if the underlying mapper implementation does not support returning + * additional information, then this call will fail with INVALID_OPERATION + * + * Available since API level 29. + */ +int AHardwareBuffer_lockAndGetInfo(AHardwareBuffer* buffer, uint64_t usage, + int32_t fence, const ARect* rect, void** outVirtualAddress, + int32_t* outBytesPerPixel, int32_t* outBytesPerStride) __INTRODUCED_IN(29); +#endif // __ANDROID_API__ >= 29 + +__END_DECLS + +#endif // ANDROID_HARDWARE_BUFFER_H + +/** @} */ diff --git a/include/android_stub/android/hdr_metadata.h b/include/android_stub/android/hdr_metadata.h new file mode 100644 index 00000000000..88772a92fc9 --- /dev/null +++ b/include/android_stub/android/hdr_metadata.h @@ -0,0 +1,74 @@ +/* + * Copyright 2019 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. + */ + +/** + * @file hdr_metadata.h + */ + +#ifndef ANDROID_HDR_METADATA_H +#define ANDROID_HDR_METADATA_H + +#include <inttypes.h> + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +/** + * These structures are used to define the display's capabilities for HDR content. + * They can be used to better tone map content to user's display. + */ + +/** + * HDR metadata standards that are supported by Android. + */ +enum AHdrMetadataType : uint32_t { + HDR10_SMPTE2086 = 1, + HDR10_CTA861_3 = 2, + HDR10PLUS_SEI = 3, +}; + +/** + * Color is defined in CIE XYZ coordinates. + */ +struct AColor_xy { + float x; + float y; +}; + +/** + * SMPTE ST 2086 "Mastering Display Color Volume" static metadata + */ +struct AHdrMetadata_smpte2086 { + struct AColor_xy displayPrimaryRed; + struct AColor_xy displayPrimaryGreen; + struct AColor_xy displayPrimaryBlue; + struct AColor_xy whitePoint; + float maxLuminance; + float minLuminance; +}; + +/** + * CTA 861.3 "HDR Static Metadata Extension" static metadata + */ +struct AHdrMetadata_cta861_3 { + float maxContentLightLevel; + float maxFrameAverageLightLevel; +}; + +__END_DECLS + +#endif // ANDROID_HDR_METADATA_H diff --git a/include/android_stub/android/log.h b/include/android_stub/android/log.h new file mode 100644 index 00000000000..8a0ebf22fee --- /dev/null +++ b/include/android_stub/android/log.h @@ -0,0 +1,380 @@ +/* + * Copyright (C) 2009 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. + */ + +#pragma once + +/** + * @addtogroup Logging + * @{ + */ + +/** + * \file + * + * Support routines to send messages to the Android log buffer, + * which can later be accessed through the `logcat` utility. + * + * Each log message must have + * - a priority + * - a log tag + * - some text + * + * The tag normally corresponds to the component that emits the log message, + * and should be reasonably small. + * + * Log message text may be truncated to less than an implementation-specific + * limit (1023 bytes). + * + * Note that a newline character ("\n") will be appended automatically to your + * log message, if not already there. It is not possible to send several + * messages and have them appear on a single line in logcat. + * + * Please use logging in moderation: + * + * - Sending log messages eats CPU and slow down your application and the + * system. + * + * - The circular log buffer is pretty small, so sending many messages + * will hide other important log messages. + * + * - In release builds, only send log messages to account for exceptional + * conditions. + */ + +#include <stdarg.h> +#include <stddef.h> +#include <stdint.h> +#include <sys/cdefs.h> + +#if !defined(__BIONIC__) && !defined(__INTRODUCED_IN) +#define __INTRODUCED_IN(x) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Android log priority values, in increasing order of priority. + */ +typedef enum android_LogPriority { + /** For internal use only. */ + ANDROID_LOG_UNKNOWN = 0, + /** The default priority, for internal use only. */ + ANDROID_LOG_DEFAULT, /* only for SetMinPriority() */ + /** Verbose logging. Should typically be disabled for a release apk. */ + ANDROID_LOG_VERBOSE, + /** Debug logging. Should typically be disabled for a release apk. */ + ANDROID_LOG_DEBUG, + /** Informational logging. Should typically be disabled for a release apk. */ + ANDROID_LOG_INFO, + /** Warning logging. For use with recoverable failures. */ + ANDROID_LOG_WARN, + /** Error logging. For use with unrecoverable failures. */ + ANDROID_LOG_ERROR, + /** Fatal logging. For use when aborting. */ + ANDROID_LOG_FATAL, + /** For internal use only. */ + ANDROID_LOG_SILENT, /* only for SetMinPriority(); must be last */ +} android_LogPriority; + +/** + * Writes the constant string `text` to the log, with priority `prio` and tag + * `tag`. + */ +int __android_log_write(int prio, const char* tag, const char* text); + +/** + * Writes a formatted string to the log, with priority `prio` and tag `tag`. + * The details of formatting are the same as for + * [printf(3)](http://man7.org/linux/man-pages/man3/printf.3.html). + */ +int __android_log_print(int prio, const char* tag, const char* fmt, ...) + __attribute__((__format__(printf, 3, 4))); + +/** + * Equivalent to `__android_log_print`, but taking a `va_list`. + * (If `__android_log_print` is like `printf`, this is like `vprintf`.) + */ +int __android_log_vprint(int prio, const char* tag, const char* fmt, va_list ap) + __attribute__((__format__(printf, 3, 0))); + +/** + * Writes an assertion failure to the log (as `ANDROID_LOG_FATAL`) and to + * stderr, before calling + * [abort(3)](http://man7.org/linux/man-pages/man3/abort.3.html). + * + * If `fmt` is non-null, `cond` is unused. If `fmt` is null, the string + * `Assertion failed: %s` is used with `cond` as the string argument. + * If both `fmt` and `cond` are null, a default string is provided. + * + * Most callers should use + * [assert(3)](http://man7.org/linux/man-pages/man3/assert.3.html) from + * `<assert.h>` instead, or the `__assert` and `__assert2` functions + * provided by bionic if more control is needed. They support automatically + * including the source filename and line number more conveniently than this + * function. + */ +void __android_log_assert(const char* cond, const char* tag, const char* fmt, ...) + __attribute__((__noreturn__)) __attribute__((__format__(printf, 3, 4))); + +/** + * Identifies a specific log buffer for __android_log_buf_write() + * and __android_log_buf_print(). + */ +typedef enum log_id { + LOG_ID_MIN = 0, + + /** The main log buffer. This is the only log buffer available to apps. */ + LOG_ID_MAIN = 0, + /** The radio log buffer. */ + LOG_ID_RADIO = 1, + /** The event log buffer. */ + LOG_ID_EVENTS = 2, + /** The system log buffer. */ + LOG_ID_SYSTEM = 3, + /** The crash log buffer. */ + LOG_ID_CRASH = 4, + /** The statistics log buffer. */ + LOG_ID_STATS = 5, + /** The security log buffer. */ + LOG_ID_SECURITY = 6, + /** The kernel log buffer. */ + LOG_ID_KERNEL = 7, + + LOG_ID_MAX, + + /** Let the logging function choose the best log target. */ + LOG_ID_DEFAULT = 0x7FFFFFFF +} log_id_t; + +/** + * Writes the constant string `text` to the log buffer `id`, + * with priority `prio` and tag `tag`. + * + * Apps should use __android_log_write() instead. + */ +int __android_log_buf_write(int bufID, int prio, const char* tag, const char* text); + +/** + * Writes a formatted string to log buffer `id`, + * with priority `prio` and tag `tag`. + * The details of formatting are the same as for + * [printf(3)](http://man7.org/linux/man-pages/man3/printf.3.html). + * + * Apps should use __android_log_print() instead. + */ +int __android_log_buf_print(int bufID, int prio, const char* tag, const char* fmt, ...) + __attribute__((__format__(printf, 4, 5))); + +/** + * Logger data struct used for writing log messages to liblog via __android_log_write_logger_data() + * and sending log messages to user defined loggers specified in __android_log_set_logger(). + */ +struct __android_log_message { + /** Must be set to sizeof(__android_log_message) and is used for versioning. */ + size_t struct_size; + + /** {@link log_id_t} values. */ + int32_t buffer_id; + + /** {@link android_LogPriority} values. */ + int32_t priority; + + /** The tag for the log message. */ + const char* tag; + + /** Optional file name, may be set to nullptr. */ + const char* file; + + /** Optional line number, ignore if file is nullptr. */ + uint32_t line; + + /** The log message itself. */ + const char* message; +}; + +/** + * Prototype for the 'logger' function that is called for every log message. + */ +typedef void (*__android_logger_function)(const struct __android_log_message* log_message); +/** + * Prototype for the 'abort' function that is called when liblog will abort due to + * __android_log_assert() failures. + */ +typedef void (*__android_aborter_function)(const char* abort_message); + +#if !defined(__ANDROID__) || __ANDROID_API__ >= 30 +/** + * Writes the log message specified by log_message. log_message includes additional file name and + * line number information that a logger may use. log_message is versioned for backwards + * compatibility. + * This assumes that loggability has already been checked through __android_log_is_loggable(). + * Higher level logging libraries, such as libbase, first check loggability, then format their + * buffers, then pass the message to liblog via this function, and therefore we do not want to + * duplicate the loggability check here. + * + * @param log_message the log message itself, see __android_log_message. + * + * Available since API level 30. + */ +void __android_log_write_log_message(struct __android_log_message* log_message) __INTRODUCED_IN(30); + +/** + * Sets a user defined logger function. All log messages sent to liblog will be set to the + * function pointer specified by logger for processing. It is not expected that log messages are + * already terminated with a new line. This function should add new lines if required for line + * separation. + * + * @param logger the new function that will handle log messages. + * + * Available since API level 30. + */ +void __android_log_set_logger(__android_logger_function logger) __INTRODUCED_IN(30); + +/** + * Writes the log message to logd. This is an __android_logger_function and can be provided to + * __android_log_set_logger(). It is the default logger when running liblog on a device. + * + * @param log_message the log message to write, see __android_log_message. + * + * Available since API level 30. + */ +void __android_log_logd_logger(const struct __android_log_message* log_message) __INTRODUCED_IN(30); + +/** + * Writes the log message to stderr. This is an __android_logger_function and can be provided to + * __android_log_set_logger(). It is the default logger when running liblog on host. + * + * @param log_message the log message to write, see __android_log_message. + * + * Available since API level 30. + */ +void __android_log_stderr_logger(const struct __android_log_message* log_message) + __INTRODUCED_IN(30); + +/** + * Sets a user defined aborter function that is called for __android_log_assert() failures. This + * user defined aborter function is highly recommended to abort and be noreturn, but is not strictly + * required to. + * + * @param aborter the new aborter function, see __android_aborter_function. + * + * Available since API level 30. + */ +void __android_log_set_aborter(__android_aborter_function aborter) __INTRODUCED_IN(30); + +/** + * Calls the stored aborter function. This allows for other logging libraries to use the same + * aborter function by calling this function in liblog. + * + * @param abort_message an additional message supplied when aborting, for example this is used to + * call android_set_abort_message() in __android_log_default_aborter(). + * + * Available since API level 30. + */ +void __android_log_call_aborter(const char* abort_message) __INTRODUCED_IN(30); + +/** + * Sets android_set_abort_message() on device then aborts(). This is the default aborter. + * + * @param abort_message an additional message supplied when aborting. This functions calls + * android_set_abort_message() with its contents. + * + * Available since API level 30. + */ +void __android_log_default_aborter(const char* abort_message) __attribute__((noreturn)) +__INTRODUCED_IN(30); + +/** + * Use the per-tag properties "log.tag.<tagname>" along with the minimum priority from + * __android_log_set_minimum_priority() to determine if a log message with a given prio and tag will + * be printed. A non-zero result indicates yes, zero indicates false. + * + * If both a priority for a tag and a minimum priority are set by + * __android_log_set_minimum_priority(), then the lowest of the two values are to determine the + * minimum priority needed to log. If only one is set, then that value is used to determine the + * minimum priority needed. If none are set, then default_priority is used. + * + * @param prio the priority to test, takes android_LogPriority values. + * @param tag the tag to test. + * @param default_prio the default priority to use if no properties or minimum priority are set. + * @return an integer where 1 indicates that the message is loggable and 0 indicates that it is not. + * + * Available since API level 30. + */ +int __android_log_is_loggable(int prio, const char* tag, int default_prio) __INTRODUCED_IN(30); + +/** + * Use the per-tag properties "log.tag.<tagname>" along with the minimum priority from + * __android_log_set_minimum_priority() to determine if a log message with a given prio and tag will + * be printed. A non-zero result indicates yes, zero indicates false. + * + * If both a priority for a tag and a minimum priority are set by + * __android_log_set_minimum_priority(), then the lowest of the two values are to determine the + * minimum priority needed to log. If only one is set, then that value is used to determine the + * minimum priority needed. If none are set, then default_priority is used. + * + * @param prio the priority to test, takes android_LogPriority values. + * @param tag the tag to test. + * @param len the length of the tag. + * @param default_prio the default priority to use if no properties or minimum priority are set. + * @return an integer where 1 indicates that the message is loggable and 0 indicates that it is not. + * + * Available since API level 30. + */ +int __android_log_is_loggable_len(int prio, const char* tag, size_t len, int default_prio) + __INTRODUCED_IN(30); + +/** + * Sets the minimum priority that will be logged for this process. + * + * @param priority the new minimum priority to set, takes android_LogPriority values. + * @return the previous set minimum priority as android_LogPriority values, or + * ANDROID_LOG_DEFAULT if none was set. + * + * Available since API level 30. + */ +int32_t __android_log_set_minimum_priority(int32_t priority) __INTRODUCED_IN(30); + +/** + * Gets the minimum priority that will be logged for this process. If none has been set by a + * previous __android_log_set_minimum_priority() call, this returns ANDROID_LOG_DEFAULT. + * + * @return the current minimum priority as android_LogPriority values, or + * ANDROID_LOG_DEFAULT if none is set. + * + * Available since API level 30. + */ +int32_t __android_log_get_minimum_priority(void) __INTRODUCED_IN(30); + +/** + * Sets the default tag if no tag is provided when writing a log message. Defaults to + * getprogname(). This truncates tag to the maximum log message size, though appropriate tags + * should be much smaller. + * + * @param tag the new log tag. + * + * Available since API level 30. + */ +void __android_log_set_default_tag(const char* tag) __INTRODUCED_IN(30); +#endif + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/include/android_stub/android/native_window.h b/include/android_stub/android/native_window.h new file mode 100644 index 00000000000..3e436e3b071 --- /dev/null +++ b/include/android_stub/android/native_window.h @@ -0,0 +1,239 @@ +/* + * 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. + */ + +/** + * @defgroup ANativeWindow Native Window + * + * ANativeWindow represents the producer end of an image queue. + * It is the C counterpart of the android.view.Surface object in Java, + * and can be converted both ways. Depending on the consumer, images + * submitted to ANativeWindow can be shown on the display or sent to + * other consumers, such as video encoders. + * @{ + */ + +/** + * @file native_window.h + * @brief API for accessing a native window. + */ + +#ifndef ANDROID_NATIVE_WINDOW_H +#define ANDROID_NATIVE_WINDOW_H + +#include <sys/cdefs.h> + +#include <android/data_space.h> +#include <android/hardware_buffer.h> +#include <android/rect.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Legacy window pixel format names, kept for backwards compatibility. + * New code and APIs should use AHARDWAREBUFFER_FORMAT_*. + */ +enum ANativeWindow_LegacyFormat { + // NOTE: these values must match the values from graphics/common/x.x/types.hal + + /** Red: 8 bits, Green: 8 bits, Blue: 8 bits, Alpha: 8 bits. **/ + WINDOW_FORMAT_RGBA_8888 = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, + /** Red: 8 bits, Green: 8 bits, Blue: 8 bits, Unused: 8 bits. **/ + WINDOW_FORMAT_RGBX_8888 = AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM, + /** Red: 5 bits, Green: 6 bits, Blue: 5 bits. **/ + WINDOW_FORMAT_RGB_565 = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM, +}; + +/** + * Transforms that can be applied to buffers as they are displayed to a window. + * + * Supported transforms are any combination of horizontal mirror, vertical + * mirror, and clockwise 90 degree rotation, in that order. Rotations of 180 + * and 270 degrees are made up of those basic transforms. + */ +enum ANativeWindowTransform { + ANATIVEWINDOW_TRANSFORM_IDENTITY = 0x00, + ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL = 0x01, + ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL = 0x02, + ANATIVEWINDOW_TRANSFORM_ROTATE_90 = 0x04, + + ANATIVEWINDOW_TRANSFORM_ROTATE_180 = ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL | + ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL, + ANATIVEWINDOW_TRANSFORM_ROTATE_270 = ANATIVEWINDOW_TRANSFORM_ROTATE_180 | + ANATIVEWINDOW_TRANSFORM_ROTATE_90, +}; + +struct ANativeWindow; +/** + * Opaque type that provides access to a native window. + * + * A pointer can be obtained using {@link ANativeWindow_fromSurface()}. + */ +typedef struct ANativeWindow ANativeWindow; + +/** + * Struct that represents a windows buffer. + * + * A pointer can be obtained using {@link ANativeWindow_lock()}. + */ +typedef struct ANativeWindow_Buffer { + /// The number of pixels that are shown horizontally. + int32_t width; + + /// The number of pixels that are shown vertically. + int32_t height; + + /// The number of *pixels* that a line in the buffer takes in + /// memory. This may be >= width. + int32_t stride; + + /// The format of the buffer. One of AHardwareBuffer_Format. + int32_t format; + + /// The actual bits. + void* bits; + + /// Do not touch. + uint32_t reserved[6]; +} ANativeWindow_Buffer; + +/** + * Acquire a reference on the given {@link ANativeWindow} object. This prevents the object + * from being deleted until the reference is removed. + */ +void ANativeWindow_acquire(ANativeWindow* window); + +/** + * Remove a reference that was previously acquired with {@link ANativeWindow_acquire()}. + */ +void ANativeWindow_release(ANativeWindow* window); + +/** + * Return the current width in pixels of the window surface. + * + * \return negative value on error. + */ +int32_t ANativeWindow_getWidth(ANativeWindow* window); + +/** + * Return the current height in pixels of the window surface. + * + * \return a negative value on error. + */ +int32_t ANativeWindow_getHeight(ANativeWindow* window); + +/** + * Return the current pixel format (AHARDWAREBUFFER_FORMAT_*) of the window surface. + * + * \return a negative value on error. + */ +int32_t ANativeWindow_getFormat(ANativeWindow* window); + +/** + * Change the format and size of the window buffers. + * + * The width and height control the number of pixels in the buffers, not the + * dimensions of the window on screen. If these are different than the + * window's physical size, then its buffer will be scaled to match that size + * when compositing it to the screen. The width and height must be either both zero + * or both non-zero. + * + * For all of these parameters, if 0 is supplied then the window's base + * value will come back in force. + * + * \param width width of the buffers in pixels. + * \param height height of the buffers in pixels. + * \param format one of the AHardwareBuffer_Format constants. + * \return 0 for success, or a negative value on error. + */ +int32_t ANativeWindow_setBuffersGeometry(ANativeWindow* window, + int32_t width, int32_t height, int32_t format); + +/** + * Lock the window's next drawing surface for writing. + * inOutDirtyBounds is used as an in/out parameter, upon entering the + * function, it contains the dirty region, that is, the region the caller + * intends to redraw. When the function returns, inOutDirtyBounds is updated + * with the actual area the caller needs to redraw -- this region is often + * extended by {@link ANativeWindow_lock}. + * + * \return 0 for success, or a negative value on error. + */ +int32_t ANativeWindow_lock(ANativeWindow* window, ANativeWindow_Buffer* outBuffer, + ARect* inOutDirtyBounds); + +/** + * Unlock the window's drawing surface after previously locking it, + * posting the new buffer to the display. + * + * \return 0 for success, or a negative value on error. + */ +int32_t ANativeWindow_unlockAndPost(ANativeWindow* window); + +#if __ANDROID_API__ >= 26 + +/** + * Set a transform that will be applied to future buffers posted to the window. + * + * Available since API level 26. + * + * \param transform combination of {@link ANativeWindowTransform} flags + * \return 0 for success, or -EINVAL if \p transform is invalid + */ +int32_t ANativeWindow_setBuffersTransform(ANativeWindow* window, int32_t transform) __INTRODUCED_IN(26); + +#endif // __ANDROID_API__ >= 26 + +#if __ANDROID_API__ >= 28 + +/** + * All buffers queued after this call will be associated with the dataSpace + * parameter specified. + * + * dataSpace specifies additional information about the buffer. + * For example, it can be used to convey the color space of the image data in + * the buffer, or it can be used to indicate that the buffers contain depth + * measurement data instead of color images. The default dataSpace is 0, + * ADATASPACE_UNKNOWN, unless it has been overridden by the producer. + * + * Available since API level 28. + * + * \param dataSpace data space of all buffers queued after this call. + * \return 0 for success, -EINVAL if window is invalid or the dataspace is not + * supported. + */ +int32_t ANativeWindow_setBuffersDataSpace(ANativeWindow* window, int32_t dataSpace) __INTRODUCED_IN(28); + +/** + * Get the dataspace of the buffers in window. + * + * Available since API level 28. + * + * \return the dataspace of buffers in window, ADATASPACE_UNKNOWN is returned if + * dataspace is unknown, or -EINVAL if window is invalid. + */ +int32_t ANativeWindow_getBuffersDataSpace(ANativeWindow* window) __INTRODUCED_IN(28); + +#endif // __ANDROID_API__ >= 28 + +#ifdef __cplusplus +}; +#endif + +#endif // ANDROID_NATIVE_WINDOW_H + +/** @} */ diff --git a/include/android_stub/android/rect.h b/include/android_stub/android/rect.h new file mode 100644 index 00000000000..b36728e9342 --- /dev/null +++ b/include/android_stub/android/rect.h @@ -0,0 +1,65 @@ +/* + * 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. + */ + +/** + * @addtogroup NativeActivity Native Activity + * @{ + */ + +/** + * @file rect.h + */ + +#ifndef ANDROID_RECT_H +#define ANDROID_RECT_H + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Rectangular window area. + * + * This is the NDK equivalent of the android.graphics.Rect class in Java. It is + * used with {@link ANativeActivityCallbacks::onContentRectChanged} event + * callback and the ANativeWindow_lock() function. + * + * In a valid ARect, left <= right and top <= bottom. ARect with left=0, top=10, + * right=1, bottom=11 contains only one pixel at x=0, y=10. + */ +typedef struct ARect { +#ifdef __cplusplus + typedef int32_t value_type; +#endif + /// Minimum X coordinate of the rectangle. + int32_t left; + /// Minimum Y coordinate of the rectangle. + int32_t top; + /// Maximum X coordinate of the rectangle. + int32_t right; + /// Maximum Y coordinate of the rectangle. + int32_t bottom; +} ARect; + +#ifdef __cplusplus +}; +#endif + +#endif // ANDROID_RECT_H + +/** @} */ diff --git a/include/android_stub/android/sync.h b/include/android_stub/android/sync.h new file mode 100644 index 00000000000..32bb878baaa --- /dev/null +++ b/include/android_stub/android/sync.h @@ -0,0 +1,49 @@ +/* + * sync.h + * + * Copyright 2012 Google, Inc + * + * 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. + */ + +#ifndef __SYS_CORE_SYNC_H +#define __SYS_CORE_SYNC_H + +/* This file contains the legacy sync interface used by Android platform and + * device code. The direct contents will be removed over time as code + * transitions to using the updated interface in ndk/sync.h. When this file is + * empty other than the ndk/sync.h include, that file will be renamed to + * replace this one. + * + * New code should continue to include this file (#include <android/sync.h>) + * instead of ndk/sync.h so the eventual rename is seamless, but should only + * use the things declared in ndk/sync.h. + * + * This file used to be called sync/sync.h, but we renamed to that both the + * platform and NDK call it android/sync.h. A symlink from the old name to this + * one exists temporarily to avoid having to change all sync clients + * simultaneously. It will be removed when they've been updated, and probably + * after this change has been delivered to AOSP so that integrations don't + * break builds. + */ + +#include "../ndk/sync.h" + +__BEGIN_DECLS + +/* timeout in msecs */ +int sync_wait(int fd, int timeout); + +__END_DECLS + +#endif /* __SYS_CORE_SYNC_H */ diff --git a/include/android_stub/backtrace/Backtrace.h b/include/android_stub/backtrace/Backtrace.h new file mode 100644 index 00000000000..664b531fb2b --- /dev/null +++ b/include/android_stub/backtrace/Backtrace.h @@ -0,0 +1,214 @@ +/* + * Copyright (C) 2013 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. + */ + +#ifndef _BACKTRACE_BACKTRACE_H +#define _BACKTRACE_BACKTRACE_H + +#include <inttypes.h> +#include <stdint.h> + +#include <string> +#include <vector> + +#include <backtrace/backtrace_constants.h> +#include <backtrace/BacktraceMap.h> + +#if defined(__LP64__) +#define PRIPTR "016" PRIx64 +typedef uint64_t word_t; +#else +#define PRIPTR "08" PRIx64 +typedef uint32_t word_t; +#endif + +enum BacktraceUnwindErrorCode : uint32_t { + BACKTRACE_UNWIND_NO_ERROR, + // Something failed while trying to perform the setup to begin the unwind. + BACKTRACE_UNWIND_ERROR_SETUP_FAILED, + // There is no map information to use with the unwind. + BACKTRACE_UNWIND_ERROR_MAP_MISSING, + // An error occurred that indicates a programming error. + BACKTRACE_UNWIND_ERROR_INTERNAL, + // The thread to unwind has disappeared before the unwind can begin. + BACKTRACE_UNWIND_ERROR_THREAD_DOESNT_EXIST, + // The thread to unwind has not responded to a signal in a timely manner. + BACKTRACE_UNWIND_ERROR_THREAD_TIMEOUT, + // Attempt to do an unsupported operation. + BACKTRACE_UNWIND_ERROR_UNSUPPORTED_OPERATION, + // Attempt to do an offline unwind without a context. + BACKTRACE_UNWIND_ERROR_NO_CONTEXT, + // The count of frames exceed MAX_BACKTRACE_FRAMES. + BACKTRACE_UNWIND_ERROR_EXCEED_MAX_FRAMES_LIMIT, + // Failed to read memory. + BACKTRACE_UNWIND_ERROR_ACCESS_MEM_FAILED, + // Failed to read registers. + BACKTRACE_UNWIND_ERROR_ACCESS_REG_FAILED, + // Failed to find a function in debug sections. + BACKTRACE_UNWIND_ERROR_FIND_PROC_INFO_FAILED, + // Failed to execute dwarf instructions in debug sections. + BACKTRACE_UNWIND_ERROR_EXECUTE_DWARF_INSTRUCTION_FAILED, + // Unwind information is incorrect. + BACKTRACE_UNWIND_ERROR_UNWIND_INFO, + // Unwind information stopped due to sp/pc repeating. + BACKTRACE_UNWIND_ERROR_REPEATED_FRAME, + // Unwind information stopped due to invalid elf. + BACKTRACE_UNWIND_ERROR_INVALID_ELF, +}; + +struct BacktraceUnwindError { + enum BacktraceUnwindErrorCode error_code; + + union { + // for BACKTRACE_UNWIND_ERROR_ACCESS_MEM_FAILED + uint64_t addr; + // for BACKTRACE_UNWIND_ERROR_ACCESS_REG_FAILED + uint64_t regno; + } error_info; + + BacktraceUnwindError() : error_code(BACKTRACE_UNWIND_NO_ERROR) {} +}; + +struct backtrace_frame_data_t { + size_t num; // The current fame number. + uint64_t pc; // The absolute pc. + uint64_t rel_pc; // The relative pc. + uint64_t sp; // The top of the stack. + size_t stack_size; // The size of the stack, zero indicate an unknown stack size. + backtrace_map_t map; // The map associated with the given pc. + std::string func_name; // The function name associated with this pc, NULL if not found. + uint64_t func_offset; // pc relative to the start of the function, only valid if func_name is not + // NULL. +}; + +struct backtrace_stackinfo_t { + uint64_t start; + uint64_t end; + const uint8_t* data; +}; + +namespace unwindstack { +class Regs; +} + +class Backtrace { + public: + enum ArchEnum : uint8_t { + ARCH_ARM, + ARCH_ARM64, + ARCH_X86, + ARCH_X86_64, + }; + + static void SetGlobalElfCache(bool enable); + + // Create the correct Backtrace object based on what is to be unwound. + // If pid < 0 or equals the current pid, then the Backtrace object + // corresponds to the current process. + // If pid < 0 or equals the current pid and tid >= 0, then the Backtrace + // object corresponds to a thread in the current process. + // If pid >= 0 and tid < 0, then the Backtrace object corresponds to a + // different process. + // Tracing a thread in a different process is not supported. + // If map is NULL, then create the map and manage it internally. + // If map is not NULL, the map is still owned by the caller. + static Backtrace* Create(pid_t pid, pid_t tid, BacktraceMap* map = nullptr); + + virtual ~Backtrace(); + + // Get the current stack trace and store in the backtrace_ structure. + virtual bool Unwind(size_t num_ignore_frames, void* context = nullptr) = 0; + + static bool Unwind(unwindstack::Regs* regs, BacktraceMap* back_map, + std::vector<backtrace_frame_data_t>* frames, size_t num_ignore_frames, + std::vector<std::string>* skip_names, BacktraceUnwindError* error = nullptr); + + // Get the function name and offset into the function given the pc. + // If the string is empty, then no valid function name was found, + // or the pc is not in any valid map. + virtual std::string GetFunctionName(uint64_t pc, uint64_t* offset, + const backtrace_map_t* map = nullptr); + + // Fill in the map data associated with the given pc. + virtual void FillInMap(uint64_t pc, backtrace_map_t* map); + + // Read the data at a specific address. + virtual bool ReadWord(uint64_t ptr, word_t* out_value) = 0; + + // Read arbitrary data from a specific address. If a read request would + // span from one map to another, this call only reads up until the end + // of the current map. + // Returns the total number of bytes actually read. + virtual size_t Read(uint64_t addr, uint8_t* buffer, size_t bytes) = 0; + + // Create a string representing the formatted line of backtrace information + // for a single frame. + virtual std::string FormatFrameData(size_t frame_num); + static std::string FormatFrameData(const backtrace_frame_data_t* frame); + + pid_t Pid() const { return pid_; } + pid_t Tid() const { return tid_; } + size_t NumFrames() const { return frames_.size(); } + + const backtrace_frame_data_t* GetFrame(size_t frame_num) { + if (frame_num >= frames_.size()) { + return nullptr; + } + return &frames_[frame_num]; + } + + typedef std::vector<backtrace_frame_data_t>::iterator iterator; + iterator begin() { return frames_.begin(); } + iterator end() { return frames_.end(); } + + typedef std::vector<backtrace_frame_data_t>::const_iterator const_iterator; + const_iterator begin() const { return frames_.begin(); } + const_iterator end() const { return frames_.end(); } + + BacktraceMap* GetMap() { return map_; } + + BacktraceUnwindError GetError() { return error_; } + + std::string GetErrorString(BacktraceUnwindError error); + + // Set whether to skip frames in libbacktrace/libunwindstack when doing a local unwind. + void SetSkipFrames(bool skip_frames) { skip_frames_ = skip_frames; } + + protected: + Backtrace(pid_t pid, pid_t tid, BacktraceMap* map); + + // The name returned is not demangled, GetFunctionName() takes care of + // demangling the name. + virtual std::string GetFunctionNameRaw(uint64_t pc, uint64_t* offset) = 0; + + virtual bool VerifyReadWordArgs(uint64_t ptr, word_t* out_value); + + bool BuildMap(); + + pid_t pid_; + pid_t tid_; + + BacktraceMap* map_; + bool map_shared_; + + std::vector<backtrace_frame_data_t> frames_; + + // Skip frames in libbacktrace/libunwindstack when doing a local unwind. + bool skip_frames_ = true; + + BacktraceUnwindError error_; +}; + +#endif // _BACKTRACE_BACKTRACE_H diff --git a/include/android_stub/backtrace/BacktraceMap.h b/include/android_stub/backtrace/BacktraceMap.h new file mode 100644 index 00000000000..e000a00e2d0 --- /dev/null +++ b/include/android_stub/backtrace/BacktraceMap.h @@ -0,0 +1,191 @@ +/* + * Copyright (C) 2014 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. + */ + +#ifndef _BACKTRACE_BACKTRACE_MAP_H +#define _BACKTRACE_BACKTRACE_MAP_H + +#include <stdint.h> +#include <sys/types.h> +#ifdef _WIN32 +// MINGW does not define these constants. +#define PROT_NONE 0 +#define PROT_READ 0x1 +#define PROT_WRITE 0x2 +#define PROT_EXEC 0x4 +#else +#include <sys/mman.h> +#endif + +#include <deque> +#include <iterator> +#include <memory> +#include <string> +#include <vector> + +// Forward declaration. +struct backtrace_stackinfo_t; + +// Special flag to indicate a map is in /dev/. However, a map in +// /dev/ashmem/... does not set this flag. +static constexpr int PROT_DEVICE_MAP = 0x8000; +// Special flag to indicate that this map represents an elf file +// created by ART for use with the gdb jit debug interface. +// This should only ever appear in offline maps data. +static constexpr int PROT_JIT_SYMFILE_MAP = 0x4000; + +struct backtrace_map_t { + uint64_t start = 0; + uint64_t end = 0; + uint64_t offset = 0; + uint64_t load_bias = 0; + int flags = 0; + std::string name; + + // Returns `name` if non-empty, or `<anonymous:0x...>` otherwise. + std::string Name() const; +}; + +namespace unwindstack { +class Memory; +} + +class BacktraceMap { +public: + // If uncached is true, then parse the current process map as of the call. + // Passing a map created with uncached set to true to Backtrace::Create() + // is unsupported. + static BacktraceMap* Create(pid_t pid, bool uncached = false); + + virtual ~BacktraceMap(); + + class iterator : public std::iterator<std::bidirectional_iterator_tag, backtrace_map_t*> { + public: + iterator(BacktraceMap* map, size_t index) : map_(map), index_(index) {} + + iterator& operator++() { + index_++; + return *this; + } + const iterator operator++(int increment) { + index_ += increment; + return *this; + } + iterator& operator--() { + index_--; + return *this; + } + const iterator operator--(int decrement) { + index_ -= decrement; + return *this; + } + + bool operator==(const iterator& rhs) { return this->index_ == rhs.index_; } + bool operator!=(const iterator& rhs) { return this->index_ != rhs.index_; } + + const backtrace_map_t* operator*() { + if (index_ >= map_->size()) { + return nullptr; + } + backtrace_map_t* map = &map_->maps_[index_]; + if (map->load_bias == static_cast<uint64_t>(-1)) { + map->load_bias = map_->GetLoadBias(index_); + } + return map; + } + + private: + BacktraceMap* map_ = nullptr; + size_t index_ = 0; + }; + + iterator begin() { return iterator(this, 0); } + iterator end() { return iterator(this, maps_.size()); } + + // Fill in the map data structure for the given address. + virtual void FillIn(uint64_t addr, backtrace_map_t* map); + + // Only supported with the new unwinder. + virtual std::string GetFunctionName(uint64_t /*pc*/, uint64_t* /*offset*/) { return ""; } + virtual std::shared_ptr<unwindstack::Memory> GetProcessMemory() { return nullptr; } + + // The flags returned are the same flags as used by the mmap call. + // The values are PROT_*. + int GetFlags(uint64_t pc) { + backtrace_map_t map; + FillIn(pc, &map); + if (IsValid(map)) { + return map.flags; + } + return PROT_NONE; + } + + bool IsReadable(uint64_t pc) { return GetFlags(pc) & PROT_READ; } + bool IsWritable(uint64_t pc) { return GetFlags(pc) & PROT_WRITE; } + bool IsExecutable(uint64_t pc) { return GetFlags(pc) & PROT_EXEC; } + + // In order to use the iterators on this object, a caller must + // call the LockIterator and UnlockIterator function to guarantee + // that the data does not change while it's being used. + virtual void LockIterator() {} + virtual void UnlockIterator() {} + + size_t size() const { return maps_.size(); } + + virtual bool Build(); + + static inline bool IsValid(const backtrace_map_t& map) { + return map.end > 0; + } + + void SetSuffixesToIgnore(std::vector<std::string> suffixes) { + suffixes_to_ignore_.insert(suffixes_to_ignore_.end(), suffixes.begin(), suffixes.end()); + } + + const std::vector<std::string>& GetSuffixesToIgnore() { return suffixes_to_ignore_; } + + // Disabling the resolving of names results in the function name being + // set to an empty string and the function offset being set to zero + // in the frame data when unwinding. + void SetResolveNames(bool resolve) { resolve_names_ = resolve; } + + bool ResolveNames() { return resolve_names_; } + + protected: + BacktraceMap(pid_t pid); + + virtual uint64_t GetLoadBias(size_t /* index */) { return 0; } + + pid_t pid_; + std::deque<backtrace_map_t> maps_; + std::vector<std::string> suffixes_to_ignore_; + bool resolve_names_ = true; +}; + +class ScopedBacktraceMapIteratorLock { +public: + explicit ScopedBacktraceMapIteratorLock(BacktraceMap* map) : map_(map) { + map->LockIterator(); + } + + ~ScopedBacktraceMapIteratorLock() { + map_->UnlockIterator(); + } + +private: + BacktraceMap* map_; +}; + +#endif // _BACKTRACE_BACKTRACE_MAP_H diff --git a/include/android_stub/backtrace/backtrace_constants.h b/include/android_stub/backtrace/backtrace_constants.h new file mode 100644 index 00000000000..1a2da365a0c --- /dev/null +++ b/include/android_stub/backtrace/backtrace_constants.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2014 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. + */ + +#ifndef _BACKTRACE_BACKTRACE_CONSTANTS_H +#define _BACKTRACE_BACKTRACE_CONSTANTS_H + +// When the pid to be traced is set to this value, then trace the current +// process. If the tid value is not BACKTRACE_NO_TID, then the specified +// thread from the current process will be traced. +#define BACKTRACE_CURRENT_PROCESS (-1) +// When the tid to be traced is set to this value, then trace the specified +// current thread of the specified pid. +#define BACKTRACE_CURRENT_THREAD (-1) + +#define MAX_BACKTRACE_FRAMES 256 + +#endif // _BACKTRACE_BACKTRACE_CONSTANTS_H diff --git a/include/android_stub/cutils/log.h b/include/android_stub/cutils/log.h new file mode 100644 index 00000000000..0e0248e50fa --- /dev/null +++ b/include/android_stub/cutils/log.h @@ -0,0 +1 @@ +#include <log/log.h> diff --git a/include/android_stub/cutils/native_handle.h b/include/android_stub/cutils/native_handle.h new file mode 100644 index 00000000000..4f07456054d --- /dev/null +++ b/include/android_stub/cutils/native_handle.h @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2009 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. + */ + +#ifndef NATIVE_HANDLE_H_ +#define NATIVE_HANDLE_H_ + +#include <stdalign.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define NATIVE_HANDLE_MAX_FDS 1024 +#define NATIVE_HANDLE_MAX_INTS 1024 + +/* Declare a char array for use with native_handle_init */ +#define NATIVE_HANDLE_DECLARE_STORAGE(name, maxFds, maxInts) \ + alignas(native_handle_t) char (name)[ \ + sizeof(native_handle_t) + sizeof(int) * ((maxFds) + (maxInts))] + +typedef struct native_handle +{ + int version; /* sizeof(native_handle_t) */ + int numFds; /* number of file-descriptors at &data[0] */ + int numInts; /* number of ints at &data[numFds] */ +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wzero-length-array" +#endif + int data[0]; /* numFds + numInts ints */ +#if defined(__clang__) +#pragma clang diagnostic pop +#endif +} native_handle_t; + +typedef const native_handle_t* buffer_handle_t; + +/* + * native_handle_close + * + * closes the file descriptors contained in this native_handle_t + * + * return 0 on success, or a negative error code on failure + * + */ +int native_handle_close(const native_handle_t* h); + +/* + * native_handle_init + * + * Initializes a native_handle_t from storage. storage must be declared with + * NATIVE_HANDLE_DECLARE_STORAGE. numFds and numInts must not respectively + * exceed maxFds and maxInts used to declare the storage. + */ +native_handle_t* native_handle_init(char* storage, int numFds, int numInts); + +/* + * native_handle_create + * + * creates a native_handle_t and initializes it. must be destroyed with + * native_handle_delete(). Note that numFds must be <= NATIVE_HANDLE_MAX_FDS, + * numInts must be <= NATIVE_HANDLE_MAX_INTS, and both must be >= 0. + * + */ +native_handle_t* native_handle_create(int numFds, int numInts); + +/* + * native_handle_clone + * + * creates a native_handle_t and initializes it from another native_handle_t. + * Must be destroyed with native_handle_delete(). + * + */ +native_handle_t* native_handle_clone(const native_handle_t* handle); + +/* + * native_handle_delete + * + * frees a native_handle_t allocated with native_handle_create(). + * This ONLY frees the memory allocated for the native_handle_t, but doesn't + * close the file descriptors; which can be achieved with native_handle_close(). + * + * return 0 on success, or a negative error code on failure + * + */ +int native_handle_delete(native_handle_t* h); + + +#ifdef __cplusplus +} +#endif + +#endif /* NATIVE_HANDLE_H_ */ diff --git a/include/android_stub/cutils/properties.h b/include/android_stub/cutils/properties.h new file mode 100644 index 00000000000..78d8bc65440 --- /dev/null +++ b/include/android_stub/cutils/properties.h @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2006 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. + */ + +#pragma once + +#include <sys/cdefs.h> +#include <stddef.h> +#include <stdint.h> + +#if __has_include(<sys/system_properties.h>) +#include <sys/system_properties.h> +#else +#define PROP_VALUE_MAX 92 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// +// Deprecated. +// +// See <android-base/properties.h> for better API. +// + +#define PROPERTY_KEY_MAX PROP_NAME_MAX +#define PROPERTY_VALUE_MAX PROP_VALUE_MAX + +/* property_get: returns the length of the value which will never be +** greater than PROPERTY_VALUE_MAX - 1 and will always be zero terminated. +** (the length does not include the terminating zero). +** +** If the property read fails or returns an empty value, the default +** value is used (if nonnull). +*/ +int property_get(const char* key, char* value, const char* default_value); + +/* property_get_bool: returns the value of key coerced into a +** boolean. If the property is not set, then the default value is returned. +** +* The following is considered to be true (1): +** "1", "true", "y", "yes", "on" +** +** The following is considered to be false (0): +** "0", "false", "n", "no", "off" +** +** The conversion is whitespace-sensitive (e.g. " off" will not be false). +** +** If no property with this key is set (or the key is NULL) or the boolean +** conversion fails, the default value is returned. +**/ +int8_t property_get_bool(const char *key, int8_t default_value); + +/* property_get_int64: returns the value of key truncated and coerced into a +** int64_t. If the property is not set, then the default value is used. +** +** The numeric conversion is identical to strtoimax with the base inferred: +** - All digits up to the first non-digit characters are read +** - The longest consecutive prefix of digits is converted to a long +** +** Valid strings of digits are: +** - An optional sign character + or - +** - An optional prefix indicating the base (otherwise base 10 is assumed) +** -- 0 prefix is octal +** -- 0x / 0X prefix is hex +** +** Leading/trailing whitespace is ignored. Overflow/underflow will cause +** numeric conversion to fail. +** +** If no property with this key is set (or the key is NULL) or the numeric +** conversion fails, the default value is returned. +**/ +int64_t property_get_int64(const char *key, int64_t default_value); + +/* property_get_int32: returns the value of key truncated and coerced into an +** int32_t. If the property is not set, then the default value is used. +** +** The numeric conversion is identical to strtoimax with the base inferred: +** - All digits up to the first non-digit characters are read +** - The longest consecutive prefix of digits is converted to a long +** +** Valid strings of digits are: +** - An optional sign character + or - +** - An optional prefix indicating the base (otherwise base 10 is assumed) +** -- 0 prefix is octal +** -- 0x / 0X prefix is hex +** +** Leading/trailing whitespace is ignored. Overflow/underflow will cause +** numeric conversion to fail. +** +** If no property with this key is set (or the key is NULL) or the numeric +** conversion fails, the default value is returned. +**/ +int32_t property_get_int32(const char *key, int32_t default_value); + +/* property_set: returns 0 on success, < 0 on failure +*/ +int property_set(const char *key, const char *value); + +int property_list(void (*propfn)(const char *key, const char *value, void *cookie), void *cookie); + +#if defined(__BIONIC_FORTIFY) +#define __property_get_err_str "property_get() called with too small of a buffer" + +#if defined(__clang__) + +/* Some projects use -Weverything; diagnose_if is clang-specific. */ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wgcc-compat" +int property_get(const char* key, char* value, const char* default_value) + __clang_error_if(__bos(value) != __BIONIC_FORTIFY_UNKNOWN_SIZE && + __bos(value) < PROPERTY_VALUE_MAX, + __property_get_err_str); +#pragma clang diagnostic pop + +#else /* defined(__clang__) */ + +extern int __property_get_real(const char *, char *, const char *) + __asm__(__USER_LABEL_PREFIX__ "property_get"); +__errordecl(__property_get_too_small_error, __property_get_err_str); + +__BIONIC_FORTIFY_INLINE +int property_get(const char *key, char *value, const char *default_value) { + size_t bos = __bos(value); + if (bos < PROPERTY_VALUE_MAX) { + __property_get_too_small_error(); + } + return __property_get_real(key, value, default_value); +} + +#endif /* defined(__clang__) */ + +#undef __property_get_err_str +#endif /* defined(__BIONIC_FORTIFY) */ + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/hardware/fb.h b/include/android_stub/hardware/fb.h new file mode 100644 index 00000000000..65720a39316 --- /dev/null +++ b/include/android_stub/hardware/fb.h @@ -0,0 +1,173 @@ +/* + * Copyright (C) 2008 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. + */ + + +#ifndef ANDROID_FB_INTERFACE_H +#define ANDROID_FB_INTERFACE_H + +#include <stdint.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <cutils/native_handle.h> + +#include <hardware/hardware.h> + +__BEGIN_DECLS + +#define GRALLOC_HARDWARE_FB0 "fb0" + +/*****************************************************************************/ + + +/*****************************************************************************/ + +typedef struct framebuffer_device_t { + /** + * Common methods of the framebuffer device. This *must* be the first member of + * framebuffer_device_t as users of this structure will cast a hw_device_t to + * framebuffer_device_t pointer in contexts where it's known the hw_device_t references a + * framebuffer_device_t. + */ + struct hw_device_t common; + + /* flags describing some attributes of the framebuffer */ + const uint32_t flags; + + /* dimensions of the framebuffer in pixels */ + const uint32_t width; + const uint32_t height; + + /* frambuffer stride in pixels */ + const int stride; + + /* framebuffer pixel format */ + const int format; + + /* resolution of the framebuffer's display panel in pixel per inch*/ + const float xdpi; + const float ydpi; + + /* framebuffer's display panel refresh rate in frames per second */ + const float fps; + + /* min swap interval supported by this framebuffer */ + const int minSwapInterval; + + /* max swap interval supported by this framebuffer */ + const int maxSwapInterval; + + /* Number of framebuffers supported*/ + const int numFramebuffers; + + int reserved[7]; + + /* + * requests a specific swap-interval (same definition than EGL) + * + * Returns 0 on success or -errno on error. + */ + int (*setSwapInterval)(struct framebuffer_device_t* window, + int interval); + + /* + * This hook is OPTIONAL. + * + * It is non NULL If the framebuffer driver supports "update-on-demand" + * and the given rectangle is the area of the screen that gets + * updated during (*post)(). + * + * This is useful on devices that are able to DMA only a portion of + * the screen to the display panel, upon demand -- as opposed to + * constantly refreshing the panel 60 times per second, for instance. + * + * Only the area defined by this rectangle is guaranteed to be valid, that + * is, the driver is not allowed to post anything outside of this + * rectangle. + * + * The rectangle evaluated during (*post)() and specifies which area + * of the buffer passed in (*post)() shall to be posted. + * + * return -EINVAL if width or height <=0, or if left or top < 0 + */ + int (*setUpdateRect)(struct framebuffer_device_t* window, + int left, int top, int width, int height); + + /* + * Post <buffer> to the display (display it on the screen) + * The buffer must have been allocated with the + * GRALLOC_USAGE_HW_FB usage flag. + * buffer must be the same width and height as the display and must NOT + * be locked. + * + * The buffer is shown during the next VSYNC. + * + * If the same buffer is posted again (possibly after some other buffer), + * post() will block until the the first post is completed. + * + * Internally, post() is expected to lock the buffer so that a + * subsequent call to gralloc_module_t::(*lock)() with USAGE_RENDER or + * USAGE_*_WRITE will block until it is safe; that is typically once this + * buffer is shown and another buffer has been posted. + * + * Returns 0 on success or -errno on error. + */ + int (*post)(struct framebuffer_device_t* dev, buffer_handle_t buffer); + + + /* + * The (*compositionComplete)() method must be called after the + * compositor has finished issuing GL commands for client buffers. + */ + + int (*compositionComplete)(struct framebuffer_device_t* dev); + + /* + * This hook is OPTIONAL. + * + * If non NULL it will be caused by SurfaceFlinger on dumpsys + */ + void (*dump)(struct framebuffer_device_t* dev, char *buff, int buff_len); + + /* + * (*enableScreen)() is used to either blank (enable=0) or + * unblank (enable=1) the screen this framebuffer is attached to. + * + * Returns 0 on success or -errno on error. + */ + int (*enableScreen)(struct framebuffer_device_t* dev, int enable); + + void* reserved_proc[6]; + +} framebuffer_device_t; + + +/** convenience API for opening and closing a supported device */ + +static inline int framebuffer_open(const struct hw_module_t* module, + struct framebuffer_device_t** device) { + return module->methods->open(module, + GRALLOC_HARDWARE_FB0, TO_HW_DEVICE_T_OPEN(device)); +} + +static inline int framebuffer_close(struct framebuffer_device_t* device) { + return device->common.close(&device->common); +} + + +__END_DECLS + +#endif // ANDROID_FB_INTERFACE_H diff --git a/include/android_stub/hardware/gralloc.h b/include/android_stub/hardware/gralloc.h new file mode 100644 index 00000000000..10a153c0121 --- /dev/null +++ b/include/android_stub/hardware/gralloc.h @@ -0,0 +1,448 @@ +/* + * Copyright (C) 2008 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. + */ + + +#ifndef ANDROID_GRALLOC_INTERFACE_H +#define ANDROID_GRALLOC_INTERFACE_H + +#include <system/graphics.h> +#include <hardware/hardware.h> + +#include <stdint.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <cutils/native_handle.h> + +#include <hardware/hardware.h> +#include <hardware/fb.h> + +__BEGIN_DECLS + +/** + * Module versioning information for the Gralloc hardware module, based on + * gralloc_module_t.common.module_api_version. + * + * Version History: + * + * GRALLOC_MODULE_API_VERSION_0_1: + * Initial Gralloc hardware module API. + * + * GRALLOC_MODULE_API_VERSION_0_2: + * Add support for flexible YCbCr format with (*lock_ycbcr)() method. + * + * GRALLOC_MODULE_API_VERSION_0_3: + * Add support for fence passing to/from lock/unlock. + */ + +#define GRALLOC_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1) +#define GRALLOC_MODULE_API_VERSION_0_2 HARDWARE_MODULE_API_VERSION(0, 2) +#define GRALLOC_MODULE_API_VERSION_0_3 HARDWARE_MODULE_API_VERSION(0, 3) + +#define GRALLOC_DEVICE_API_VERSION_0_1 HARDWARE_DEVICE_API_VERSION(0, 1) + +/** + * The id of this module + */ +#define GRALLOC_HARDWARE_MODULE_ID "gralloc" + +/** + * Name of the graphics device to open + */ + +#define GRALLOC_HARDWARE_GPU0 "gpu0" + +enum { + /* buffer is never read in software */ + GRALLOC_USAGE_SW_READ_NEVER = 0x00000000U, + /* buffer is rarely read in software */ + GRALLOC_USAGE_SW_READ_RARELY = 0x00000002U, + /* buffer is often read in software */ + GRALLOC_USAGE_SW_READ_OFTEN = 0x00000003U, + /* mask for the software read values */ + GRALLOC_USAGE_SW_READ_MASK = 0x0000000FU, + + /* buffer is never written in software */ + GRALLOC_USAGE_SW_WRITE_NEVER = 0x00000000U, + /* buffer is rarely written in software */ + GRALLOC_USAGE_SW_WRITE_RARELY = 0x00000020U, + /* buffer is often written in software */ + GRALLOC_USAGE_SW_WRITE_OFTEN = 0x00000030U, + /* mask for the software write values */ + GRALLOC_USAGE_SW_WRITE_MASK = 0x000000F0U, + + /* buffer will be used as an OpenGL ES texture */ + GRALLOC_USAGE_HW_TEXTURE = 0x00000100U, + /* buffer will be used as an OpenGL ES render target */ + GRALLOC_USAGE_HW_RENDER = 0x00000200U, + /* buffer will be used by the 2D hardware blitter */ + GRALLOC_USAGE_HW_2D = 0x00000400U, + /* buffer will be used by the HWComposer HAL module */ + GRALLOC_USAGE_HW_COMPOSER = 0x00000800U, + /* buffer will be used with the framebuffer device */ + GRALLOC_USAGE_HW_FB = 0x00001000U, + + /* buffer should be displayed full-screen on an external display when + * possible */ + GRALLOC_USAGE_EXTERNAL_DISP = 0x00002000U, + + /* Must have a hardware-protected path to external display sink for + * this buffer. If a hardware-protected path is not available, then + * either don't composite only this buffer (preferred) to the + * external sink, or (less desirable) do not route the entire + * composition to the external sink. */ + GRALLOC_USAGE_PROTECTED = 0x00004000U, + + /* buffer may be used as a cursor */ + GRALLOC_USAGE_CURSOR = 0x00008000U, + + /* buffer will be used with the HW video encoder */ + GRALLOC_USAGE_HW_VIDEO_ENCODER = 0x00010000U, + /* buffer will be written by the HW camera pipeline */ + GRALLOC_USAGE_HW_CAMERA_WRITE = 0x00020000U, + /* buffer will be read by the HW camera pipeline */ + GRALLOC_USAGE_HW_CAMERA_READ = 0x00040000U, + /* buffer will be used as part of zero-shutter-lag queue */ + GRALLOC_USAGE_HW_CAMERA_ZSL = 0x00060000U, + /* mask for the camera access values */ + GRALLOC_USAGE_HW_CAMERA_MASK = 0x00060000U, + /* mask for the software usage bit-mask */ + GRALLOC_USAGE_HW_MASK = 0x00071F00U, + + /* buffer will be used as a RenderScript Allocation */ + GRALLOC_USAGE_RENDERSCRIPT = 0x00100000U, + + /* Set by the consumer to indicate to the producer that they may attach a + * buffer that they did not detach from the BufferQueue. Will be filtered + * out by GRALLOC_USAGE_ALLOC_MASK, so gralloc modules will not need to + * handle this flag. */ + GRALLOC_USAGE_FOREIGN_BUFFERS = 0x00200000U, + + /* buffer will be used as input to HW HEIC image encoder */ + GRALLOC_USAGE_HW_IMAGE_ENCODER = 0x08000000U, + + /* Mask of all flags which could be passed to a gralloc module for buffer + * allocation. Any flags not in this mask do not need to be handled by + * gralloc modules. */ + GRALLOC_USAGE_ALLOC_MASK = ~(GRALLOC_USAGE_FOREIGN_BUFFERS), + + /* implementation-specific private usage flags */ + GRALLOC_USAGE_PRIVATE_0 = 0x10000000U, + GRALLOC_USAGE_PRIVATE_1 = 0x20000000U, + GRALLOC_USAGE_PRIVATE_2 = 0x40000000U, + GRALLOC_USAGE_PRIVATE_3 = 0x80000000U, + GRALLOC_USAGE_PRIVATE_MASK = 0xF0000000U, +}; + +/*****************************************************************************/ + +/** + * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM + * and the fields of this data structure must begin with hw_module_t + * followed by module specific information. + */ +typedef struct gralloc_module_t { + struct hw_module_t common; + + /* + * (*registerBuffer)() must be called before a buffer_handle_t that has not + * been created with (*alloc_device_t::alloc)() can be used. + * + * This is intended to be used with buffer_handle_t's that have been + * received in this process through IPC. + * + * This function checks that the handle is indeed a valid one and prepares + * it for use with (*lock)() and (*unlock)(). + * + * It is not necessary to call (*registerBuffer)() on a handle created + * with (*alloc_device_t::alloc)(). + * + * returns an error if this buffer_handle_t is not valid. + */ + int (*registerBuffer)(struct gralloc_module_t const* module, + buffer_handle_t handle); + + /* + * (*unregisterBuffer)() is called once this handle is no longer needed in + * this process. After this call, it is an error to call (*lock)(), + * (*unlock)(), or (*registerBuffer)(). + * + * This function doesn't close or free the handle itself; this is done + * by other means, usually through libcutils's native_handle_close() and + * native_handle_free(). + * + * It is an error to call (*unregisterBuffer)() on a buffer that wasn't + * explicitly registered first. + */ + int (*unregisterBuffer)(struct gralloc_module_t const* module, + buffer_handle_t handle); + + /* + * The (*lock)() method is called before a buffer is accessed for the + * specified usage. This call may block, for instance if the h/w needs + * to finish rendering or if CPU caches need to be synchronized. + * + * The caller promises to modify only pixels in the area specified + * by (l,t,w,h). + * + * The content of the buffer outside of the specified area is NOT modified + * by this call. + * + * If usage specifies GRALLOC_USAGE_SW_*, vaddr is filled with the address + * of the buffer in virtual memory. + * + * Note calling (*lock)() on HAL_PIXEL_FORMAT_YCbCr_*_888 buffers will fail + * and return -EINVAL. These buffers must be locked with (*lock_ycbcr)() + * instead. + * + * THREADING CONSIDERATIONS: + * + * It is legal for several different threads to lock a buffer from + * read access, none of the threads are blocked. + * + * However, locking a buffer simultaneously for write or read/write is + * undefined, but: + * - shall not result in termination of the process + * - shall not block the caller + * It is acceptable to return an error or to leave the buffer's content + * into an indeterminate state. + * + * If the buffer was created with a usage mask incompatible with the + * requested usage flags here, -EINVAL is returned. + * + */ + + int (*lock)(struct gralloc_module_t const* module, + buffer_handle_t handle, int usage, + int l, int t, int w, int h, + void** vaddr); + + + /* + * The (*unlock)() method must be called after all changes to the buffer + * are completed. + */ + + int (*unlock)(struct gralloc_module_t const* module, + buffer_handle_t handle); + + + /* reserved for future use */ + int (*perform)(struct gralloc_module_t const* module, + int operation, ... ); + + /* + * The (*lock_ycbcr)() method is like the (*lock)() method, with the + * difference that it fills a struct ycbcr with a description of the buffer + * layout, and zeroes out the reserved fields. + * + * If the buffer format is not compatible with a flexible YUV format (e.g. + * the buffer layout cannot be represented with the ycbcr struct), it + * will return -EINVAL. + * + * This method must work on buffers with HAL_PIXEL_FORMAT_YCbCr_*_888 + * if supported by the device, as well as with any other format that is + * requested by the multimedia codecs when they are configured with a + * flexible-YUV-compatible color-format with android native buffers. + * + * Note that this method may also be called on buffers of other formats, + * including non-YUV formats. + * + * Added in GRALLOC_MODULE_API_VERSION_0_2. + */ + + int (*lock_ycbcr)(struct gralloc_module_t const* module, + buffer_handle_t handle, int usage, + int l, int t, int w, int h, + struct android_ycbcr *ycbcr); + + /* + * The (*lockAsync)() method is like the (*lock)() method except + * that the buffer's sync fence object is passed into the lock + * call instead of requiring the caller to wait for completion. + * + * The gralloc implementation takes ownership of the fenceFd and + * is responsible for closing it when no longer needed. + * + * Added in GRALLOC_MODULE_API_VERSION_0_3. + */ + int (*lockAsync)(struct gralloc_module_t const* module, + buffer_handle_t handle, int usage, + int l, int t, int w, int h, + void** vaddr, int fenceFd); + + /* + * The (*unlockAsync)() method is like the (*unlock)() method + * except that a buffer sync fence object is returned from the + * lock call, representing the completion of any pending work + * performed by the gralloc implementation. + * + * The caller takes ownership of the fenceFd and is responsible + * for closing it when no longer needed. + * + * Added in GRALLOC_MODULE_API_VERSION_0_3. + */ + int (*unlockAsync)(struct gralloc_module_t const* module, + buffer_handle_t handle, int* fenceFd); + + /* + * The (*lockAsync_ycbcr)() method is like the (*lock_ycbcr)() + * method except that the buffer's sync fence object is passed + * into the lock call instead of requiring the caller to wait for + * completion. + * + * The gralloc implementation takes ownership of the fenceFd and + * is responsible for closing it when no longer needed. + * + * Added in GRALLOC_MODULE_API_VERSION_0_3. + */ + int (*lockAsync_ycbcr)(struct gralloc_module_t const* module, + buffer_handle_t handle, int usage, + int l, int t, int w, int h, + struct android_ycbcr *ycbcr, int fenceFd); + + /* getTransportSize(..., outNumFds, outNumInts) + * This function is mandatory on devices running IMapper2.1 or higher. + * + * Get the transport size of a buffer. An imported buffer handle is a raw + * buffer handle with the process-local runtime data appended. This + * function, for example, allows a caller to omit the process-local + * runtime data at the tail when serializing the imported buffer handle. + * + * Note that a client might or might not omit the process-local runtime + * data when sending an imported buffer handle. The mapper must support + * both cases on the receiving end. + */ + int32_t (*getTransportSize)( + struct gralloc_module_t const* module, buffer_handle_t handle, uint32_t *outNumFds, + uint32_t *outNumInts); + + /* validateBufferSize(..., w, h, format, usage, stride) + * This function is mandatory on devices running IMapper2.1 or higher. + * + * Validate that the buffer can be safely accessed by a caller who assumes + * the specified width, height, format, usage, and stride. This must at least validate + * that the buffer size is large enough. Validating the buffer against + * individual buffer attributes is optional. + */ + int32_t (*validateBufferSize)( + struct gralloc_module_t const* device, buffer_handle_t handle, + uint32_t w, uint32_t h, int32_t format, int usage, + uint32_t stride); + + /* reserved for future use */ + void* reserved_proc[1]; + +} gralloc_module_t; + +/*****************************************************************************/ + +/** + * Every device data structure must begin with hw_device_t + * followed by module specific public methods and attributes. + */ + +typedef struct alloc_device_t { + struct hw_device_t common; + + /* + * (*alloc)() Allocates a buffer in graphic memory with the requested + * parameters and returns a buffer_handle_t and the stride in pixels to + * allow the implementation to satisfy hardware constraints on the width + * of a pixmap (eg: it may have to be multiple of 8 pixels). + * The CALLER TAKES OWNERSHIP of the buffer_handle_t. + * + * If format is HAL_PIXEL_FORMAT_YCbCr_420_888, the returned stride must be + * 0, since the actual strides are available from the android_ycbcr + * structure. + * + * Returns 0 on success or -errno on error. + */ + + int (*alloc)(struct alloc_device_t* dev, + int w, int h, int format, int usage, + buffer_handle_t* handle, int* stride); + + /* + * (*free)() Frees a previously allocated buffer. + * Behavior is undefined if the buffer is still mapped in any process, + * but shall not result in termination of the program or security breaches + * (allowing a process to get access to another process' buffers). + * THIS FUNCTION TAKES OWNERSHIP of the buffer_handle_t which becomes + * invalid after the call. + * + * Returns 0 on success or -errno on error. + */ + int (*free)(struct alloc_device_t* dev, + buffer_handle_t handle); + + /* This hook is OPTIONAL. + * + * If non NULL it will be caused by SurfaceFlinger on dumpsys + */ + void (*dump)(struct alloc_device_t *dev, char *buff, int buff_len); + + void* reserved_proc[7]; +} alloc_device_t; + + +/** convenience API for opening and closing a supported device */ + +static inline int gralloc_open(const struct hw_module_t* module, + struct alloc_device_t** device) { + return module->methods->open(module, + GRALLOC_HARDWARE_GPU0, TO_HW_DEVICE_T_OPEN(device)); +} + +static inline int gralloc_close(struct alloc_device_t* device) { + return device->common.close(&device->common); +} + +/** + * map_usage_to_memtrack should be called after allocating a gralloc buffer. + * + * @param usage - it is the flag used when alloc function is called. + * + * This function maps the gralloc usage flags to appropriate memtrack bucket. + * GrallocHAL implementers and users should make an additional ION_IOCTL_TAG + * call using the memtrack tag returned by this function. This will help the + * in-kernel memtack to categorize the memory allocated by different processes + * according to their usage. + * + */ +static inline const char* map_usage_to_memtrack(uint32_t usage) { + usage &= GRALLOC_USAGE_ALLOC_MASK; + + if ((usage & GRALLOC_USAGE_HW_CAMERA_WRITE) != 0) { + return "camera"; + } else if ((usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) != 0 || + (usage & GRALLOC_USAGE_EXTERNAL_DISP) != 0) { + return "video"; + } else if ((usage & GRALLOC_USAGE_HW_RENDER) != 0 || + (usage & GRALLOC_USAGE_HW_TEXTURE) != 0) { + return "gl"; + } else if ((usage & GRALLOC_USAGE_HW_CAMERA_READ) != 0) { + return "camera"; + } else if ((usage & GRALLOC_USAGE_SW_READ_MASK) != 0 || + (usage & GRALLOC_USAGE_SW_WRITE_MASK) != 0) { + return "cpu"; + } + return "graphics"; +} + +__END_DECLS + +#endif // ANDROID_GRALLOC_INTERFACE_H diff --git a/include/android_stub/hardware/hardware.h b/include/android_stub/hardware/hardware.h new file mode 100644 index 00000000000..bf076f6c34c --- /dev/null +++ b/include/android_stub/hardware/hardware.h @@ -0,0 +1,244 @@ +/* + * Copyright (C) 2008 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. + */ + +#ifndef ANDROID_INCLUDE_HARDWARE_HARDWARE_H +#define ANDROID_INCLUDE_HARDWARE_HARDWARE_H + +#include <stdint.h> +#include <sys/cdefs.h> + +#include <cutils/native_handle.h> +#include <system/graphics.h> + +__BEGIN_DECLS + +/* + * Value for the hw_module_t.tag field + */ + +#define MAKE_TAG_CONSTANT(A,B,C,D) (((A) << 24) | ((B) << 16) | ((C) << 8) | (D)) + +#define HARDWARE_MODULE_TAG MAKE_TAG_CONSTANT('H', 'W', 'M', 'T') +#define HARDWARE_DEVICE_TAG MAKE_TAG_CONSTANT('H', 'W', 'D', 'T') + +#define HARDWARE_MAKE_API_VERSION(maj,min) \ + ((((maj) & 0xff) << 8) | ((min) & 0xff)) + +#define HARDWARE_MAKE_API_VERSION_2(maj,min,hdr) \ + ((((maj) & 0xff) << 24) | (((min) & 0xff) << 16) | ((hdr) & 0xffff)) +#define HARDWARE_API_VERSION_2_MAJ_MIN_MASK 0xffff0000 +#define HARDWARE_API_VERSION_2_HEADER_MASK 0x0000ffff + + +/* + * The current HAL API version. + * + * All module implementations must set the hw_module_t.hal_api_version field + * to this value when declaring the module with HAL_MODULE_INFO_SYM. + * + * Note that previous implementations have always set this field to 0. + * Therefore, libhardware HAL API will always consider versions 0.0 and 1.0 + * to be 100% binary compatible. + * + */ +#define HARDWARE_HAL_API_VERSION HARDWARE_MAKE_API_VERSION(1, 0) + +/* + * Helper macros for module implementors. + * + * The derived modules should provide convenience macros for supported + * versions so that implementations can explicitly specify module/device + * versions at definition time. + * + * Use this macro to set the hw_module_t.module_api_version field. + */ +#define HARDWARE_MODULE_API_VERSION(maj,min) HARDWARE_MAKE_API_VERSION(maj,min) +#define HARDWARE_MODULE_API_VERSION_2(maj,min,hdr) HARDWARE_MAKE_API_VERSION_2(maj,min,hdr) + +/* + * Use this macro to set the hw_device_t.version field + */ +#define HARDWARE_DEVICE_API_VERSION(maj,min) HARDWARE_MAKE_API_VERSION(maj,min) +#define HARDWARE_DEVICE_API_VERSION_2(maj,min,hdr) HARDWARE_MAKE_API_VERSION_2(maj,min,hdr) + +struct hw_module_t; +struct hw_module_methods_t; +struct hw_device_t; + +/** + * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM + * and the fields of this data structure must begin with hw_module_t + * followed by module specific information. + */ +typedef struct hw_module_t { + /** tag must be initialized to HARDWARE_MODULE_TAG */ + uint32_t tag; + + /** + * The API version of the implemented module. The module owner is + * responsible for updating the version when a module interface has + * changed. + * + * The derived modules such as gralloc and audio own and manage this field. + * The module user must interpret the version field to decide whether or + * not to inter-operate with the supplied module implementation. + * For example, SurfaceFlinger is responsible for making sure that + * it knows how to manage different versions of the gralloc-module API, + * and AudioFlinger must know how to do the same for audio-module API. + * + * The module API version should include a major and a minor component. + * For example, version 1.0 could be represented as 0x0100. This format + * implies that versions 0x0100-0x01ff are all API-compatible. + * + * In the future, libhardware will expose a hw_get_module_version() + * (or equivalent) function that will take minimum/maximum supported + * versions as arguments and would be able to reject modules with + * versions outside of the supplied range. + */ + uint16_t module_api_version; +#define version_major module_api_version + /** + * version_major/version_minor defines are supplied here for temporary + * source code compatibility. They will be removed in the next version. + * ALL clients must convert to the new version format. + */ + + /** + * The API version of the HAL module interface. This is meant to + * version the hw_module_t, hw_module_methods_t, and hw_device_t + * structures and definitions. + * + * The HAL interface owns this field. Module users/implementations + * must NOT rely on this value for version information. + * + * Presently, 0 is the only valid value. + */ + uint16_t hal_api_version; +#define version_minor hal_api_version + + /** Identifier of module */ + const char *id; + + /** Name of this module */ + const char *name; + + /** Author/owner/implementor of the module */ + const char *author; + + /** Modules methods */ + struct hw_module_methods_t* methods; + + /** module's dso */ + void* dso; + +#ifdef __LP64__ + uint64_t reserved[32-7]; +#else + /** padding to 128 bytes, reserved for future use */ + uint32_t reserved[32-7]; +#endif + +} hw_module_t; + +typedef struct hw_module_methods_t { + /** Open a specific device */ + int (*open)(const struct hw_module_t* module, const char* id, + struct hw_device_t** device); + +} hw_module_methods_t; + +/** + * Every device data structure must begin with hw_device_t + * followed by module specific public methods and attributes. + */ +typedef struct hw_device_t { + /** tag must be initialized to HARDWARE_DEVICE_TAG */ + uint32_t tag; + + /** + * Version of the module-specific device API. This value is used by + * the derived-module user to manage different device implementations. + * + * The module user is responsible for checking the module_api_version + * and device version fields to ensure that the user is capable of + * communicating with the specific module implementation. + * + * One module can support multiple devices with different versions. This + * can be useful when a device interface changes in an incompatible way + * but it is still necessary to support older implementations at the same + * time. One such example is the Camera 2.0 API. + * + * This field is interpreted by the module user and is ignored by the + * HAL interface itself. + */ + uint32_t version; + + /** reference to the module this device belongs to */ + struct hw_module_t* module; + + /** padding reserved for future use */ +#ifdef __LP64__ + uint64_t reserved[12]; +#else + uint32_t reserved[12]; +#endif + + /** Close this device */ + int (*close)(struct hw_device_t* device); + +} hw_device_t; + +#ifdef __cplusplus +#define TO_HW_DEVICE_T_OPEN(x) reinterpret_cast<struct hw_device_t**>(x) +#else +#define TO_HW_DEVICE_T_OPEN(x) (struct hw_device_t**)(x) +#endif + +/** + * Name of the hal_module_info + */ +#define HAL_MODULE_INFO_SYM HMI + +/** + * Name of the hal_module_info as a string + */ +#define HAL_MODULE_INFO_SYM_AS_STR "HMI" + +/** + * Get the module info associated with a module by id. + * + * @return: 0 == success, <0 == error and *module == NULL + */ +int hw_get_module(const char *id, const struct hw_module_t **module); + +/** + * Get the module info associated with a module instance by class 'class_id' + * and instance 'inst'. + * + * Some modules types necessitate multiple instances. For example audio supports + * multiple concurrent interfaces and thus 'audio' is the module class + * and 'primary' or 'a2dp' are module interfaces. This implies that the files + * providing these modules would be named audio.primary.<variant>.so and + * audio.a2dp.<variant>.so + * + * @return: 0 == success, <0 == error and *module == NULL + */ +int hw_get_module_by_class(const char *class_id, const char *inst, + const struct hw_module_t **module); + +__END_DECLS + +#endif /* ANDROID_INCLUDE_HARDWARE_HARDWARE_H */ diff --git a/include/android_stub/hardware/hwvulkan.h b/include/android_stub/hardware/hwvulkan.h new file mode 100644 index 00000000000..9e9a14d4897 --- /dev/null +++ b/include/android_stub/hardware/hwvulkan.h @@ -0,0 +1,71 @@ +/* + * Copyright 2015 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. + */ + +#ifndef ANDROID_HWVULKAN_H +#define ANDROID_HWVULKAN_H + +#include <hardware/hardware.h> +#include <vulkan/vulkan.h> + +__BEGIN_DECLS + +#define HWVULKAN_HARDWARE_MODULE_ID "vulkan" + +#define HWVULKAN_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1) +#define HWVULKAN_DEVICE_API_VERSION_0_1 HARDWARE_DEVICE_API_VERSION_2(0, 1, 0) + +#define HWVULKAN_DEVICE_0 "vk0" + +typedef struct hwvulkan_module_t { + struct hw_module_t common; +} hwvulkan_module_t; + +/* Dispatchable Vulkan object handles must be pointers, which must point to + * instances of hwvulkan_dispatch_t (potentially followed by additional + * implementation-defined data). On return from the creation function, the + * 'magic' field must contain HWVULKAN_DISPATCH_MAGIC; the loader will overwrite + * the 'vtbl' field. + * + * NOTE: The magic value and the layout of hwvulkan_dispatch_t match the LunarG + * loader used on platforms, to avoid pointless annoying differences for + * multi-platform drivers. Don't change them without a good reason. If there is + * an opportunity to change it, using a magic value that doesn't leave the + * upper 32-bits zero on 64-bit platforms would be nice. + */ +#define HWVULKAN_DISPATCH_MAGIC 0x01CDC0DE +typedef union { + uintptr_t magic; + const void* vtbl; +} hwvulkan_dispatch_t; + +/* A hwvulkan_device_t corresponds to an ICD on other systems. Currently there + * can only be one on a system (HWVULKAN_DEVICE_0). It is opened once per + * process when the Vulkan API is first used; the hw_device_t::close() function + * is never called. Any non-trivial resource allocation should be done when + * the VkInstance is created rather than when the hwvulkan_device_t is opened. + */ +typedef struct hwvulkan_device_t { + struct hw_device_t common; + + PFN_vkEnumerateInstanceExtensionProperties + EnumerateInstanceExtensionProperties; + PFN_vkCreateInstance CreateInstance; + PFN_vkGetInstanceProcAddr GetInstanceProcAddr; +} hwvulkan_device_t; + +__END_DECLS + +#endif // ANDROID_HWVULKAN_H diff --git a/include/android_stub/log/event_tag_map.h b/include/android_stub/log/event_tag_map.h new file mode 100644 index 00000000000..f7ec208b337 --- /dev/null +++ b/include/android_stub/log/event_tag_map.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2007 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. + */ + +#pragma once + +#include <stddef.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define EVENT_TAG_MAP_FILE "/system/etc/event-log-tags" + +struct EventTagMap; +typedef struct EventTagMap EventTagMap; + +/* + * Open the specified file as an event log tag map. + * + * Returns NULL on failure. + */ +EventTagMap* android_openEventTagMap(const char* fileName); + +/* + * Close the map. + */ +void android_closeEventTagMap(EventTagMap* map); + +/* + * Look up a tag by index. Returns the tag string, or NULL if not found. + */ +const char* android_lookupEventTag(const EventTagMap* map, unsigned int tag) + __attribute__(( + deprecated("use android_lookupEventTag_len() instead to minimize " + "MAP_PRIVATE copy-on-write memory impact"))); + +/* + * Look up a tag by index. Returns the tag string & string length, or NULL if + * not found. Returned string is not guaranteed to be nul terminated. + */ +const char* android_lookupEventTag_len(const EventTagMap* map, size_t* len, + unsigned int tag); + +/* + * Look up a format by index. Returns the format string & string length, + * or NULL if not found. Returned string is not guaranteed to be nul terminated. + */ +const char* android_lookupEventFormat_len(const EventTagMap* map, size_t* len, + unsigned int tag); + +/* + * Look up tagname, generate one if necessary, and return a tag + */ +int android_lookupEventTagNum(EventTagMap* map, const char* tagname, + const char* format, int prio); + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/log/log.h b/include/android_stub/log/log.h new file mode 100644 index 00000000000..d7e9b7dab41 --- /dev/null +++ b/include/android_stub/log/log.h @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2005-2014 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. + */ + +#pragma once + +/* Too many in the ecosystem assume these are included */ +#if !defined(_WIN32) +#include <pthread.h> +#endif +#include <stdint.h> /* uint16_t, int32_t */ +#include <stdio.h> +#include <time.h> +#include <unistd.h> + +#include <android/log.h> +#include <log/log_id.h> +#include <log/log_main.h> +#include <log/log_radio.h> +#include <log/log_safetynet.h> +#include <log/log_system.h> +#include <log/log_time.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * LOG_TAG is the local tag used for the following simplified + * logging macros. You can change this preprocessor definition + * before using the other macros to change the tag. + */ + +#ifndef LOG_TAG +#define LOG_TAG NULL +#endif + +/* + * Normally we strip the effects of ALOGV (VERBOSE messages), + * LOG_FATAL and LOG_FATAL_IF (FATAL assert messages) from the + * release builds be defining NDEBUG. You can modify this (for + * example with "#define LOG_NDEBUG 0" at the top of your source + * file) to change that behavior. + */ + +#ifndef LOG_NDEBUG +#ifdef NDEBUG +#define LOG_NDEBUG 1 +#else +#define LOG_NDEBUG 0 +#endif +#endif + +/* + * The maximum size of the log entry payload that can be + * written to the logger. An attempt to write more than + * this amount will result in a truncated log entry. + */ +#define LOGGER_ENTRY_MAX_PAYLOAD 4068 + +/* + * Event logging. + */ + +/* + * The following should not be used directly. + */ + +int __android_log_bwrite(int32_t tag, const void* payload, size_t len); +int __android_log_btwrite(int32_t tag, char type, const void* payload, + size_t len); +int __android_log_bswrite(int32_t tag, const char* payload); + +int __android_log_stats_bwrite(int32_t tag, const void* payload, size_t len); + +#define android_bWriteLog(tag, payload, len) \ + __android_log_bwrite(tag, payload, len) +#define android_btWriteLog(tag, type, payload, len) \ + __android_log_btwrite(tag, type, payload, len) + +/* + * Event log entry types. + */ +typedef enum { + /* Special markers for android_log_list_element type */ + EVENT_TYPE_LIST_STOP = '\n', /* declare end of list */ + EVENT_TYPE_UNKNOWN = '?', /* protocol error */ + + /* must match with declaration in java/android/android/util/EventLog.java */ + EVENT_TYPE_INT = 0, /* int32_t */ + EVENT_TYPE_LONG = 1, /* int64_t */ + EVENT_TYPE_STRING = 2, + EVENT_TYPE_LIST = 3, + EVENT_TYPE_FLOAT = 4, +} AndroidEventLogType; + +#ifndef LOG_EVENT_INT +#define LOG_EVENT_INT(_tag, _value) \ + { \ + int intBuf = _value; \ + (void)android_btWriteLog(_tag, EVENT_TYPE_INT, &intBuf, sizeof(intBuf)); \ + } +#endif +#ifndef LOG_EVENT_LONG +#define LOG_EVENT_LONG(_tag, _value) \ + { \ + long long longBuf = _value; \ + (void)android_btWriteLog(_tag, EVENT_TYPE_LONG, &longBuf, sizeof(longBuf)); \ + } +#endif +#ifndef LOG_EVENT_FLOAT +#define LOG_EVENT_FLOAT(_tag, _value) \ + { \ + float floatBuf = _value; \ + (void)android_btWriteLog(_tag, EVENT_TYPE_FLOAT, &floatBuf, \ + sizeof(floatBuf)); \ + } +#endif +#ifndef LOG_EVENT_STRING +#define LOG_EVENT_STRING(_tag, _value) \ + (void)__android_log_bswrite(_tag, _value); +#endif + +/* --------------------------------------------------------------------- */ + +/* + * Release any logger resources (a new log write will immediately re-acquire) + * + * This is specifically meant to be used by Zygote to close open file descriptors after fork() + * and before specialization. O_CLOEXEC is used on file descriptors, so they will be closed upon + * exec() in normal use cases. + * + * Note that this is not safe to call from a multi-threaded program. + */ +void __android_log_close(void); + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/log/log_event_list.h b/include/android_stub/log/log_event_list.h new file mode 100644 index 00000000000..deadf2060ec --- /dev/null +++ b/include/android_stub/log/log_event_list.h @@ -0,0 +1,278 @@ +/* + * Copyright (C) 2005-2016 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. + */ + +#pragma once + +#include <errno.h> +#include <stdint.h> + +#ifdef __cplusplus +#include <string> +#endif + +#include <log/log.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* For manipulating lists of events. */ + +#define ANDROID_MAX_LIST_NEST_DEPTH 8 + +/* + * The opaque context used to manipulate lists of events. + */ +typedef struct android_log_context_internal* android_log_context; + +/* + * Elements returned when reading a list of events. + */ +typedef struct { + AndroidEventLogType type; + uint16_t complete; + uint16_t len; + union { + int32_t int32; + int64_t int64; + char* string; + float float32; + } data; +} android_log_list_element; + +/* + * Creates a context associated with an event tag to write elements to + * the list of events. + */ +android_log_context create_android_logger(uint32_t tag); + +/* All lists must be braced by a begin and end call */ +/* + * NB: If the first level braces are missing when specifying multiple + * elements, we will manufacturer a list to embrace it for your API + * convenience. For a single element, it will remain solitary. + */ +int android_log_write_list_begin(android_log_context ctx); +int android_log_write_list_end(android_log_context ctx); + +int android_log_write_int32(android_log_context ctx, int32_t value); +int android_log_write_int64(android_log_context ctx, int64_t value); +int android_log_write_string8(android_log_context ctx, const char* value); +int android_log_write_string8_len(android_log_context ctx, const char* value, + size_t maxlen); +int android_log_write_float32(android_log_context ctx, float value); + +/* Submit the composed list context to the specified logger id */ +/* NB: LOG_ID_EVENTS and LOG_ID_SECURITY only valid binary buffers */ +int android_log_write_list(android_log_context ctx, log_id_t id); + +/* + * Creates a context from a raw buffer representing a list of events to be read. + */ +android_log_context create_android_log_parser(const char* msg, size_t len); + +android_log_list_element android_log_read_next(android_log_context ctx); +android_log_list_element android_log_peek_next(android_log_context ctx); + +/* Reset writer context */ +int android_log_reset(android_log_context ctx); + +/* Reset reader context */ +int android_log_parser_reset(android_log_context ctx, + const char* msg, size_t len); + +/* Finished with reader or writer context */ +int android_log_destroy(android_log_context* ctx); + +#ifdef __cplusplus +/* android_log_list C++ helpers */ +extern "C++" { +class android_log_event_list { + private: + android_log_context ctx; + int ret; + + android_log_event_list(const android_log_event_list&) = delete; + void operator=(const android_log_event_list&) = delete; + + public: + explicit android_log_event_list(int tag) : ret(0) { + ctx = create_android_logger(static_cast<uint32_t>(tag)); + } + ~android_log_event_list() { + android_log_destroy(&ctx); + } + + int close() { + int retval = android_log_destroy(&ctx); + if (retval < 0) ret = retval; + return retval; + } + + /* To allow above C calls to use this class as parameter */ + operator android_log_context() const { + return ctx; + } + + /* return errors or transmit status */ + int status() const { + return ret; + } + + int begin() { + int retval = android_log_write_list_begin(ctx); + if (retval < 0) ret = retval; + return ret; + } + int end() { + int retval = android_log_write_list_end(ctx); + if (retval < 0) ret = retval; + return ret; + } + + android_log_event_list& operator<<(int32_t value) { + int retval = android_log_write_int32(ctx, value); + if (retval < 0) ret = retval; + return *this; + } + + android_log_event_list& operator<<(uint32_t value) { + int retval = android_log_write_int32(ctx, static_cast<int32_t>(value)); + if (retval < 0) ret = retval; + return *this; + } + + android_log_event_list& operator<<(bool value) { + int retval = android_log_write_int32(ctx, value ? 1 : 0); + if (retval < 0) ret = retval; + return *this; + } + + android_log_event_list& operator<<(int64_t value) { + int retval = android_log_write_int64(ctx, value); + if (retval < 0) ret = retval; + return *this; + } + + android_log_event_list& operator<<(uint64_t value) { + int retval = android_log_write_int64(ctx, static_cast<int64_t>(value)); + if (retval < 0) ret = retval; + return *this; + } + + android_log_event_list& operator<<(const char* value) { + int retval = android_log_write_string8(ctx, value); + if (retval < 0) ret = retval; + return *this; + } + + android_log_event_list& operator<<(const std::string& value) { + int retval = + android_log_write_string8_len(ctx, value.data(), value.length()); + if (retval < 0) ret = retval; + return *this; + } + + android_log_event_list& operator<<(float value) { + int retval = android_log_write_float32(ctx, value); + if (retval < 0) ret = retval; + return *this; + } + + int write(log_id_t id = LOG_ID_EVENTS) { + /* facilitate -EBUSY retry */ + if ((ret == -EBUSY) || (ret > 0)) ret = 0; + int retval = android_log_write_list(ctx, id); + /* existing errors trump transmission errors */ + if (!ret) ret = retval; + return ret; + } + + int operator<<(log_id_t id) { + write(id); + android_log_destroy(&ctx); + return ret; + } + + /* + * Append<Type> methods removes any integer promotion + * confusion, and adds access to string with length. + * Append methods are also added for all types for + * convenience. + */ + + bool AppendInt(int32_t value) { + int retval = android_log_write_int32(ctx, value); + if (retval < 0) ret = retval; + return ret >= 0; + } + + bool AppendLong(int64_t value) { + int retval = android_log_write_int64(ctx, value); + if (retval < 0) ret = retval; + return ret >= 0; + } + + bool AppendString(const char* value) { + int retval = android_log_write_string8(ctx, value); + if (retval < 0) ret = retval; + return ret >= 0; + } + + bool AppendString(const char* value, size_t len) { + int retval = android_log_write_string8_len(ctx, value, len); + if (retval < 0) ret = retval; + return ret >= 0; + } + + bool AppendString(const std::string& value) { + int retval = + android_log_write_string8_len(ctx, value.data(), value.length()); + if (retval < 0) ret = retval; + return ret; + } + + bool Append(const std::string& value) { + int retval = + android_log_write_string8_len(ctx, value.data(), value.length()); + if (retval < 0) ret = retval; + return ret; + } + + bool AppendFloat(float value) { + int retval = android_log_write_float32(ctx, value); + if (retval < 0) ret = retval; + return ret >= 0; + } + + template <typename Tvalue> + bool Append(Tvalue value) { + *this << value; + return ret >= 0; + } + + bool Append(const char* value, size_t len) { + int retval = android_log_write_string8_len(ctx, value, len); + if (retval < 0) ret = retval; + return ret >= 0; + } +}; +} +#endif + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/log/log_id.h b/include/android_stub/log/log_id.h new file mode 100644 index 00000000000..8e4faeb061e --- /dev/null +++ b/include/android_stub/log/log_id.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2005-2017 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. + */ + +#pragma once + +#include <android/log.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * log_id_t helpers + */ +log_id_t android_name_to_log_id(const char* logName); +const char* android_log_id_to_name(log_id_t log_id); + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/log/log_main.h b/include/android_stub/log/log_main.h new file mode 100644 index 00000000000..1bd1c8aec19 --- /dev/null +++ b/include/android_stub/log/log_main.h @@ -0,0 +1,380 @@ +/* + * Copyright (C) 2005-2017 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. + */ + +#pragma once + +#include <stdbool.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <android/log.h> + +__BEGIN_DECLS + +/* + * Normally we strip the effects of ALOGV (VERBOSE messages), + * LOG_FATAL and LOG_FATAL_IF (FATAL assert messages) from the + * release builds be defining NDEBUG. You can modify this (for + * example with "#define LOG_NDEBUG 0" at the top of your source + * file) to change that behavior. + */ + +#ifndef LOG_NDEBUG +#ifdef NDEBUG +#define LOG_NDEBUG 1 +#else +#define LOG_NDEBUG 0 +#endif +#endif + +/* --------------------------------------------------------------------- */ + +/* + * This file uses ", ## __VA_ARGS__" zero-argument token pasting to + * work around issues with debug-only syntax errors in assertions + * that are missing format strings. See commit + * 19299904343daf191267564fe32e6cd5c165cd42 + */ +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" +#endif + +/* + * Use __VA_ARGS__ if running a static analyzer, + * to avoid warnings of unused variables in __VA_ARGS__. + * Use constexpr function in C++ mode, so these macros can be used + * in other constexpr functions without warning. + */ +#ifdef __clang_analyzer__ +#ifdef __cplusplus +extern "C++" { +template <typename... Ts> +constexpr int __fake_use_va_args(Ts...) { + return 0; +} +} +#else +extern int __fake_use_va_args(int, ...); +#endif /* __cplusplus */ +#define __FAKE_USE_VA_ARGS(...) ((void)__fake_use_va_args(0, ##__VA_ARGS__)) +#else +#define __FAKE_USE_VA_ARGS(...) ((void)(0)) +#endif /* __clang_analyzer__ */ + +#ifndef __predict_false +#define __predict_false(exp) __builtin_expect((exp) != 0, 0) +#endif + +#define android_writeLog(prio, tag, text) __android_log_write(prio, tag, text) + +#define android_printLog(prio, tag, ...) \ + __android_log_print(prio, tag, __VA_ARGS__) + +#define android_vprintLog(prio, cond, tag, ...) \ + __android_log_vprint(prio, tag, __VA_ARGS__) + +/* + * Log macro that allows you to specify a number for the priority. + */ +#ifndef LOG_PRI +#define LOG_PRI(priority, tag, ...) android_printLog(priority, tag, __VA_ARGS__) +#endif + +/* + * Log macro that allows you to pass in a varargs ("args" is a va_list). + */ +#ifndef LOG_PRI_VA +#define LOG_PRI_VA(priority, tag, fmt, args) \ + android_vprintLog(priority, NULL, tag, fmt, args) +#endif + +/* --------------------------------------------------------------------- */ + +/* XXX Macros to work around syntax errors in places where format string + * arg is not passed to ALOG_ASSERT, LOG_ALWAYS_FATAL or LOG_ALWAYS_FATAL_IF + * (happens only in debug builds). + */ + +/* Returns 2nd arg. Used to substitute default value if caller's vararg list + * is empty. + */ +#define __android_second(dummy, second, ...) second + +/* If passed multiple args, returns ',' followed by all but 1st arg, otherwise + * returns nothing. + */ +#define __android_rest(first, ...) , ##__VA_ARGS__ + +#define android_printAssert(cond, tag, ...) \ + __android_log_assert(cond, tag, \ + __android_second(0, ##__VA_ARGS__, NULL) \ + __android_rest(__VA_ARGS__)) + +/* + * Log a fatal error. If the given condition fails, this stops program + * execution like a normal assertion, but also generating the given message. + * It is NOT stripped from release builds. Note that the condition test + * is -inverted- from the normal assert() semantics. + */ +#ifndef LOG_ALWAYS_FATAL_IF +#define LOG_ALWAYS_FATAL_IF(cond, ...) \ + ((__predict_false(cond)) ? (__FAKE_USE_VA_ARGS(__VA_ARGS__), \ + ((void)android_printAssert(#cond, LOG_TAG, ##__VA_ARGS__))) \ + : ((void)0)) +#endif + +#ifndef LOG_ALWAYS_FATAL +#define LOG_ALWAYS_FATAL(...) \ + (((void)android_printAssert(NULL, LOG_TAG, ##__VA_ARGS__))) +#endif + +/* + * Versions of LOG_ALWAYS_FATAL_IF and LOG_ALWAYS_FATAL that + * are stripped out of release builds. + */ + +#if LOG_NDEBUG + +#ifndef LOG_FATAL_IF +#define LOG_FATAL_IF(cond, ...) __FAKE_USE_VA_ARGS(__VA_ARGS__) +#endif +#ifndef LOG_FATAL +#define LOG_FATAL(...) __FAKE_USE_VA_ARGS(__VA_ARGS__) +#endif + +#else + +#ifndef LOG_FATAL_IF +#define LOG_FATAL_IF(cond, ...) LOG_ALWAYS_FATAL_IF(cond, ##__VA_ARGS__) +#endif +#ifndef LOG_FATAL +#define LOG_FATAL(...) LOG_ALWAYS_FATAL(__VA_ARGS__) +#endif + +#endif + +/* + * Assertion that generates a log message when the assertion fails. + * Stripped out of release builds. Uses the current LOG_TAG. + */ +#ifndef ALOG_ASSERT +#define ALOG_ASSERT(cond, ...) LOG_FATAL_IF(!(cond), ##__VA_ARGS__) +#endif + +/* --------------------------------------------------------------------- */ + +/* + * C/C++ logging functions. See the logging documentation for API details. + * + * We'd like these to be available from C code (in case we import some from + * somewhere), so this has a C interface. + * + * The output will be correct when the log file is shared between multiple + * threads and/or multiple processes so long as the operating system + * supports O_APPEND. These calls have mutex-protected data structures + * and so are NOT reentrant. Do not use LOG in a signal handler. + */ + +/* --------------------------------------------------------------------- */ + +/* + * Simplified macro to send a verbose log message using the current LOG_TAG. + */ +#ifndef ALOGV +#define __ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) +#if LOG_NDEBUG +#define ALOGV(...) \ + do { \ + __FAKE_USE_VA_ARGS(__VA_ARGS__); \ + if (false) { \ + __ALOGV(__VA_ARGS__); \ + } \ + } while (false) +#else +#define ALOGV(...) __ALOGV(__VA_ARGS__) +#endif +#endif + +#ifndef ALOGV_IF +#if LOG_NDEBUG +#define ALOGV_IF(cond, ...) __FAKE_USE_VA_ARGS(__VA_ARGS__) +#else +#define ALOGV_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? (__FAKE_USE_VA_ARGS(__VA_ARGS__), (void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \ + : ((void)0)) +#endif +#endif + +/* + * Simplified macro to send a debug log message using the current LOG_TAG. + */ +#ifndef ALOGD +#define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) +#endif + +#ifndef ALOGD_IF +#define ALOGD_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? (__FAKE_USE_VA_ARGS(__VA_ARGS__), (void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \ + : ((void)0)) +#endif + +/* + * Simplified macro to send an info log message using the current LOG_TAG. + */ +#ifndef ALOGI +#define ALOGI(...) ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) +#endif + +#ifndef ALOGI_IF +#define ALOGI_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? (__FAKE_USE_VA_ARGS(__VA_ARGS__), (void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) \ + : ((void)0)) +#endif + +/* + * Simplified macro to send a warning log message using the current LOG_TAG. + */ +#ifndef ALOGW +#define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) +#endif + +#ifndef ALOGW_IF +#define ALOGW_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? (__FAKE_USE_VA_ARGS(__VA_ARGS__), (void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) \ + : ((void)0)) +#endif + +/* + * Simplified macro to send an error log message using the current LOG_TAG. + */ +#ifndef ALOGE +#define ALOGE(...) ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) +#endif + +#ifndef ALOGE_IF +#define ALOGE_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? (__FAKE_USE_VA_ARGS(__VA_ARGS__), (void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) \ + : ((void)0)) +#endif + +/* --------------------------------------------------------------------- */ + +/* + * Conditional based on whether the current LOG_TAG is enabled at + * verbose priority. + */ +#ifndef IF_ALOGV +#if LOG_NDEBUG +#define IF_ALOGV() if (false) +#else +#define IF_ALOGV() IF_ALOG(LOG_VERBOSE, LOG_TAG) +#endif +#endif + +/* + * Conditional based on whether the current LOG_TAG is enabled at + * debug priority. + */ +#ifndef IF_ALOGD +#define IF_ALOGD() IF_ALOG(LOG_DEBUG, LOG_TAG) +#endif + +/* + * Conditional based on whether the current LOG_TAG is enabled at + * info priority. + */ +#ifndef IF_ALOGI +#define IF_ALOGI() IF_ALOG(LOG_INFO, LOG_TAG) +#endif + +/* + * Conditional based on whether the current LOG_TAG is enabled at + * warn priority. + */ +#ifndef IF_ALOGW +#define IF_ALOGW() IF_ALOG(LOG_WARN, LOG_TAG) +#endif + +/* + * Conditional based on whether the current LOG_TAG is enabled at + * error priority. + */ +#ifndef IF_ALOGE +#define IF_ALOGE() IF_ALOG(LOG_ERROR, LOG_TAG) +#endif + +/* --------------------------------------------------------------------- */ + +/* + * Basic log message macro. + * + * Example: + * ALOG(LOG_WARN, NULL, "Failed with error %d", errno); + * + * The second argument may be NULL or "" to indicate the "global" tag. + */ +#ifndef ALOG +#define ALOG(priority, tag, ...) LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__) +#endif + +/* + * Conditional given a desired logging priority and tag. + */ +#ifndef IF_ALOG +#define IF_ALOG(priority, tag) if (android_testLog(ANDROID_##priority, tag)) +#endif + +/* --------------------------------------------------------------------- */ + +/* + * IF_ALOG uses android_testLog, but IF_ALOG can be overridden. + * android_testLog will remain constant in its purpose as a wrapper + * for Android logging filter policy, and can be subject to + * change. It can be reused by the developers that override + * IF_ALOG as a convenient means to reimplement their policy + * over Android. + */ + +/* + * Use the per-tag properties "log.tag.<tagname>" to generate a runtime + * result of non-zero to expose a log. prio is ANDROID_LOG_VERBOSE to + * ANDROID_LOG_FATAL. default_prio if no property. Undefined behavior if + * any other value. + */ +int __android_log_is_loggable(int prio, const char* tag, int default_prio); +int __android_log_is_loggable_len(int prio, const char* tag, size_t len, int default_prio); + +#if LOG_NDEBUG /* Production */ +#define android_testLog(prio, tag) \ + (__android_log_is_loggable_len(prio, tag, ((tag) && *(tag)) ? strlen(tag) : 0, \ + ANDROID_LOG_DEBUG) != 0) +#else +#define android_testLog(prio, tag) \ + (__android_log_is_loggable_len(prio, tag, ((tag) && *(tag)) ? strlen(tag) : 0, \ + ANDROID_LOG_VERBOSE) != 0) +#endif + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +__END_DECLS diff --git a/include/android_stub/log/log_properties.h b/include/android_stub/log/log_properties.h new file mode 100644 index 00000000000..3497d63dca5 --- /dev/null +++ b/include/android_stub/log/log_properties.h @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2017 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. + */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +int __android_log_is_debuggable(); + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/log/log_radio.h b/include/android_stub/log/log_radio.h new file mode 100644 index 00000000000..f5525c134cf --- /dev/null +++ b/include/android_stub/log/log_radio.h @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2005-2017 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. + */ + +#pragma once + +#include <android/log.h> + +/* + * Normally we strip the effects of ALOGV (VERBOSE messages), + * LOG_FATAL and LOG_FATAL_IF (FATAL assert messages) from the + * release builds be defining NDEBUG. You can modify this (for + * example with "#define LOG_NDEBUG 0" at the top of your source + * file) to change that behavior. + */ + +#ifndef LOG_NDEBUG +#ifdef NDEBUG +#define LOG_NDEBUG 1 +#else +#define LOG_NDEBUG 0 +#endif +#endif + +/* --------------------------------------------------------------------- */ + +#ifndef __predict_false +#define __predict_false(exp) __builtin_expect((exp) != 0, 0) +#endif + +/* + * Simplified macro to send a verbose radio log message using current LOG_TAG. + */ +#ifndef RLOGV +#define __RLOGV(...) \ + ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_VERBOSE, LOG_TAG, \ + __VA_ARGS__)) +#if LOG_NDEBUG +#define RLOGV(...) \ + do { \ + if (0) { \ + __RLOGV(__VA_ARGS__); \ + } \ + } while (0) +#else +#define RLOGV(...) __RLOGV(__VA_ARGS__) +#endif +#endif + +#ifndef RLOGV_IF +#if LOG_NDEBUG +#define RLOGV_IF(cond, ...) ((void)0) +#else +#define RLOGV_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_VERBOSE, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif +#endif + +/* + * Simplified macro to send a debug radio log message using current LOG_TAG. + */ +#ifndef RLOGD +#define RLOGD(...) \ + ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_DEBUG, LOG_TAG, \ + __VA_ARGS__)) +#endif + +#ifndef RLOGD_IF +#define RLOGD_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_DEBUG, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif + +/* + * Simplified macro to send an info radio log message using current LOG_TAG. + */ +#ifndef RLOGI +#define RLOGI(...) \ + ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_INFO, LOG_TAG, \ + __VA_ARGS__)) +#endif + +#ifndef RLOGI_IF +#define RLOGI_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_INFO, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif + +/* + * Simplified macro to send a warning radio log message using current LOG_TAG. + */ +#ifndef RLOGW +#define RLOGW(...) \ + ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_WARN, LOG_TAG, \ + __VA_ARGS__)) +#endif + +#ifndef RLOGW_IF +#define RLOGW_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_WARN, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif + +/* + * Simplified macro to send an error radio log message using current LOG_TAG. + */ +#ifndef RLOGE +#define RLOGE(...) \ + ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_ERROR, LOG_TAG, \ + __VA_ARGS__)) +#endif + +#ifndef RLOGE_IF +#define RLOGE_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_ERROR, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif diff --git a/include/android_stub/log/log_read.h b/include/android_stub/log/log_read.h new file mode 100644 index 00000000000..23d76f48567 --- /dev/null +++ b/include/android_stub/log/log_read.h @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2005-2017 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. + */ + +#pragma once + +#include <stdint.h> +#include <sys/types.h> + +#include <android/log.h> +#include <log/log_time.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define ANDROID_LOG_WRAP_DEFAULT_TIMEOUT 7200 /* 2 hour default */ + +/* + * Native log reading interface section. See logcat for sample code. + * + * The preferred API is an exec of logcat. Likely uses of this interface + * are if native code suffers from exec or filtration being too costly, + * access to raw information, or parsing is an issue. + */ + +struct logger_entry { + uint16_t len; /* length of the payload */ + uint16_t hdr_size; /* sizeof(struct logger_entry) */ + int32_t pid; /* generating process's pid */ + uint32_t tid; /* generating process's tid */ + uint32_t sec; /* seconds since Epoch */ + uint32_t nsec; /* nanoseconds */ + uint32_t lid; /* log id of the payload, bottom 4 bits currently */ + uint32_t uid; /* generating process's uid */ +}; + +/* + * The maximum size of a log entry which can be read. + * An attempt to read less than this amount may result + * in read() returning EINVAL. + */ +#define LOGGER_ENTRY_MAX_LEN (5 * 1024) + +struct log_msg { + union { + unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1]; + struct logger_entry entry; + } __attribute__((aligned(4))); +#ifdef __cplusplus + uint64_t nsec() const { + return static_cast<uint64_t>(entry.sec) * NS_PER_SEC + entry.nsec; + } + log_id_t id() { + return static_cast<log_id_t>(entry.lid); + } + char* msg() { + unsigned short hdr_size = entry.hdr_size; + if (hdr_size >= sizeof(struct log_msg) - sizeof(entry)) { + return nullptr; + } + return reinterpret_cast<char*>(buf) + hdr_size; + } + unsigned int len() { return entry.hdr_size + entry.len; } +#endif +}; + +struct logger; + +log_id_t android_logger_get_id(struct logger* logger); + +int android_logger_clear(struct logger* logger); +long android_logger_get_log_size(struct logger* logger); +int android_logger_set_log_size(struct logger* logger, unsigned long size); +long android_logger_get_log_readable_size(struct logger* logger); +int android_logger_get_log_version(struct logger* logger); + +struct logger_list; + +ssize_t android_logger_get_statistics(struct logger_list* logger_list, + char* buf, size_t len); +ssize_t android_logger_get_prune_list(struct logger_list* logger_list, + char* buf, size_t len); +int android_logger_set_prune_list(struct logger_list* logger_list, const char* buf, size_t len); + +/* The below values are used for the `mode` argument of the below functions. */ +/* Note that 0x00000003 were previously used and should be considered reserved. */ +#define ANDROID_LOG_NONBLOCK 0x00000800 +#define ANDROID_LOG_WRAP 0x40000000 /* Block until buffer about to wrap */ +#define ANDROID_LOG_PSTORE 0x80000000 + +struct logger_list* android_logger_list_alloc(int mode, unsigned int tail, + pid_t pid); +struct logger_list* android_logger_list_alloc_time(int mode, log_time start, + pid_t pid); +void android_logger_list_free(struct logger_list* logger_list); +/* In the purest sense, the following two are orthogonal interfaces */ +int android_logger_list_read(struct logger_list* logger_list, + struct log_msg* log_msg); + +/* Multiple log_id_t opens */ +struct logger* android_logger_open(struct logger_list* logger_list, log_id_t id); +/* Single log_id_t open */ +struct logger_list* android_logger_list_open(log_id_t id, int mode, + unsigned int tail, pid_t pid); +#define android_logger_list_close android_logger_list_free + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/log/log_safetynet.h b/include/android_stub/log/log_safetynet.h new file mode 100644 index 00000000000..b2604b55449 --- /dev/null +++ b/include/android_stub/log/log_safetynet.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2017 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. + */ + +#pragma once + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define android_errorWriteLog(tag, subTag) \ + __android_log_error_write(tag, subTag, -1, NULL, 0) + +#define android_errorWriteWithInfoLog(tag, subTag, uid, data, dataLen) \ + __android_log_error_write(tag, subTag, uid, data, dataLen) + +int __android_log_error_write(int tag, const char* subTag, int32_t uid, + const char* data, uint32_t dataLen); + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/log/log_system.h b/include/android_stub/log/log_system.h new file mode 100644 index 00000000000..6f40515e823 --- /dev/null +++ b/include/android_stub/log/log_system.h @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2005-2017 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. + */ + +#pragma once + +#include <android/log.h> + +/* + * Normally we strip the effects of ALOGV (VERBOSE messages), + * LOG_FATAL and LOG_FATAL_IF (FATAL assert messages) from the + * release builds be defining NDEBUG. You can modify this (for + * example with "#define LOG_NDEBUG 0" at the top of your source + * file) to change that behavior. + */ + +#ifndef LOG_NDEBUG +#ifdef NDEBUG +#define LOG_NDEBUG 1 +#else +#define LOG_NDEBUG 0 +#endif +#endif + +#ifndef __predict_false +#define __predict_false(exp) __builtin_expect((exp) != 0, 0) +#endif + +/* + * Simplified macro to send a verbose system log message using current LOG_TAG. + */ +#ifndef SLOGV +#define __SLOGV(...) \ + ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_VERBOSE, LOG_TAG, \ + __VA_ARGS__)) +#if LOG_NDEBUG +#define SLOGV(...) \ + do { \ + if (0) { \ + __SLOGV(__VA_ARGS__); \ + } \ + } while (0) +#else +#define SLOGV(...) __SLOGV(__VA_ARGS__) +#endif +#endif + +#ifndef SLOGV_IF +#if LOG_NDEBUG +#define SLOGV_IF(cond, ...) ((void)0) +#else +#define SLOGV_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_VERBOSE, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif +#endif + +/* + * Simplified macro to send a debug system log message using current LOG_TAG. + */ +#ifndef SLOGD +#define SLOGD(...) \ + ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_DEBUG, LOG_TAG, \ + __VA_ARGS__)) +#endif + +#ifndef SLOGD_IF +#define SLOGD_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_DEBUG, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif + +/* + * Simplified macro to send an info system log message using current LOG_TAG. + */ +#ifndef SLOGI +#define SLOGI(...) \ + ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, LOG_TAG, \ + __VA_ARGS__)) +#endif + +#ifndef SLOGI_IF +#define SLOGI_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif + +/* + * Simplified macro to send a warning system log message using current LOG_TAG. + */ +#ifndef SLOGW +#define SLOGW(...) \ + ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_WARN, LOG_TAG, \ + __VA_ARGS__)) +#endif + +#ifndef SLOGW_IF +#define SLOGW_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_WARN, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif + +/* + * Simplified macro to send an error system log message using current LOG_TAG. + */ +#ifndef SLOGE +#define SLOGE(...) \ + ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_ERROR, LOG_TAG, \ + __VA_ARGS__)) +#endif + +#ifndef SLOGE_IF +#define SLOGE_IF(cond, ...) \ + ((__predict_false(cond)) \ + ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_ERROR, \ + LOG_TAG, __VA_ARGS__)) \ + : (void)0) +#endif diff --git a/include/android_stub/log/log_time.h b/include/android_stub/log/log_time.h new file mode 100644 index 00000000000..f50764de35f --- /dev/null +++ b/include/android_stub/log/log_time.h @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2005-2017 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. + */ + +#pragma once + +#include <stdint.h> +#include <time.h> + +/* struct log_time is a wire-format variant of struct timespec */ +#define NS_PER_SEC 1000000000ULL +#define US_PER_SEC 1000000ULL +#define MS_PER_SEC 1000ULL + +#define LOG_TIME_SEC(t) ((t)->tv_sec) +/* next power of two after NS_PER_SEC */ +#define LOG_TIME_NSEC(t) ((t)->tv_nsec & (UINT32_MAX >> 2)) + +#ifdef __cplusplus + +extern "C" { + +struct log_time { + public: + uint32_t tv_sec = 0; /* good to Feb 5 2106 */ + uint32_t tv_nsec = 0; + + static constexpr timespec EPOCH = {0, 0}; + + log_time() {} + explicit log_time(const timespec& T) + : tv_sec(static_cast<uint32_t>(T.tv_sec)), tv_nsec(static_cast<uint32_t>(T.tv_nsec)) {} + explicit log_time(uint32_t sec, uint32_t nsec = 0) + : tv_sec(sec), tv_nsec(nsec) { + } +#ifdef __linux__ + explicit log_time(clockid_t id) { + timespec T; + clock_gettime(id, &T); + tv_sec = static_cast<uint32_t>(T.tv_sec); + tv_nsec = static_cast<uint32_t>(T.tv_nsec); + } +#endif + /* timespec */ + bool operator==(const timespec& T) const { + return (tv_sec == static_cast<uint32_t>(T.tv_sec)) && + (tv_nsec == static_cast<uint32_t>(T.tv_nsec)); + } + bool operator!=(const timespec& T) const { + return !(*this == T); + } + bool operator<(const timespec& T) const { + return (tv_sec < static_cast<uint32_t>(T.tv_sec)) || + ((tv_sec == static_cast<uint32_t>(T.tv_sec)) && + (tv_nsec < static_cast<uint32_t>(T.tv_nsec))); + } + bool operator>=(const timespec& T) const { + return !(*this < T); + } + bool operator>(const timespec& T) const { + return (tv_sec > static_cast<uint32_t>(T.tv_sec)) || + ((tv_sec == static_cast<uint32_t>(T.tv_sec)) && + (tv_nsec > static_cast<uint32_t>(T.tv_nsec))); + } + bool operator<=(const timespec& T) const { + return !(*this > T); + } + + /* log_time */ + bool operator==(const log_time& T) const { + return (tv_sec == T.tv_sec) && (tv_nsec == T.tv_nsec); + } + bool operator!=(const log_time& T) const { + return !(*this == T); + } + bool operator<(const log_time& T) const { + return (tv_sec < T.tv_sec) || + ((tv_sec == T.tv_sec) && (tv_nsec < T.tv_nsec)); + } + bool operator>=(const log_time& T) const { + return !(*this < T); + } + bool operator>(const log_time& T) const { + return (tv_sec > T.tv_sec) || + ((tv_sec == T.tv_sec) && (tv_nsec > T.tv_nsec)); + } + bool operator<=(const log_time& T) const { + return !(*this > T); + } + + log_time operator-=(const log_time& T) { + // No concept of negative time, clamp to EPOCH + if (*this <= T) { + return *this = log_time(EPOCH); + } + + if (this->tv_nsec < T.tv_nsec) { + --this->tv_sec; + this->tv_nsec = NS_PER_SEC + this->tv_nsec - T.tv_nsec; + } else { + this->tv_nsec -= T.tv_nsec; + } + this->tv_sec -= T.tv_sec; + + return *this; + } + log_time operator-(const log_time& T) const { + log_time local(*this); + return local -= T; + } + log_time operator+=(const log_time& T) { + this->tv_nsec += T.tv_nsec; + if (this->tv_nsec >= NS_PER_SEC) { + this->tv_nsec -= NS_PER_SEC; + ++this->tv_sec; + } + this->tv_sec += T.tv_sec; + + return *this; + } + log_time operator+(const log_time& T) const { + log_time local(*this); + return local += T; + } + + uint64_t nsec() const { + return static_cast<uint64_t>(tv_sec) * NS_PER_SEC + tv_nsec; + } + uint64_t usec() const { + return static_cast<uint64_t>(tv_sec) * US_PER_SEC + + tv_nsec / (NS_PER_SEC / US_PER_SEC); + } + uint64_t msec() const { + return static_cast<uint64_t>(tv_sec) * MS_PER_SEC + + tv_nsec / (NS_PER_SEC / MS_PER_SEC); + } + + /* Add %#q for the fraction of a second to the standard library functions */ + char* strptime(const char* s, const char* format); +} __attribute__((__packed__)); +} + +#else /* __cplusplus */ + +typedef struct log_time { + uint32_t tv_sec; + uint32_t tv_nsec; +} __attribute__((__packed__)) log_time; + +#endif /* __cplusplus */ diff --git a/include/android_stub/log/logprint.h b/include/android_stub/log/logprint.h new file mode 100644 index 00000000000..7dfd914e413 --- /dev/null +++ b/include/android_stub/log/logprint.h @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2006 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. + */ + +#pragma once + +#include <stdint.h> +#include <sys/types.h> + +#include <android/log.h> +#include <log/event_tag_map.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + /* Verbs */ + FORMAT_OFF = 0, + FORMAT_BRIEF, + FORMAT_PROCESS, + FORMAT_TAG, + FORMAT_THREAD, + FORMAT_RAW, + FORMAT_TIME, + FORMAT_THREADTIME, + FORMAT_LONG, + /* Adverbs. The following are modifiers to above format verbs */ + FORMAT_MODIFIER_COLOR, /* converts priority to color */ + FORMAT_MODIFIER_TIME_USEC, /* switches from msec to usec time precision */ + FORMAT_MODIFIER_PRINTABLE, /* converts non-printable to printable escapes */ + FORMAT_MODIFIER_YEAR, /* Adds year to date */ + FORMAT_MODIFIER_ZONE, /* Adds zone to date, + UTC */ + FORMAT_MODIFIER_EPOCH, /* Print time as seconds since Jan 1 1970 */ + FORMAT_MODIFIER_MONOTONIC, /* Print cpu time as seconds since start */ + FORMAT_MODIFIER_UID, /* Adds uid */ + FORMAT_MODIFIER_DESCRIPT, /* Adds descriptive */ + /* private, undocumented */ + FORMAT_MODIFIER_TIME_NSEC, /* switches from msec to nsec time precision */ +} AndroidLogPrintFormat; + +typedef struct AndroidLogFormat_t AndroidLogFormat; + +typedef struct AndroidLogEntry_t { + time_t tv_sec; + long tv_nsec; + android_LogPriority priority; + int32_t uid; + int32_t pid; + int32_t tid; + const char* tag; + size_t tagLen; + size_t messageLen; + const char* message; +} AndroidLogEntry; + +AndroidLogFormat* android_log_format_new(); + +void android_log_format_free(AndroidLogFormat* p_format); + +/* currently returns 0 if format is a modifier, 1 if not */ +int android_log_setPrintFormat(AndroidLogFormat* p_format, + AndroidLogPrintFormat format); + +/** + * Returns FORMAT_OFF on invalid string + */ +AndroidLogPrintFormat android_log_formatFromString(const char* s); + +/** + * filterExpression: a single filter expression + * eg "AT:d" + * + * returns 0 on success and -1 on invalid expression + * + * Assumes single threaded execution + * + */ + +int android_log_addFilterRule(AndroidLogFormat* p_format, + const char* filterExpression); + +/** + * filterString: a whitespace-separated set of filter expressions + * eg "AT:d *:i" + * + * returns 0 on success and -1 on invalid expression + * + * Assumes single threaded execution + * + */ + +int android_log_addFilterString(AndroidLogFormat* p_format, + const char* filterString); + +/** + * returns 1 if this log line should be printed based on its priority + * and tag, and 0 if it should not + */ +int android_log_shouldPrintLine(AndroidLogFormat* p_format, const char* tag, + android_LogPriority pri); + +/** + * Splits a wire-format buffer into an AndroidLogEntry + * entry allocated by caller. Pointers will point directly into buf + * + * Returns 0 on success and -1 on invalid wire format (entry will be + * in unspecified state) + */ +int android_log_processLogBuffer(struct logger_entry* buf, + AndroidLogEntry* entry); + +/** + * Like android_log_processLogBuffer, but for binary logs. + * + * If "map" is non-NULL, it will be used to convert the log tag number + * into a string. + */ +int android_log_processBinaryLogBuffer(struct logger_entry* buf, + AndroidLogEntry* entry, + const EventTagMap* map, char* messageBuf, + int messageBufLen); + +/** + * Formats a log message into a buffer + * + * Uses defaultBuffer if it can, otherwise malloc()'s a new buffer + * If return value != defaultBuffer, caller must call free() + * Returns NULL on malloc error + */ + +char* android_log_formatLogLine(AndroidLogFormat* p_format, char* defaultBuffer, + size_t defaultBufferSize, + const AndroidLogEntry* p_line, + size_t* p_outLength); + +/** + * Either print or do not print log line, based on filter + * + * Assumes single threaded execution + * + */ +int android_log_printLogLine(AndroidLogFormat* p_format, int fd, + const AndroidLogEntry* entry); + +#ifdef __cplusplus +} +#endif diff --git a/include/android_stub/nativebase/nativebase.h b/include/android_stub/nativebase/nativebase.h new file mode 100644 index 00000000000..7ecdfbd7458 --- /dev/null +++ b/include/android_stub/nativebase/nativebase.h @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2017 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. + */ + +#pragma once + +#include <stdint.h> +#include <stdbool.h> +#include <string.h> +#include <sys/cdefs.h> +#include <system/graphics-base.h> +#include <cutils/native_handle.h> + +__BEGIN_DECLS + +#ifdef __cplusplus +#define ANDROID_NATIVE_UNSIGNED_CAST(x) static_cast<unsigned int>(x) +#else +#define ANDROID_NATIVE_UNSIGNED_CAST(x) ((unsigned int)(x)) +#endif + +#define ANDROID_NATIVE_MAKE_CONSTANT(a,b,c,d) \ + ((ANDROID_NATIVE_UNSIGNED_CAST(a) << 24) | \ + (ANDROID_NATIVE_UNSIGNED_CAST(b) << 16) | \ + (ANDROID_NATIVE_UNSIGNED_CAST(c) << 8) | \ + (ANDROID_NATIVE_UNSIGNED_CAST(d))) + +#define ANDROID_NATIVE_BUFFER_MAGIC ANDROID_NATIVE_MAKE_CONSTANT('_','b','f','r') + + +typedef struct android_native_base_t +{ + /* a magic value defined by the actual EGL native type */ + int magic; + + /* the sizeof() of the actual EGL native type */ + int version; + + void* reserved[4]; + + /* reference-counting interface */ + void (*incRef)(struct android_native_base_t* base); + void (*decRef)(struct android_native_base_t* base); +} android_native_base_t; + +typedef struct android_native_rect_t +{ + int32_t left; + int32_t top; + int32_t right; + int32_t bottom; +} android_native_rect_t; + +typedef struct ANativeWindowBuffer +{ +#ifdef __cplusplus + ANativeWindowBuffer() { + common.magic = ANDROID_NATIVE_BUFFER_MAGIC; + common.version = sizeof(ANativeWindowBuffer); + memset(common.reserved, 0, sizeof(common.reserved)); + } + + // Implement the methods that sp<ANativeWindowBuffer> expects so that it + // can be used to automatically refcount ANativeWindowBuffer's. + void incStrong(const void* /*id*/) const { + common.incRef(const_cast<android_native_base_t*>(&common)); + } + void decStrong(const void* /*id*/) const { + common.decRef(const_cast<android_native_base_t*>(&common)); + } +#endif + + struct android_native_base_t common; + + int width; + int height; + int stride; + int format; + int usage_deprecated; + uintptr_t layerCount; + + void* reserved[1]; + + const native_handle_t* handle; + uint64_t usage; + + // we needed extra space for storing the 64-bits usage flags + // the number of slots to use from reserved_proc depends on the + // architecture. + void* reserved_proc[8 - (sizeof(uint64_t) / sizeof(void*))]; +} ANativeWindowBuffer_t; + +typedef struct ANativeWindowBuffer ANativeWindowBuffer; + +// Old typedef for backwards compatibility. +typedef ANativeWindowBuffer_t android_native_buffer_t; + +__END_DECLS diff --git a/include/android_stub/ndk/sync.h b/include/android_stub/ndk/sync.h new file mode 100644 index 00000000000..2a59e35bbc6 --- /dev/null +++ b/include/android_stub/ndk/sync.h @@ -0,0 +1,110 @@ +/* + * Copyright 2017 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. + */ + +/** + * @addtogroup Sync + * @{ + */ + +/** + * @file sync.h + */ + +#ifndef ANDROID_SYNC_H +#define ANDROID_SYNC_H + +#include <stdint.h> +#include <sys/cdefs.h> + +#include <linux/sync_file.h> + +__BEGIN_DECLS + +#if __ANDROID_API__ >= 26 + +/* Fences indicate the status of an asynchronous task. They are initially + * in unsignaled state (0), and make a one-time transition to either signaled + * (1) or error (< 0) state. A sync file is a collection of one or more fences; + * the sync file's status is error if any of its fences are in error state, + * signaled if all of the child fences are signaled, or unsignaled otherwise. + * + * Sync files are created by various device APIs in response to submitting + * tasks to the device. Standard file descriptor lifetime syscalls like dup() + * and close() are used to manage sync file lifetime. + * + * The poll(), ppoll(), or select() syscalls can be used to wait for the sync + * file to change status, or (with a timeout of zero) to check its status. + * + * The functions below provide a few additional sync-specific operations. + */ + +/** + * Merge two sync files. + * + * This produces a new sync file with the given name which has the union of the + * two original sync file's fences; redundant fences may be removed. + * + * If one of the input sync files is signaled or invalid, then this function + * may behave like dup(): the new file descriptor refers to the valid/unsignaled + * sync file with its original name, rather than a new sync file. + * + * The original fences remain valid, and the caller is responsible for closing + * them. + * + * Available since API level 26. + */ +int32_t sync_merge(const char* name, int32_t fd1, int32_t fd2) __INTRODUCED_IN(26); + +/** + * Retrieve detailed information about a sync file and its fences. + * + * The returned sync_file_info must be freed by calling sync_file_info_free(). + * + * Available since API level 26. + */ +struct sync_file_info* sync_file_info(int32_t fd) __INTRODUCED_IN(26); + +/** + * Get the array of fence infos from the sync file's info. + * + * The returned array is owned by the parent sync file info, and has + * info->num_fences entries. + * + * Available since API level 26. + */ +static inline struct sync_fence_info* sync_get_fence_info(const struct sync_file_info* info) { +// This header should compile in C, but some C++ projects enable +// warnings-as-error for C-style casts. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" + return (struct sync_fence_info *)(uintptr_t)(info->sync_fence_info); +#pragma GCC diagnostic pop +} + +/** + * Free a struct sync_file_info structure + * + * Available since API level 26. + */ +void sync_file_info_free(struct sync_file_info* info) __INTRODUCED_IN(26); + +#endif /* __ANDROID_API__ >= 26 */ + +__END_DECLS + +#endif /* ANDROID_SYNC_H */ + +/** @} */ diff --git a/include/android_stub/sync/sync.h b/include/android_stub/sync/sync.h new file mode 120000 index 00000000000..3b17e480a56 --- /dev/null +++ b/include/android_stub/sync/sync.h @@ -0,0 +1 @@ +../android/sync.h
\ No newline at end of file diff --git a/include/android_stub/system/camera.h b/include/android_stub/system/camera.h new file mode 100644 index 00000000000..2ca90c395ba --- /dev/null +++ b/include/android_stub/system/camera.h @@ -0,0 +1,307 @@ +/* + * Copyright (C) 2011 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. + */ + +#ifndef SYSTEM_CORE_INCLUDE_ANDROID_CAMERA_H +#define SYSTEM_CORE_INCLUDE_ANDROID_CAMERA_H + +#include <stdint.h> +#include <sys/cdefs.h> +#include <sys/types.h> +#include <cutils/native_handle.h> +#include <hardware/hardware.h> +#include <hardware/gralloc.h> + +__BEGIN_DECLS + +/** + * A set of bit masks for specifying how the received preview frames are + * handled before the previewCallback() call. + * + * The least significant 3 bits of an "int" value are used for this purpose: + * + * ..... 0 0 0 + * ^ ^ ^ + * | | |---------> determine whether the callback is enabled or not + * | |-----------> determine whether the callback is one-shot or not + * |-------------> determine whether the frame is copied out or not + * + * WARNING: When a frame is sent directly without copying, it is the frame + * receiver's responsiblity to make sure that the frame data won't get + * corrupted by subsequent preview frames filled by the camera. This flag is + * recommended only when copying out data brings significant performance price + * and the handling/processing of the received frame data is always faster than + * the preview frame rate so that data corruption won't occur. + * + * For instance, + * 1. 0x00 disables the callback. In this case, copy out and one shot bits + * are ignored. + * 2. 0x01 enables a callback without copying out the received frames. A + * typical use case is the Camcorder application to avoid making costly + * frame copies. + * 3. 0x05 is enabling a callback with frame copied out repeatedly. A typical + * use case is the Camera application. + * 4. 0x07 is enabling a callback with frame copied out only once. A typical + * use case is the Barcode scanner application. + */ + +enum { + CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK = 0x01, + CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK = 0x02, + CAMERA_FRAME_CALLBACK_FLAG_COPY_OUT_MASK = 0x04, + /** Typical use cases */ + CAMERA_FRAME_CALLBACK_FLAG_NOOP = 0x00, + CAMERA_FRAME_CALLBACK_FLAG_CAMCORDER = 0x01, + CAMERA_FRAME_CALLBACK_FLAG_CAMERA = 0x05, + CAMERA_FRAME_CALLBACK_FLAG_BARCODE_SCANNER = 0x07 +}; + +/** msgType in notifyCallback and dataCallback functions */ +enum { + CAMERA_MSG_ERROR = 0x0001, // notifyCallback + CAMERA_MSG_SHUTTER = 0x0002, // notifyCallback + CAMERA_MSG_FOCUS = 0x0004, // notifyCallback + CAMERA_MSG_ZOOM = 0x0008, // notifyCallback + CAMERA_MSG_PREVIEW_FRAME = 0x0010, // dataCallback + CAMERA_MSG_VIDEO_FRAME = 0x0020, // data_timestamp_callback + CAMERA_MSG_POSTVIEW_FRAME = 0x0040, // dataCallback + CAMERA_MSG_RAW_IMAGE = 0x0080, // dataCallback + CAMERA_MSG_COMPRESSED_IMAGE = 0x0100, // dataCallback + CAMERA_MSG_RAW_IMAGE_NOTIFY = 0x0200, // dataCallback + // Preview frame metadata. This can be combined with + // CAMERA_MSG_PREVIEW_FRAME in dataCallback. For example, the apps can + // request FRAME and METADATA. Or the apps can request only FRAME or only + // METADATA. + CAMERA_MSG_PREVIEW_METADATA = 0x0400, // dataCallback + // Notify on autofocus start and stop. This is useful in continuous + // autofocus - FOCUS_MODE_CONTINUOUS_VIDEO and FOCUS_MODE_CONTINUOUS_PICTURE. + CAMERA_MSG_FOCUS_MOVE = 0x0800, // notifyCallback + CAMERA_MSG_ALL_MSGS = 0xFFFF +}; + +/** cmdType in sendCommand functions */ +enum { + CAMERA_CMD_START_SMOOTH_ZOOM = 1, + CAMERA_CMD_STOP_SMOOTH_ZOOM = 2, + + /** + * Set the clockwise rotation of preview display (setPreviewDisplay) in + * degrees. This affects the preview frames and the picture displayed after + * snapshot. This method is useful for portrait mode applications. Note + * that preview display of front-facing cameras is flipped horizontally + * before the rotation, that is, the image is reflected along the central + * vertical axis of the camera sensor. So the users can see themselves as + * looking into a mirror. + * + * This does not affect the order of byte array of + * CAMERA_MSG_PREVIEW_FRAME, CAMERA_MSG_VIDEO_FRAME, + * CAMERA_MSG_POSTVIEW_FRAME, CAMERA_MSG_RAW_IMAGE, or + * CAMERA_MSG_COMPRESSED_IMAGE. This is allowed to be set during preview + * since API level 14. + */ + CAMERA_CMD_SET_DISPLAY_ORIENTATION = 3, + + /** + * cmdType to disable/enable shutter sound. In sendCommand passing arg1 = + * 0 will disable, while passing arg1 = 1 will enable the shutter sound. + */ + CAMERA_CMD_ENABLE_SHUTTER_SOUND = 4, + + /* cmdType to play recording sound */ + CAMERA_CMD_PLAY_RECORDING_SOUND = 5, + + /** + * Start the face detection. This should be called after preview is started. + * The camera will notify the listener of CAMERA_MSG_FACE and the detected + * faces in the preview frame. The detected faces may be the same as the + * previous ones. Apps should call CAMERA_CMD_STOP_FACE_DETECTION to stop + * the face detection. This method is supported if CameraParameters + * KEY_MAX_NUM_HW_DETECTED_FACES or KEY_MAX_NUM_SW_DETECTED_FACES is + * bigger than 0. Hardware and software face detection should not be running + * at the same time. If the face detection has started, apps should not send + * this again. + * + * In hardware face detection mode, CameraParameters KEY_WHITE_BALANCE, + * KEY_FOCUS_AREAS and KEY_METERING_AREAS have no effect. + * + * arg1 is the face detection type. It can be CAMERA_FACE_DETECTION_HW or + * CAMERA_FACE_DETECTION_SW. If the type of face detection requested is not + * supported, the HAL must return BAD_VALUE. + */ + CAMERA_CMD_START_FACE_DETECTION = 6, + + /** + * Stop the face detection. + */ + CAMERA_CMD_STOP_FACE_DETECTION = 7, + + /** + * Enable/disable focus move callback (CAMERA_MSG_FOCUS_MOVE). Passing + * arg1 = 0 will disable, while passing arg1 = 1 will enable the callback. + */ + CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG = 8, + + /** + * Ping camera service to see if camera hardware is released. + * + * When any camera method returns error, the client can use ping command + * to see if the camera has been taken away by other clients. If the result + * is OK, it means the camera hardware is not released. If the result + * is not OK, the camera has been released and the existing client + * can silently finish itself or show a dialog. + */ + CAMERA_CMD_PING = 9, + + /** + * Configure the number of video buffers used for recording. The intended + * video buffer count for recording is passed as arg1, which must be + * greater than 0. This command must be sent before recording is started. + * This command returns INVALID_OPERATION error if it is sent after video + * recording is started, or the command is not supported at all. This + * command also returns a BAD_VALUE error if the intended video buffer + * count is non-positive or too big to be realized. + */ + CAMERA_CMD_SET_VIDEO_BUFFER_COUNT = 10, + + /** + * Configure an explicit format to use for video recording metadata mode. + * This can be used to switch the format from the + * default IMPLEMENTATION_DEFINED gralloc format to some other + * device-supported format, and the default dataspace from the BT_709 color + * space to some other device-supported dataspace. arg1 is the HAL pixel + * format, and arg2 is the HAL dataSpace. This command returns + * INVALID_OPERATION error if it is sent after video recording is started, + * or the command is not supported at all. + * + * If the gralloc format is set to a format other than + * IMPLEMENTATION_DEFINED, then HALv3 devices will use gralloc usage flags + * of SW_READ_OFTEN. + */ + CAMERA_CMD_SET_VIDEO_FORMAT = 11 +}; + +/** camera fatal errors */ +enum { + CAMERA_ERROR_UNKNOWN = 1, + /** + * Camera was released because another client has connected to the camera. + * The original client should call Camera::disconnect immediately after + * getting this notification. Otherwise, the camera will be released by + * camera service in a short time. The client should not call any method + * (except disconnect and sending CAMERA_CMD_PING) after getting this. + */ + CAMERA_ERROR_RELEASED = 2, + + /** + * Camera was released because device policy change or the client application + * is going to background. The client should call Camera::disconnect + * immediately after getting this notification. Otherwise, the camera will be + * released by camera service in a short time. The client should not call any + * method (except disconnect and sending CAMERA_CMD_PING) after getting this. + */ + CAMERA_ERROR_DISABLED = 3, + CAMERA_ERROR_SERVER_DIED = 100 +}; + +enum { + /** The facing of the camera is opposite to that of the screen. */ + CAMERA_FACING_BACK = 0, + /** The facing of the camera is the same as that of the screen. */ + CAMERA_FACING_FRONT = 1, + /** + * The facing of the camera is not fixed relative to the screen. + * The cameras with this facing are external cameras, e.g. USB cameras. + */ + CAMERA_FACING_EXTERNAL = 2 +}; + +enum { + /** Hardware face detection. It does not use much CPU. */ + CAMERA_FACE_DETECTION_HW = 0, + /** + * Software face detection. It uses some CPU. Applications must use + * Camera.setPreviewTexture for preview in this mode. + */ + CAMERA_FACE_DETECTION_SW = 1 +}; + +/** + * The information of a face from camera face detection. + */ +typedef struct camera_face { + /** + * Bounds of the face [left, top, right, bottom]. (-1000, -1000) represents + * the top-left of the camera field of view, and (1000, 1000) represents the + * bottom-right of the field of view. The width and height cannot be 0 or + * negative. This is supported by both hardware and software face detection. + * + * The direction is relative to the sensor orientation, that is, what the + * sensor sees. The direction is not affected by the rotation or mirroring + * of CAMERA_CMD_SET_DISPLAY_ORIENTATION. + */ + int32_t rect[4]; + + /** + * The confidence level of the face. The range is 1 to 100. 100 is the + * highest confidence. This is supported by both hardware and software + * face detection. + */ + int32_t score; + + /** + * An unique id per face while the face is visible to the tracker. If + * the face leaves the field-of-view and comes back, it will get a new + * id. If the value is 0, id is not supported. + */ + int32_t id; + + /** + * The coordinates of the center of the left eye. The range is -1000 to + * 1000. -2000, -2000 if this is not supported. + */ + int32_t left_eye[2]; + + /** + * The coordinates of the center of the right eye. The range is -1000 to + * 1000. -2000, -2000 if this is not supported. + */ + int32_t right_eye[2]; + + /** + * The coordinates of the center of the mouth. The range is -1000 to 1000. + * -2000, -2000 if this is not supported. + */ + int32_t mouth[2]; + +} camera_face_t; + +/** + * The metadata of the frame data. + */ +typedef struct camera_frame_metadata { + /** + * The number of detected faces in the frame. + */ + int32_t number_of_faces; + + /** + * An array of the detected faces. The length is number_of_faces. + */ + camera_face_t *faces; +} camera_frame_metadata_t; + +__END_DECLS + +#endif /* SYSTEM_CORE_INCLUDE_ANDROID_CAMERA_H */ diff --git a/include/android_stub/system/graphics-base-v1.0.h b/include/android_stub/system/graphics-base-v1.0.h new file mode 100644 index 00000000000..44913cc61f2 --- /dev/null +++ b/include/android_stub/system/graphics-base-v1.0.h @@ -0,0 +1,140 @@ +// This file is autogenerated by hidl-gen. Do not edit manually. +// Source: android.hardware.graphics.common@1.0 +// Location: hardware/interfaces/graphics/common/1.0/ + +#ifndef HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_0_EXPORTED_CONSTANTS_H_ +#define HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_0_EXPORTED_CONSTANTS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + HAL_PIXEL_FORMAT_RGBA_8888 = 1, + HAL_PIXEL_FORMAT_RGBX_8888 = 2, + HAL_PIXEL_FORMAT_RGB_888 = 3, + HAL_PIXEL_FORMAT_RGB_565 = 4, + HAL_PIXEL_FORMAT_BGRA_8888 = 5, + HAL_PIXEL_FORMAT_YCBCR_422_SP = 16, + HAL_PIXEL_FORMAT_YCRCB_420_SP = 17, + HAL_PIXEL_FORMAT_YCBCR_422_I = 20, + HAL_PIXEL_FORMAT_RGBA_FP16 = 22, + HAL_PIXEL_FORMAT_RAW16 = 32, + HAL_PIXEL_FORMAT_BLOB = 33, + HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED = 34, + HAL_PIXEL_FORMAT_YCBCR_420_888 = 35, + HAL_PIXEL_FORMAT_RAW_OPAQUE = 36, + HAL_PIXEL_FORMAT_RAW10 = 37, + HAL_PIXEL_FORMAT_RAW12 = 38, + HAL_PIXEL_FORMAT_RGBA_1010102 = 43, + HAL_PIXEL_FORMAT_Y8 = 538982489, + HAL_PIXEL_FORMAT_Y16 = 540422489, + HAL_PIXEL_FORMAT_YV12 = 842094169, +} android_pixel_format_t; + +typedef enum { + HAL_TRANSFORM_FLIP_H = 1, // (1 << 0) + HAL_TRANSFORM_FLIP_V = 2, // (1 << 1) + HAL_TRANSFORM_ROT_90 = 4, // (1 << 2) + HAL_TRANSFORM_ROT_180 = 3, // (FLIP_H | FLIP_V) + HAL_TRANSFORM_ROT_270 = 7, // ((FLIP_H | FLIP_V) | ROT_90) +} android_transform_t; + +typedef enum { + HAL_DATASPACE_UNKNOWN = 0, + HAL_DATASPACE_ARBITRARY = 1, + HAL_DATASPACE_STANDARD_SHIFT = 16, + HAL_DATASPACE_STANDARD_MASK = 4128768, // (63 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_UNSPECIFIED = 0, // (0 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_BT709 = 65536, // (1 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_BT601_625 = 131072, // (2 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED = 196608, // (3 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_BT601_525 = 262144, // (4 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED = 327680, // (5 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_BT2020 = 393216, // (6 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE = 458752, // (7 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_BT470M = 524288, // (8 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_FILM = 589824, // (9 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_DCI_P3 = 655360, // (10 << STANDARD_SHIFT) + HAL_DATASPACE_STANDARD_ADOBE_RGB = 720896, // (11 << STANDARD_SHIFT) + HAL_DATASPACE_TRANSFER_SHIFT = 22, + HAL_DATASPACE_TRANSFER_MASK = 130023424, // (31 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_UNSPECIFIED = 0, // (0 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_LINEAR = 4194304, // (1 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_SRGB = 8388608, // (2 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_SMPTE_170M = 12582912, // (3 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_GAMMA2_2 = 16777216, // (4 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_GAMMA2_6 = 20971520, // (5 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_GAMMA2_8 = 25165824, // (6 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_ST2084 = 29360128, // (7 << TRANSFER_SHIFT) + HAL_DATASPACE_TRANSFER_HLG = 33554432, // (8 << TRANSFER_SHIFT) + HAL_DATASPACE_RANGE_SHIFT = 27, + HAL_DATASPACE_RANGE_MASK = 939524096, // (7 << RANGE_SHIFT) + HAL_DATASPACE_RANGE_UNSPECIFIED = 0, // (0 << RANGE_SHIFT) + HAL_DATASPACE_RANGE_FULL = 134217728, // (1 << RANGE_SHIFT) + HAL_DATASPACE_RANGE_LIMITED = 268435456, // (2 << RANGE_SHIFT) + HAL_DATASPACE_RANGE_EXTENDED = 402653184, // (3 << RANGE_SHIFT) + HAL_DATASPACE_SRGB_LINEAR = 512, + HAL_DATASPACE_V0_SRGB_LINEAR = 138477568, // ((STANDARD_BT709 | TRANSFER_LINEAR) | RANGE_FULL) + HAL_DATASPACE_V0_SCRGB_LINEAR = + 406913024, // ((STANDARD_BT709 | TRANSFER_LINEAR) | RANGE_EXTENDED) + HAL_DATASPACE_SRGB = 513, + HAL_DATASPACE_V0_SRGB = 142671872, // ((STANDARD_BT709 | TRANSFER_SRGB) | RANGE_FULL) + HAL_DATASPACE_V0_SCRGB = 411107328, // ((STANDARD_BT709 | TRANSFER_SRGB) | RANGE_EXTENDED) + HAL_DATASPACE_JFIF = 257, + HAL_DATASPACE_V0_JFIF = 146931712, // ((STANDARD_BT601_625 | TRANSFER_SMPTE_170M) | RANGE_FULL) + HAL_DATASPACE_BT601_625 = 258, + HAL_DATASPACE_V0_BT601_625 = + 281149440, // ((STANDARD_BT601_625 | TRANSFER_SMPTE_170M) | RANGE_LIMITED) + HAL_DATASPACE_BT601_525 = 259, + HAL_DATASPACE_V0_BT601_525 = + 281280512, // ((STANDARD_BT601_525 | TRANSFER_SMPTE_170M) | RANGE_LIMITED) + HAL_DATASPACE_BT709 = 260, + HAL_DATASPACE_V0_BT709 = 281083904, // ((STANDARD_BT709 | TRANSFER_SMPTE_170M) | RANGE_LIMITED) + HAL_DATASPACE_DCI_P3_LINEAR = 139067392, // ((STANDARD_DCI_P3 | TRANSFER_LINEAR) | RANGE_FULL) + HAL_DATASPACE_DCI_P3 = 155844608, // ((STANDARD_DCI_P3 | TRANSFER_GAMMA2_6) | RANGE_FULL) + HAL_DATASPACE_DISPLAY_P3_LINEAR = + 139067392, // ((STANDARD_DCI_P3 | TRANSFER_LINEAR) | RANGE_FULL) + HAL_DATASPACE_DISPLAY_P3 = 143261696, // ((STANDARD_DCI_P3 | TRANSFER_SRGB) | RANGE_FULL) + HAL_DATASPACE_ADOBE_RGB = 151715840, // ((STANDARD_ADOBE_RGB | TRANSFER_GAMMA2_2) | RANGE_FULL) + HAL_DATASPACE_BT2020_LINEAR = 138805248, // ((STANDARD_BT2020 | TRANSFER_LINEAR) | RANGE_FULL) + HAL_DATASPACE_BT2020 = 147193856, // ((STANDARD_BT2020 | TRANSFER_SMPTE_170M) | RANGE_FULL) + HAL_DATASPACE_BT2020_PQ = 163971072, // ((STANDARD_BT2020 | TRANSFER_ST2084) | RANGE_FULL) + HAL_DATASPACE_DEPTH = 4096, + HAL_DATASPACE_SENSOR = 4097, +} android_dataspace_t; + +typedef enum { + HAL_COLOR_MODE_NATIVE = 0, + HAL_COLOR_MODE_STANDARD_BT601_625 = 1, + HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED = 2, + HAL_COLOR_MODE_STANDARD_BT601_525 = 3, + HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED = 4, + HAL_COLOR_MODE_STANDARD_BT709 = 5, + HAL_COLOR_MODE_DCI_P3 = 6, + HAL_COLOR_MODE_SRGB = 7, + HAL_COLOR_MODE_ADOBE_RGB = 8, + HAL_COLOR_MODE_DISPLAY_P3 = 9, +} android_color_mode_t; + +typedef enum { + HAL_COLOR_TRANSFORM_IDENTITY = 0, + HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX = 1, + HAL_COLOR_TRANSFORM_VALUE_INVERSE = 2, + HAL_COLOR_TRANSFORM_GRAYSCALE = 3, + HAL_COLOR_TRANSFORM_CORRECT_PROTANOPIA = 4, + HAL_COLOR_TRANSFORM_CORRECT_DEUTERANOPIA = 5, + HAL_COLOR_TRANSFORM_CORRECT_TRITANOPIA = 6, +} android_color_transform_t; + +typedef enum { + HAL_HDR_DOLBY_VISION = 1, + HAL_HDR_HDR10 = 2, + HAL_HDR_HLG = 3, +} android_hdr_t; + +#ifdef __cplusplus +} +#endif + +#endif // HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_0_EXPORTED_CONSTANTS_H_ diff --git a/include/android_stub/system/graphics-base-v1.1.h b/include/android_stub/system/graphics-base-v1.1.h new file mode 100644 index 00000000000..f95b9ba213f --- /dev/null +++ b/include/android_stub/system/graphics-base-v1.1.h @@ -0,0 +1,48 @@ +// This file is autogenerated by hidl-gen. Do not edit manually. +// Source: android.hardware.graphics.common@1.1 +// Location: hardware/interfaces/graphics/common/1.1/ + +#ifndef HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_1_EXPORTED_CONSTANTS_H_ +#define HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_1_EXPORTED_CONSTANTS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + HAL_PIXEL_FORMAT_DEPTH_16 = 48, + HAL_PIXEL_FORMAT_DEPTH_24 = 49, + HAL_PIXEL_FORMAT_DEPTH_24_STENCIL_8 = 50, + HAL_PIXEL_FORMAT_DEPTH_32F = 51, + HAL_PIXEL_FORMAT_DEPTH_32F_STENCIL_8 = 52, + HAL_PIXEL_FORMAT_STENCIL_8 = 53, + HAL_PIXEL_FORMAT_YCBCR_P010 = 54, +} android_pixel_format_v1_1_t; + +typedef enum { + HAL_DATASPACE_BT2020_ITU = + 281411584, // ((STANDARD_BT2020 | TRANSFER_SMPTE_170M) | RANGE_LIMITED) + HAL_DATASPACE_BT2020_ITU_PQ = + 298188800, // ((STANDARD_BT2020 | TRANSFER_ST2084) | RANGE_LIMITED) + HAL_DATASPACE_BT2020_ITU_HLG = 302383104, // ((STANDARD_BT2020 | TRANSFER_HLG) | RANGE_LIMITED) + HAL_DATASPACE_BT2020_HLG = 168165376, // ((STANDARD_BT2020 | TRANSFER_HLG) | RANGE_FULL) +} android_dataspace_v1_1_t; + +typedef enum { + HAL_COLOR_MODE_BT2020 = 10, + HAL_COLOR_MODE_BT2100_PQ = 11, + HAL_COLOR_MODE_BT2100_HLG = 12, +} android_color_mode_v1_1_t; + +typedef enum { + HAL_RENDER_INTENT_COLORIMETRIC = 0, + HAL_RENDER_INTENT_ENHANCE = 1, + HAL_RENDER_INTENT_TONE_MAP_COLORIMETRIC = 2, + HAL_RENDER_INTENT_TONE_MAP_ENHANCE = 3, +} android_render_intent_v1_1_t; + +#ifdef __cplusplus +} +#endif + +#endif // HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_1_EXPORTED_CONSTANTS_H_ diff --git a/include/android_stub/system/graphics-base-v1.2.h b/include/android_stub/system/graphics-base-v1.2.h new file mode 100644 index 00000000000..2194f5ea864 --- /dev/null +++ b/include/android_stub/system/graphics-base-v1.2.h @@ -0,0 +1,31 @@ +// This file is autogenerated by hidl-gen. Do not edit manually. +// Source: android.hardware.graphics.common@1.2 +// Location: hardware/interfaces/graphics/common/1.2/ + +#ifndef HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_ +#define HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + HAL_HDR_HDR10_PLUS = 4, +} android_hdr_v1_2_t; + +typedef enum { + HAL_DATASPACE_DISPLAY_BT2020 = 142999552 /* ((STANDARD_BT2020 | TRANSFER_SRGB) | RANGE_FULL) */, + HAL_DATASPACE_DYNAMIC_DEPTH = 4098 /* 0x1002 */, + HAL_DATASPACE_JPEG_APP_SEGMENTS = 4099 /* 0x1003 */, + HAL_DATASPACE_HEIF = 4100 /* 0x1004 */, +} android_dataspace_v1_2_t; + +typedef enum { + HAL_PIXEL_FORMAT_HSV_888 = 55 /* 0x37 */, +} android_pixel_format_v1_2_t; + +#ifdef __cplusplus +} +#endif + +#endif // HIDL_GENERATED_ANDROID_HARDWARE_GRAPHICS_COMMON_V1_2_EXPORTED_CONSTANTS_H_ diff --git a/include/android_stub/system/graphics-base.h b/include/android_stub/system/graphics-base.h new file mode 100644 index 00000000000..92ee077a65e --- /dev/null +++ b/include/android_stub/system/graphics-base.h @@ -0,0 +1,8 @@ +#ifndef SYSTEM_CORE_GRAPHICS_BASE_H_ +#define SYSTEM_CORE_GRAPHICS_BASE_H_ + +#include "graphics-base-v1.0.h" +#include "graphics-base-v1.1.h" +#include "graphics-base-v1.2.h" + +#endif // SYSTEM_CORE_GRAPHICS_BASE_H_ diff --git a/include/android_stub/system/graphics-sw.h b/include/android_stub/system/graphics-sw.h new file mode 100644 index 00000000000..9e1a88e9e39 --- /dev/null +++ b/include/android_stub/system/graphics-sw.h @@ -0,0 +1,16 @@ +#ifndef SYSTEM_CORE_GRAPHICS_SW_H_ +#define SYSTEM_CORE_GRAPHICS_SW_H_ + +/* Software formats not in the HAL definitions. */ +typedef enum { + HAL_PIXEL_FORMAT_YCBCR_422_888 = 39, // 0x27 + HAL_PIXEL_FORMAT_YCBCR_444_888 = 40, // 0x28 + HAL_PIXEL_FORMAT_FLEX_RGB_888 = 41, // 0x29 + HAL_PIXEL_FORMAT_FLEX_RGBA_8888 = 42, // 0x2A +} android_pixel_format_sw_t; + +/* for compatibility */ +#define HAL_PIXEL_FORMAT_YCbCr_422_888 HAL_PIXEL_FORMAT_YCBCR_422_888 +#define HAL_PIXEL_FORMAT_YCbCr_444_888 HAL_PIXEL_FORMAT_YCBCR_444_888 + +#endif // SYSTEM_CORE_GRAPHICS_SW_H_ diff --git a/include/android_stub/system/graphics.h b/include/android_stub/system/graphics.h new file mode 100644 index 00000000000..1b6060a4edc --- /dev/null +++ b/include/android_stub/system/graphics.h @@ -0,0 +1,268 @@ +/* + * Copyright (C) 2011 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. + */ + +#ifndef SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H +#define SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H + +#include <stddef.h> +#include <stdint.h> + +/* + * Some of the enums are now defined in HIDL in hardware/interfaces and are + * generated. + */ +#include "graphics-base.h" +#include "graphics-sw.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* for compatibility */ +#define HAL_PIXEL_FORMAT_YCbCr_420_888 HAL_PIXEL_FORMAT_YCBCR_420_888 +#define HAL_PIXEL_FORMAT_YCbCr_422_SP HAL_PIXEL_FORMAT_YCBCR_422_SP +#define HAL_PIXEL_FORMAT_YCrCb_420_SP HAL_PIXEL_FORMAT_YCRCB_420_SP +#define HAL_PIXEL_FORMAT_YCbCr_422_I HAL_PIXEL_FORMAT_YCBCR_422_I +typedef android_pixel_format_t android_pixel_format; +typedef android_transform_t android_transform; +typedef android_dataspace_t android_dataspace; +typedef android_color_mode_t android_color_mode; +typedef android_color_transform_t android_color_transform; +typedef android_hdr_t android_hdr; + +/* + * If the HAL needs to create service threads to handle graphics related + * tasks, these threads need to run at HAL_PRIORITY_URGENT_DISPLAY priority + * if they can block the main rendering thread in any way. + * + * the priority of the current thread can be set with: + * + * #include <sys/resource.h> + * setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY); + * + */ + +#define HAL_PRIORITY_URGENT_DISPLAY (-8) + +/* + * Structure for describing YCbCr formats for consumption by applications. + * This is used with HAL_PIXEL_FORMAT_YCbCr_*_888. + * + * Buffer chroma subsampling is defined in the format. + * e.g. HAL_PIXEL_FORMAT_YCbCr_420_888 has subsampling 4:2:0. + * + * Buffers must have a 8 bit depth. + * + * y, cb, and cr point to the first byte of their respective planes. + * + * Stride describes the distance in bytes from the first value of one row of + * the image to the first value of the next row. It includes the width of the + * image plus padding. + * ystride is the stride of the luma plane. + * cstride is the stride of the chroma planes. + * + * chroma_step is the distance in bytes from one chroma pixel value to the + * next. This is 2 bytes for semiplanar (because chroma values are interleaved + * and each chroma value is one byte) and 1 for planar. + */ + +struct android_ycbcr { + void *y; + void *cb; + void *cr; + size_t ystride; + size_t cstride; + size_t chroma_step; + + /** reserved for future use, set to 0 by gralloc's (*lock_ycbcr)() */ + uint32_t reserved[8]; +}; + +/* + * Structures for describing flexible YUVA/RGBA formats for consumption by + * applications. Such flexible formats contain a plane for each component (e.g. + * red, green, blue), where each plane is laid out in a grid-like pattern + * occupying unique byte addresses and with consistent byte offsets between + * neighboring pixels. + * + * The android_flex_layout structure is used with any pixel format that can be + * represented by it, such as: + * - HAL_PIXEL_FORMAT_YCbCr_*_888 + * - HAL_PIXEL_FORMAT_FLEX_RGB*_888 + * - HAL_PIXEL_FORMAT_RGB[AX]_888[8],BGRA_8888,RGB_888 + * - HAL_PIXEL_FORMAT_YV12,Y8,Y16,YCbCr_422_SP/I,YCrCb_420_SP + * - even implementation defined formats that can be represented by + * the structures + * + * Vertical increment (aka. row increment or stride) describes the distance in + * bytes from the first pixel of one row to the first pixel of the next row + * (below) for the component plane. This can be negative. + * + * Horizontal increment (aka. column or pixel increment) describes the distance + * in bytes from one pixel to the next pixel (to the right) on the same row for + * the component plane. This can be negative. + * + * Each plane can be subsampled either vertically or horizontally by + * a power-of-two factor. + * + * The bit-depth of each component can be arbitrary, as long as the pixels are + * laid out on whole bytes, in native byte-order, using the most significant + * bits of each unit. + */ + +typedef enum android_flex_component { + /* luma */ + FLEX_COMPONENT_Y = 1 << 0, + /* chroma blue */ + FLEX_COMPONENT_Cb = 1 << 1, + /* chroma red */ + FLEX_COMPONENT_Cr = 1 << 2, + + /* red */ + FLEX_COMPONENT_R = 1 << 10, + /* green */ + FLEX_COMPONENT_G = 1 << 11, + /* blue */ + FLEX_COMPONENT_B = 1 << 12, + + /* alpha */ + FLEX_COMPONENT_A = 1 << 30, +} android_flex_component_t; + +typedef struct android_flex_plane { + /* pointer to the first byte of the top-left pixel of the plane. */ + uint8_t *top_left; + + android_flex_component_t component; + + /* bits allocated for the component in each pixel. Must be a positive + multiple of 8. */ + int32_t bits_per_component; + /* number of the most significant bits used in the format for this + component. Must be between 1 and bits_per_component, inclusive. */ + int32_t bits_used; + + /* horizontal increment */ + int32_t h_increment; + /* vertical increment */ + int32_t v_increment; + /* horizontal subsampling. Must be a positive power of 2. */ + int32_t h_subsampling; + /* vertical subsampling. Must be a positive power of 2. */ + int32_t v_subsampling; +} android_flex_plane_t; + +typedef enum android_flex_format { + /* not a flexible format */ + FLEX_FORMAT_INVALID = 0x0, + FLEX_FORMAT_Y = FLEX_COMPONENT_Y, + FLEX_FORMAT_YCbCr = FLEX_COMPONENT_Y | FLEX_COMPONENT_Cb | FLEX_COMPONENT_Cr, + FLEX_FORMAT_YCbCrA = FLEX_FORMAT_YCbCr | FLEX_COMPONENT_A, + FLEX_FORMAT_RGB = FLEX_COMPONENT_R | FLEX_COMPONENT_G | FLEX_COMPONENT_B, + FLEX_FORMAT_RGBA = FLEX_FORMAT_RGB | FLEX_COMPONENT_A, +} android_flex_format_t; + +typedef struct android_flex_layout { + /* the kind of flexible format */ + android_flex_format_t format; + + /* number of planes; 0 for FLEX_FORMAT_INVALID */ + uint32_t num_planes; + /* a plane for each component; ordered in increasing component value order. + E.g. FLEX_FORMAT_RGBA maps 0 -> R, 1 -> G, etc. + Can be NULL for FLEX_FORMAT_INVALID */ + android_flex_plane_t *planes; +} android_flex_layout_t; + +/** + * Structure used to define depth point clouds for format HAL_PIXEL_FORMAT_BLOB + * with dataSpace value of HAL_DATASPACE_DEPTH. + * When locking a native buffer of the above format and dataSpace value, + * the vaddr pointer can be cast to this structure. + * + * A variable-length list of (x,y,z, confidence) 3D points, as floats. (x, y, + * z) represents a measured point's position, with the coordinate system defined + * by the data source. Confidence represents the estimated likelihood that this + * measurement is correct. It is between 0.f and 1.f, inclusive, with 1.f == + * 100% confidence. + * + * num_points is the number of points in the list + * + * xyz_points is the flexible array of floating-point values. + * It contains (num_points) * 4 floats. + * + * For example: + * android_depth_points d = get_depth_buffer(); + * struct { + * float x; float y; float z; float confidence; + * } firstPoint, lastPoint; + * + * firstPoint.x = d.xyzc_points[0]; + * firstPoint.y = d.xyzc_points[1]; + * firstPoint.z = d.xyzc_points[2]; + * firstPoint.confidence = d.xyzc_points[3]; + * lastPoint.x = d.xyzc_points[(d.num_points - 1) * 4 + 0]; + * lastPoint.y = d.xyzc_points[(d.num_points - 1) * 4 + 1]; + * lastPoint.z = d.xyzc_points[(d.num_points - 1) * 4 + 2]; + * lastPoint.confidence = d.xyzc_points[(d.num_points - 1) * 4 + 3]; + */ + +struct android_depth_points { + uint32_t num_points; + + /** reserved for future use, set to 0 by gralloc's (*lock)() */ + uint32_t reserved[8]; + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wc99-extensions" +#endif + float xyzc_points[]; +#if defined(__clang__) +#pragma clang diagnostic pop +#endif +}; + +/** + * These structures are used to define the reference display's + * capabilities for HDR content. Display engine can use this + * to better tone map content to user's display. + * Color is defined in CIE XYZ coordinates + */ +struct android_xy_color { + float x; + float y; +}; + +struct android_smpte2086_metadata { + struct android_xy_color displayPrimaryRed; + struct android_xy_color displayPrimaryGreen; + struct android_xy_color displayPrimaryBlue; + struct android_xy_color whitePoint; + float maxLuminance; + float minLuminance; +}; + +struct android_cta861_3_metadata { + float maxContentLightLevel; + float maxFrameAverageLightLevel; +}; + +#ifdef __cplusplus +} +#endif + +#endif /* SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H */ diff --git a/include/android_stub/system/radio.h b/include/android_stub/system/radio.h new file mode 100644 index 00000000000..acf3ea787ae --- /dev/null +++ b/include/android_stub/system/radio.h @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2015 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. + */ + +#ifndef ANDROID_RADIO_H +#define ANDROID_RADIO_H + +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <sys/cdefs.h> +#include <sys/types.h> + + +#define RADIO_NUM_BANDS_MAX 16 +#define RADIO_NUM_SPACINGS_MAX 16 +#define RADIO_STRING_LEN_MAX 128 + +/* + * Radio hardware module class. A given radio hardware module HAL is of one class + * only. The platform can not have more than one hardware module of each class. + * Current version of the framework only supports RADIO_CLASS_AM_FM. + */ +typedef enum { + RADIO_CLASS_AM_FM = 0, /* FM (including HD radio) and AM */ + RADIO_CLASS_SAT = 1, /* Satellite Radio */ + RADIO_CLASS_DT = 2, /* Digital Radio (DAB) */ +} radio_class_t; + +/* value for field "type" of radio band described in struct radio_hal_band_config */ +typedef enum { + RADIO_BAND_AM = 0, /* Amplitude Modulation band: LW, MW, SW */ + RADIO_BAND_FM = 1, /* Frequency Modulation band: FM */ + RADIO_BAND_FM_HD = 2, /* FM HD Radio / DRM (IBOC) */ + RADIO_BAND_AM_HD = 3, /* AM HD Radio / DRM (IBOC) */ +} radio_band_t; + +/* RDS variant implemented. A struct radio_hal_fm_band_config can list none or several. */ +enum { + RADIO_RDS_NONE = 0x0, + RADIO_RDS_WORLD = 0x01, + RADIO_RDS_US = 0x02, +}; +typedef unsigned int radio_rds_t; + +/* FM deemphasis variant implemented. A struct radio_hal_fm_band_config can list one or more. */ +enum { + RADIO_DEEMPHASIS_50 = 0x1, + RADIO_DEEMPHASIS_75 = 0x2, +}; +typedef unsigned int radio_deemphasis_t; + +/* Region a particular radio band configuration corresponds to. Not used at the HAL. + * Derived by the framework when converting the band descriptors retrieved from the HAL to + * individual band descriptors for each supported region. */ +typedef enum { + RADIO_REGION_NONE = -1, + RADIO_REGION_ITU_1 = 0, + RADIO_REGION_ITU_2 = 1, + RADIO_REGION_OIRT = 2, + RADIO_REGION_JAPAN = 3, + RADIO_REGION_KOREA = 4, +} radio_region_t; + +/* scanning direction for scan() and step() tuner APIs */ +typedef enum { + RADIO_DIRECTION_UP, + RADIO_DIRECTION_DOWN +} radio_direction_t; + +/* unique handle allocated to a radio module */ +typedef uint32_t radio_handle_t; + +/* Opaque meta data structure used by radio meta data API (see system/radio_metadata.h) */ +typedef struct radio_metadata radio_metadata_t; + + +/* Additional attributes for an FM band configuration */ +typedef struct radio_hal_fm_band_config { + radio_deemphasis_t deemphasis; /* deemphasis variant */ + bool stereo; /* stereo supported */ + radio_rds_t rds; /* RDS variants supported */ + bool ta; /* Traffic Announcement supported */ + bool af; /* Alternate Frequency supported */ + bool ea; /* Emergency announcements supported */ +} radio_hal_fm_band_config_t; + +/* Additional attributes for an AM band configuration */ +typedef struct radio_hal_am_band_config { + bool stereo; /* stereo supported */ +} radio_hal_am_band_config_t; + +/* Radio band configuration. Describes a given band supported by the radio module. + * The HAL can expose only one band per type with the the maximum range supported and all options. + * THe framework will derive the actual regions were this module can operate and expose separate + * band configurations for applications to chose from. */ +typedef struct radio_hal_band_config { + radio_band_t type; + bool antenna_connected; + uint32_t lower_limit; + uint32_t upper_limit; + uint32_t num_spacings; + uint32_t spacings[RADIO_NUM_SPACINGS_MAX]; + union { + radio_hal_fm_band_config_t fm; + radio_hal_am_band_config_t am; + }; +} radio_hal_band_config_t; + +/* Used internally by the framework to represent a band for s specific region */ +typedef struct radio_band_config { + radio_region_t region; + radio_hal_band_config_t band; +} radio_band_config_t; + + +/* Exposes properties of a given hardware radio module. + * NOTE: current framework implementation supports only one audio source (num_audio_sources = 1). + * The source corresponds to AUDIO_DEVICE_IN_FM_TUNER. + * If more than one tuner is supported (num_tuners > 1), only one can be connected to the audio + * source. */ +typedef struct radio_hal_properties { + radio_class_t class_id; /* Class of this module. E.g RADIO_CLASS_AM_FM */ + char implementor[RADIO_STRING_LEN_MAX]; /* implementor name */ + char product[RADIO_STRING_LEN_MAX]; /* product name */ + char version[RADIO_STRING_LEN_MAX]; /* product version */ + char serial[RADIO_STRING_LEN_MAX]; /* serial number (for subscription services) */ + uint32_t num_tuners; /* number of tuners controllable independently */ + uint32_t num_audio_sources; /* number of audio sources driven simultaneously */ + bool supports_capture; /* the hardware supports capture of audio source audio HAL */ + uint32_t num_bands; /* number of band descriptors */ + radio_hal_band_config_t bands[RADIO_NUM_BANDS_MAX]; /* band descriptors */ +} radio_hal_properties_t; + +/* Used internally by the framework. Same information as in struct radio_hal_properties plus a + * unique handle and one band configuration per region. */ +typedef struct radio_properties { + radio_handle_t handle; + radio_class_t class_id; + char implementor[RADIO_STRING_LEN_MAX]; + char product[RADIO_STRING_LEN_MAX]; + char version[RADIO_STRING_LEN_MAX]; + char serial[RADIO_STRING_LEN_MAX]; + uint32_t num_tuners; + uint32_t num_audio_sources; + bool supports_capture; + uint32_t num_bands; + radio_band_config_t bands[RADIO_NUM_BANDS_MAX]; +} radio_properties_t; + +/* Radio program information. Returned by the HAL with event RADIO_EVENT_TUNED. + * Contains information on currently tuned channel. + */ +typedef struct radio_program_info { + uint32_t channel; /* current channel. (e.g kHz for band type RADIO_BAND_FM) */ + uint32_t sub_channel; /* current sub channel. (used for RADIO_BAND_FM_HD) */ + bool tuned; /* tuned to a program or not */ + bool stereo; /* program is stereo or not */ + bool digital; /* digital program or not (e.g HD Radio program) */ + uint32_t signal_strength; /* signal strength from 0 to 100 */ + /* meta data (e.g PTY, song title ...), must not be NULL */ + __attribute__((aligned(8))) radio_metadata_t *metadata; +} radio_program_info_t; + + +/* Events sent to the framework via the HAL callback. An event can notify the completion of an + * asynchronous command (configuration, tune, scan ...) or a spontaneous change (antenna connection, + * failure, AF switching, meta data reception... */ +enum { + RADIO_EVENT_HW_FAILURE = 0, /* hardware module failure. Requires reopening the tuner */ + RADIO_EVENT_CONFIG = 1, /* configuration change completed */ + RADIO_EVENT_ANTENNA = 2, /* Antenna connected, disconnected */ + RADIO_EVENT_TUNED = 3, /* tune, step, scan completed */ + RADIO_EVENT_METADATA = 4, /* New meta data received */ + RADIO_EVENT_TA = 5, /* Traffic announcement start or stop */ + RADIO_EVENT_AF_SWITCH = 6, /* Switch to Alternate Frequency */ + RADIO_EVENT_EA = 7, /* Emergency announcement start or stop */ + // begin framework only events + RADIO_EVENT_CONTROL = 100, /* loss/gain of tuner control */ + RADIO_EVENT_SERVER_DIED = 101, /* radio service died */ +}; +typedef unsigned int radio_event_type_t; + +/* Event passed to the framework by the HAL callback */ +typedef struct radio_hal_event { + radio_event_type_t type; /* event type */ + int32_t status; /* used by RADIO_EVENT_CONFIG, RADIO_EVENT_TUNED */ + union { + /* RADIO_EVENT_ANTENNA, RADIO_EVENT_TA, RADIO_EVENT_EA */ + bool on; + radio_hal_band_config_t config; /* RADIO_EVENT_CONFIG */ + radio_program_info_t info; /* RADIO_EVENT_TUNED, RADIO_EVENT_AF_SWITCH */ + radio_metadata_t *metadata; /* RADIO_EVENT_METADATA */ + }; +} radio_hal_event_t; + +/* Used internally by the framework. Same information as in struct radio_hal_event */ +typedef struct radio_event { + radio_event_type_t type; + int32_t status; + union { + bool on; + radio_band_config_t config; + radio_program_info_t info; + /* meta data (e.g PTY, song title ...), must not be NULL */ + __attribute__((aligned(8))) radio_metadata_t *metadata; + }; +} radio_event_t; + + +static inline +radio_rds_t radio_rds_for_region(bool rds, radio_region_t region) { + if (!rds) + return RADIO_RDS_NONE; + switch(region) { + case RADIO_REGION_ITU_1: + case RADIO_REGION_OIRT: + case RADIO_REGION_JAPAN: + case RADIO_REGION_KOREA: + return RADIO_RDS_WORLD; + case RADIO_REGION_ITU_2: + return RADIO_RDS_US; + default: + return RADIO_REGION_NONE; + } +} + +static inline +radio_deemphasis_t radio_demephasis_for_region(radio_region_t region) { + switch(region) { + case RADIO_REGION_KOREA: + case RADIO_REGION_ITU_2: + return RADIO_DEEMPHASIS_75; + case RADIO_REGION_ITU_1: + case RADIO_REGION_OIRT: + case RADIO_REGION_JAPAN: + default: + return RADIO_DEEMPHASIS_50; + } +} + +#endif // ANDROID_RADIO_H diff --git a/include/android_stub/system/thread_defs.h b/include/android_stub/system/thread_defs.h new file mode 100644 index 00000000000..80d11608b37 --- /dev/null +++ b/include/android_stub/system/thread_defs.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2013 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. + */ + +#ifndef ANDROID_THREAD_DEFS_H +#define ANDROID_THREAD_DEFS_H + +#include "graphics.h" + +#if defined(__cplusplus) +extern "C" { +#endif + +enum { + /* + * *********************************************** + * ** Keep in sync with android.os.Process.java ** + * *********************************************** + * + * This maps directly to the "nice" priorities we use in Android. + * A thread priority should be chosen inverse-proportionally to + * the amount of work the thread is expected to do. The more work + * a thread will do, the less favorable priority it should get so that + * it doesn't starve the system. Threads not behaving properly might + * be "punished" by the kernel. + * Use the levels below when appropriate. Intermediate values are + * acceptable, preferably use the {MORE|LESS}_FAVORABLE constants below. + */ + ANDROID_PRIORITY_LOWEST = 19, + + /* use for background tasks */ + ANDROID_PRIORITY_BACKGROUND = 10, + + /* most threads run at normal priority */ + ANDROID_PRIORITY_NORMAL = 0, + + /* threads currently running a UI that the user is interacting with */ + ANDROID_PRIORITY_FOREGROUND = -2, + + /* the main UI thread has a slightly more favorable priority */ + ANDROID_PRIORITY_DISPLAY = -4, + + /* ui service treads might want to run at a urgent display (uncommon) */ + ANDROID_PRIORITY_URGENT_DISPLAY = HAL_PRIORITY_URGENT_DISPLAY, + + /* all normal video threads */ + ANDROID_PRIORITY_VIDEO = -10, + + /* all normal audio threads */ + ANDROID_PRIORITY_AUDIO = -16, + + /* service audio threads (uncommon) */ + ANDROID_PRIORITY_URGENT_AUDIO = -19, + + /* should never be used in practice. regular process might not + * be allowed to use this level */ + ANDROID_PRIORITY_HIGHEST = -20, + + ANDROID_PRIORITY_DEFAULT = ANDROID_PRIORITY_NORMAL, + ANDROID_PRIORITY_MORE_FAVORABLE = -1, + ANDROID_PRIORITY_LESS_FAVORABLE = +1, +}; + +#if defined(__cplusplus) +} +#endif + +#endif /* ANDROID_THREAD_DEFS_H */ diff --git a/include/android_stub/system/window.h b/include/android_stub/system/window.h new file mode 100644 index 00000000000..61590e01960 --- /dev/null +++ b/include/android_stub/system/window.h @@ -0,0 +1,988 @@ +/* + * Copyright (C) 2011 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. + */ + +/************************************************************************************************* + * + * IMPORTANT: + * + * There is an old copy of this file in system/core/include/system/window.h, which exists only + * for backward source compatibility. + * But there are binaries out there as well, so this version of window.h must stay binary + * backward compatible with the one found in system/core. + * + * + * Source compatibility is also required for now, because this is how we're handling the + * transition from system/core/include (global include path) to nativewindow/include. + * + *************************************************************************************************/ + +#pragma once + +#include <cutils/native_handle.h> +#include <errno.h> +#include <limits.h> +#include <stdint.h> +#include <string.h> +#include <sys/cdefs.h> +#include <system/graphics.h> +#include <unistd.h> +#include <stdbool.h> + +// system/window.h is a superset of the vndk +#include <vndk/window.h> + + +#ifndef __UNUSED +#define __UNUSED __attribute__((__unused__)) +#endif +#ifndef __deprecated +#define __deprecated __attribute__((__deprecated__)) +#endif + +__BEGIN_DECLS + +/*****************************************************************************/ + +#define ANDROID_NATIVE_WINDOW_MAGIC ANDROID_NATIVE_MAKE_CONSTANT('_','w','n','d') + +// --------------------------------------------------------------------------- + +/* attributes queriable with query() */ +enum { + NATIVE_WINDOW_WIDTH = 0, + NATIVE_WINDOW_HEIGHT = 1, + NATIVE_WINDOW_FORMAT = 2, + + /* see ANativeWindowQuery in vndk/window.h */ + NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS = ANATIVEWINDOW_QUERY_MIN_UNDEQUEUED_BUFFERS, + + /* Check whether queueBuffer operations on the ANativeWindow send the buffer + * to the window compositor. The query sets the returned 'value' argument + * to 1 if the ANativeWindow DOES send queued buffers directly to the window + * compositor and 0 if the buffers do not go directly to the window + * compositor. + * + * This can be used to determine whether protected buffer content should be + * sent to the ANativeWindow. Note, however, that a result of 1 does NOT + * indicate that queued buffers will be protected from applications or users + * capturing their contents. If that behavior is desired then some other + * mechanism (e.g. the GRALLOC_USAGE_PROTECTED flag) should be used in + * conjunction with this query. + */ + NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER = 4, + + /* Get the concrete type of a ANativeWindow. See below for the list of + * possible return values. + * + * This query should not be used outside the Android framework and will + * likely be removed in the near future. + */ + NATIVE_WINDOW_CONCRETE_TYPE = 5, + + + /* + * Default width and height of ANativeWindow buffers, these are the + * dimensions of the window buffers irrespective of the + * NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS call and match the native window + * size unless overridden by NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS. + */ + NATIVE_WINDOW_DEFAULT_WIDTH = ANATIVEWINDOW_QUERY_DEFAULT_WIDTH, + NATIVE_WINDOW_DEFAULT_HEIGHT = ANATIVEWINDOW_QUERY_DEFAULT_HEIGHT, + + /* see ANativeWindowQuery in vndk/window.h */ + NATIVE_WINDOW_TRANSFORM_HINT = ANATIVEWINDOW_QUERY_TRANSFORM_HINT, + + /* + * Boolean that indicates whether the consumer is running more than + * one buffer behind the producer. + */ + NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND = 9, + + /* + * The consumer gralloc usage bits currently set by the consumer. + * The values are defined in hardware/libhardware/include/gralloc.h. + */ + NATIVE_WINDOW_CONSUMER_USAGE_BITS = 10, /* deprecated */ + + /** + * Transformation that will by applied to buffers by the hwcomposer. + * This must not be set or checked by producer endpoints, and will + * disable the transform hint set in SurfaceFlinger (see + * NATIVE_WINDOW_TRANSFORM_HINT). + * + * INTENDED USE: + * Temporary - Please do not use this. This is intended only to be used + * by the camera's LEGACY mode. + * + * In situations where a SurfaceFlinger client wishes to set a transform + * that is not visible to the producer, and will always be applied in the + * hardware composer, the client can set this flag with + * native_window_set_buffers_sticky_transform. This can be used to rotate + * and flip buffers consumed by hardware composer without actually changing + * the aspect ratio of the buffers produced. + */ + NATIVE_WINDOW_STICKY_TRANSFORM = 11, + + /** + * The default data space for the buffers as set by the consumer. + * The values are defined in graphics.h. + */ + NATIVE_WINDOW_DEFAULT_DATASPACE = 12, + + /* see ANativeWindowQuery in vndk/window.h */ + NATIVE_WINDOW_BUFFER_AGE = ANATIVEWINDOW_QUERY_BUFFER_AGE, + + /* + * Returns the duration of the last dequeueBuffer call in microseconds + */ + NATIVE_WINDOW_LAST_DEQUEUE_DURATION = 14, + + /* + * Returns the duration of the last queueBuffer call in microseconds + */ + NATIVE_WINDOW_LAST_QUEUE_DURATION = 15, + + /* + * Returns the number of image layers that the ANativeWindow buffer + * contains. By default this is 1, unless a buffer is explicitly allocated + * to contain multiple layers. + */ + NATIVE_WINDOW_LAYER_COUNT = 16, + + /* + * Returns 1 if the native window is valid, 0 otherwise. native window is valid + * if it is safe (i.e. no crash will occur) to call any method on it. + */ + NATIVE_WINDOW_IS_VALID = 17, + + /* + * Returns 1 if NATIVE_WINDOW_GET_FRAME_TIMESTAMPS will return display + * present info, 0 if it won't. + */ + NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT = 18, + + /* + * The consumer end is capable of handling protected buffers, i.e. buffer + * with GRALLOC_USAGE_PROTECTED usage bits on. + */ + NATIVE_WINDOW_CONSUMER_IS_PROTECTED = 19, + + /* + * Returns data space for the buffers. + */ + NATIVE_WINDOW_DATASPACE = 20, + + /* + * Returns maxBufferCount set by BufferQueueConsumer + */ + NATIVE_WINDOW_MAX_BUFFER_COUNT = 21, +}; + +/* Valid operations for the (*perform)() hook. + * + * Values marked as 'deprecated' are supported, but have been superceded by + * other functionality. + * + * Values marked as 'private' should be considered private to the framework. + * HAL implementation code with access to an ANativeWindow should not use these, + * as it may not interact properly with the framework's use of the + * ANativeWindow. + */ +enum { + // clang-format off + NATIVE_WINDOW_SET_USAGE = 0, /* deprecated */ + NATIVE_WINDOW_CONNECT = 1, /* deprecated */ + NATIVE_WINDOW_DISCONNECT = 2, /* deprecated */ + NATIVE_WINDOW_SET_CROP = 3, /* private */ + NATIVE_WINDOW_SET_BUFFER_COUNT = 4, + NATIVE_WINDOW_SET_BUFFERS_GEOMETRY = 5, /* deprecated */ + NATIVE_WINDOW_SET_BUFFERS_TRANSFORM = 6, + NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP = 7, + NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS = 8, + NATIVE_WINDOW_SET_BUFFERS_FORMAT = 9, + NATIVE_WINDOW_SET_SCALING_MODE = 10, /* private */ + NATIVE_WINDOW_LOCK = 11, /* private */ + NATIVE_WINDOW_UNLOCK_AND_POST = 12, /* private */ + NATIVE_WINDOW_API_CONNECT = 13, /* private */ + NATIVE_WINDOW_API_DISCONNECT = 14, /* private */ + NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS = 15, /* private */ + NATIVE_WINDOW_SET_POST_TRANSFORM_CROP = 16, /* deprecated, unimplemented */ + NATIVE_WINDOW_SET_BUFFERS_STICKY_TRANSFORM = 17, /* private */ + NATIVE_WINDOW_SET_SIDEBAND_STREAM = 18, + NATIVE_WINDOW_SET_BUFFERS_DATASPACE = 19, + NATIVE_WINDOW_SET_SURFACE_DAMAGE = 20, /* private */ + NATIVE_WINDOW_SET_SHARED_BUFFER_MODE = 21, + NATIVE_WINDOW_SET_AUTO_REFRESH = 22, + NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION = 23, + NATIVE_WINDOW_GET_NEXT_FRAME_ID = 24, + NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS = 25, + NATIVE_WINDOW_GET_COMPOSITOR_TIMING = 26, + NATIVE_WINDOW_GET_FRAME_TIMESTAMPS = 27, + NATIVE_WINDOW_GET_WIDE_COLOR_SUPPORT = 28, + NATIVE_WINDOW_GET_HDR_SUPPORT = 29, + NATIVE_WINDOW_SET_USAGE64 = 30, + NATIVE_WINDOW_GET_CONSUMER_USAGE64 = 31, + NATIVE_WINDOW_SET_BUFFERS_SMPTE2086_METADATA = 32, + NATIVE_WINDOW_SET_BUFFERS_CTA861_3_METADATA = 33, + NATIVE_WINDOW_SET_BUFFERS_HDR10_PLUS_METADATA = 34, + // clang-format on +}; + +/* parameter for NATIVE_WINDOW_[API_][DIS]CONNECT */ +enum { + /* Buffers will be queued by EGL via eglSwapBuffers after being filled using + * OpenGL ES. + */ + NATIVE_WINDOW_API_EGL = 1, + + /* Buffers will be queued after being filled using the CPU + */ + NATIVE_WINDOW_API_CPU = 2, + + /* Buffers will be queued by Stagefright after being filled by a video + * decoder. The video decoder can either be a software or hardware decoder. + */ + NATIVE_WINDOW_API_MEDIA = 3, + + /* Buffers will be queued by the the camera HAL. + */ + NATIVE_WINDOW_API_CAMERA = 4, +}; + +/* parameter for NATIVE_WINDOW_SET_BUFFERS_TRANSFORM */ +enum { + /* flip source image horizontally */ + NATIVE_WINDOW_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H , + /* flip source image vertically */ + NATIVE_WINDOW_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V, + /* rotate source image 90 degrees clock-wise, and is applied after TRANSFORM_FLIP_{H|V} */ + NATIVE_WINDOW_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90, + /* rotate source image 180 degrees */ + NATIVE_WINDOW_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180, + /* rotate source image 270 degrees clock-wise */ + NATIVE_WINDOW_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270, + /* transforms source by the inverse transform of the screen it is displayed onto. This + * transform is applied last */ + NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY = 0x08 +}; + +/* parameter for NATIVE_WINDOW_SET_SCALING_MODE + * keep in sync with Surface.java in frameworks/base */ +enum { + /* the window content is not updated (frozen) until a buffer of + * the window size is received (enqueued) + */ + NATIVE_WINDOW_SCALING_MODE_FREEZE = 0, + /* the buffer is scaled in both dimensions to match the window size */ + NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW = 1, + /* the buffer is scaled uniformly such that the smaller dimension + * of the buffer matches the window size (cropping in the process) + */ + NATIVE_WINDOW_SCALING_MODE_SCALE_CROP = 2, + /* the window is clipped to the size of the buffer's crop rectangle; pixels + * outside the crop rectangle are treated as if they are completely + * transparent. + */ + NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP = 3, +}; + +/* values returned by the NATIVE_WINDOW_CONCRETE_TYPE query */ +enum { + NATIVE_WINDOW_FRAMEBUFFER = 0, /* FramebufferNativeWindow */ + NATIVE_WINDOW_SURFACE = 1, /* Surface */ +}; + +/* parameter for NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP + * + * Special timestamp value to indicate that timestamps should be auto-generated + * by the native window when queueBuffer is called. This is equal to INT64_MIN, + * defined directly to avoid problems with C99/C++ inclusion of stdint.h. + */ +static const int64_t NATIVE_WINDOW_TIMESTAMP_AUTO = (-9223372036854775807LL-1); + +/* parameter for NATIVE_WINDOW_GET_FRAME_TIMESTAMPS + * + * Special timestamp value to indicate the timestamps aren't yet known or + * that they are invalid. + */ +static const int64_t NATIVE_WINDOW_TIMESTAMP_PENDING = -2; +static const int64_t NATIVE_WINDOW_TIMESTAMP_INVALID = -1; + +struct ANativeWindow +{ +#ifdef __cplusplus + ANativeWindow() + : flags(0), minSwapInterval(0), maxSwapInterval(0), xdpi(0), ydpi(0) + { + common.magic = ANDROID_NATIVE_WINDOW_MAGIC; + common.version = sizeof(ANativeWindow); + memset(common.reserved, 0, sizeof(common.reserved)); + } + + /* Implement the methods that sp<ANativeWindow> expects so that it + can be used to automatically refcount ANativeWindow's. */ + void incStrong(const void* /*id*/) const { + common.incRef(const_cast<android_native_base_t*>(&common)); + } + void decStrong(const void* /*id*/) const { + common.decRef(const_cast<android_native_base_t*>(&common)); + } +#endif + + struct android_native_base_t common; + + /* flags describing some attributes of this surface or its updater */ + const uint32_t flags; + + /* min swap interval supported by this updated */ + const int minSwapInterval; + + /* max swap interval supported by this updated */ + const int maxSwapInterval; + + /* horizontal and vertical resolution in DPI */ + const float xdpi; + const float ydpi; + + /* Some storage reserved for the OEM's driver. */ + intptr_t oem[4]; + + /* + * Set the swap interval for this surface. + * + * Returns 0 on success or -errno on error. + */ + int (*setSwapInterval)(struct ANativeWindow* window, + int interval); + + /* + * Hook called by EGL to acquire a buffer. After this call, the buffer + * is not locked, so its content cannot be modified. This call may block if + * no buffers are available. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * Returns 0 on success or -errno on error. + * + * XXX: This function is deprecated. It will continue to work for some + * time for binary compatibility, but the new dequeueBuffer function that + * outputs a fence file descriptor should be used in its place. + */ + int (*dequeueBuffer_DEPRECATED)(struct ANativeWindow* window, + struct ANativeWindowBuffer** buffer); + + /* + * hook called by EGL to lock a buffer. This MUST be called before modifying + * the content of a buffer. The buffer must have been acquired with + * dequeueBuffer first. + * + * Returns 0 on success or -errno on error. + * + * XXX: This function is deprecated. It will continue to work for some + * time for binary compatibility, but it is essentially a no-op, and calls + * to it should be removed. + */ + int (*lockBuffer_DEPRECATED)(struct ANativeWindow* window, + struct ANativeWindowBuffer* buffer); + + /* + * Hook called by EGL when modifications to the render buffer are done. + * This unlocks and post the buffer. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * Buffers MUST be queued in the same order than they were dequeued. + * + * Returns 0 on success or -errno on error. + * + * XXX: This function is deprecated. It will continue to work for some + * time for binary compatibility, but the new queueBuffer function that + * takes a fence file descriptor should be used in its place (pass a value + * of -1 for the fence file descriptor if there is no valid one to pass). + */ + int (*queueBuffer_DEPRECATED)(struct ANativeWindow* window, + struct ANativeWindowBuffer* buffer); + + /* + * hook used to retrieve information about the native window. + * + * Returns 0 on success or -errno on error. + */ + int (*query)(const struct ANativeWindow* window, + int what, int* value); + + /* + * hook used to perform various operations on the surface. + * (*perform)() is a generic mechanism to add functionality to + * ANativeWindow while keeping backward binary compatibility. + * + * DO NOT CALL THIS HOOK DIRECTLY. Instead, use the helper functions + * defined below. + * + * (*perform)() returns -ENOENT if the 'what' parameter is not supported + * by the surface's implementation. + * + * See above for a list of valid operations, such as + * NATIVE_WINDOW_SET_USAGE or NATIVE_WINDOW_CONNECT + */ + int (*perform)(struct ANativeWindow* window, + int operation, ... ); + + /* + * Hook used to cancel a buffer that has been dequeued. + * No synchronization is performed between dequeue() and cancel(), so + * either external synchronization is needed, or these functions must be + * called from the same thread. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * XXX: This function is deprecated. It will continue to work for some + * time for binary compatibility, but the new cancelBuffer function that + * takes a fence file descriptor should be used in its place (pass a value + * of -1 for the fence file descriptor if there is no valid one to pass). + */ + int (*cancelBuffer_DEPRECATED)(struct ANativeWindow* window, + struct ANativeWindowBuffer* buffer); + + /* + * Hook called by EGL to acquire a buffer. This call may block if no + * buffers are available. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * The libsync fence file descriptor returned in the int pointed to by the + * fenceFd argument will refer to the fence that must signal before the + * dequeued buffer may be written to. A value of -1 indicates that the + * caller may access the buffer immediately without waiting on a fence. If + * a valid file descriptor is returned (i.e. any value except -1) then the + * caller is responsible for closing the file descriptor. + * + * Returns 0 on success or -errno on error. + */ + int (*dequeueBuffer)(struct ANativeWindow* window, + struct ANativeWindowBuffer** buffer, int* fenceFd); + + /* + * Hook called by EGL when modifications to the render buffer are done. + * This unlocks and post the buffer. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * The fenceFd argument specifies a libsync fence file descriptor for a + * fence that must signal before the buffer can be accessed. If the buffer + * can be accessed immediately then a value of -1 should be used. The + * caller must not use the file descriptor after it is passed to + * queueBuffer, and the ANativeWindow implementation is responsible for + * closing it. + * + * Returns 0 on success or -errno on error. + */ + int (*queueBuffer)(struct ANativeWindow* window, + struct ANativeWindowBuffer* buffer, int fenceFd); + + /* + * Hook used to cancel a buffer that has been dequeued. + * No synchronization is performed between dequeue() and cancel(), so + * either external synchronization is needed, or these functions must be + * called from the same thread. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * The fenceFd argument specifies a libsync fence file decsriptor for a + * fence that must signal before the buffer can be accessed. If the buffer + * can be accessed immediately then a value of -1 should be used. + * + * Note that if the client has not waited on the fence that was returned + * from dequeueBuffer, that same fence should be passed to cancelBuffer to + * ensure that future uses of the buffer are preceded by a wait on that + * fence. The caller must not use the file descriptor after it is passed + * to cancelBuffer, and the ANativeWindow implementation is responsible for + * closing it. + * + * Returns 0 on success or -errno on error. + */ + int (*cancelBuffer)(struct ANativeWindow* window, + struct ANativeWindowBuffer* buffer, int fenceFd); +}; + + /* Backwards compatibility: use ANativeWindow (struct ANativeWindow in C). + * android_native_window_t is deprecated. + */ +typedef struct ANativeWindow android_native_window_t __deprecated; + +/* + * native_window_set_usage64(..., usage) + * Sets the intended usage flags for the next buffers + * acquired with (*lockBuffer)() and on. + * + * Valid usage flags are defined in android/hardware_buffer.h + * All AHARDWAREBUFFER_USAGE_* flags can be specified as needed. + * + * Calling this function will usually cause following buffers to be + * reallocated. + */ +static inline int native_window_set_usage(struct ANativeWindow* window, uint64_t usage) { + return window->perform(window, NATIVE_WINDOW_SET_USAGE64, usage); +} + +/* deprecated. Always returns 0. Don't call. */ +static inline int native_window_connect( + struct ANativeWindow* window __UNUSED, int api __UNUSED) __deprecated; + +static inline int native_window_connect( + struct ANativeWindow* window __UNUSED, int api __UNUSED) { + return 0; +} + +/* deprecated. Always returns 0. Don't call. */ +static inline int native_window_disconnect( + struct ANativeWindow* window __UNUSED, int api __UNUSED) __deprecated; + +static inline int native_window_disconnect( + struct ANativeWindow* window __UNUSED, int api __UNUSED) { + return 0; +} + +/* + * native_window_set_crop(..., crop) + * Sets which region of the next queued buffers needs to be considered. + * Depending on the scaling mode, a buffer's crop region is scaled and/or + * cropped to match the surface's size. This function sets the crop in + * pre-transformed buffer pixel coordinates. + * + * The specified crop region applies to all buffers queued after it is called. + * + * If 'crop' is NULL, subsequently queued buffers won't be cropped. + * + * An error is returned if for instance the crop region is invalid, out of the + * buffer's bound or if the window is invalid. + */ +static inline int native_window_set_crop( + struct ANativeWindow* window, + android_native_rect_t const * crop) +{ + return window->perform(window, NATIVE_WINDOW_SET_CROP, crop); +} + +/* + * native_window_set_buffer_count(..., count) + * Sets the number of buffers associated with this native window. + */ +static inline int native_window_set_buffer_count( + struct ANativeWindow* window, + size_t bufferCount) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFER_COUNT, bufferCount); +} + +/* + * native_window_set_buffers_geometry(..., int w, int h, int format) + * All buffers dequeued after this call will have the dimensions and format + * specified. A successful call to this function has the same effect as calling + * native_window_set_buffers_size and native_window_set_buffers_format. + * + * XXX: This function is deprecated. The native_window_set_buffers_dimensions + * and native_window_set_buffers_format functions should be used instead. + */ +static inline int native_window_set_buffers_geometry( + struct ANativeWindow* window, + int w, int h, int format) __deprecated; + +static inline int native_window_set_buffers_geometry( + struct ANativeWindow* window, + int w, int h, int format) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_GEOMETRY, + w, h, format); +} + +/* + * native_window_set_buffers_dimensions(..., int w, int h) + * All buffers dequeued after this call will have the dimensions specified. + * In particular, all buffers will have a fixed-size, independent from the + * native-window size. They will be scaled according to the scaling mode + * (see native_window_set_scaling_mode) upon window composition. + * + * If w and h are 0, the normal behavior is restored. That is, dequeued buffers + * following this call will be sized to match the window's size. + * + * Calling this function will reset the window crop to a NULL value, which + * disables cropping of the buffers. + */ +static inline int native_window_set_buffers_dimensions( + struct ANativeWindow* window, + int w, int h) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS, + w, h); +} + +/* + * native_window_set_buffers_user_dimensions(..., int w, int h) + * + * Sets the user buffer size for the window, which overrides the + * window's size. All buffers dequeued after this call will have the + * dimensions specified unless overridden by + * native_window_set_buffers_dimensions. All buffers will have a + * fixed-size, independent from the native-window size. They will be + * scaled according to the scaling mode (see + * native_window_set_scaling_mode) upon window composition. + * + * If w and h are 0, the normal behavior is restored. That is, the + * default buffer size will match the windows's size. + * + * Calling this function will reset the window crop to a NULL value, which + * disables cropping of the buffers. + */ +static inline int native_window_set_buffers_user_dimensions( + struct ANativeWindow* window, + int w, int h) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS, + w, h); +} + +/* + * native_window_set_buffers_format(..., int format) + * All buffers dequeued after this call will have the format specified. + * + * If the specified format is 0, the default buffer format will be used. + */ +static inline int native_window_set_buffers_format( + struct ANativeWindow* window, + int format) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_FORMAT, format); +} + +/* + * native_window_set_buffers_data_space(..., int dataSpace) + * All buffers queued after this call will be associated with the dataSpace + * parameter specified. + * + * dataSpace specifies additional information about the buffer that's dependent + * on the buffer format and the endpoints. For example, it can be used to convey + * the color space of the image data in the buffer, or it can be used to + * indicate that the buffers contain depth measurement data instead of color + * images. The default dataSpace is 0, HAL_DATASPACE_UNKNOWN, unless it has been + * overridden by the consumer. + */ +static inline int native_window_set_buffers_data_space( + struct ANativeWindow* window, + android_dataspace_t dataSpace) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_DATASPACE, + dataSpace); +} + +/* + * native_window_set_buffers_smpte2086_metadata(..., metadata) + * All buffers queued after this call will be associated with the SMPTE + * ST.2086 metadata specified. + * + * metadata specifies additional information about the contents of the buffer + * that may affect how it's displayed. When it is nullptr, it means no such + * information is available. No SMPTE ST.2086 metadata is associated with the + * buffers by default. + */ +static inline int native_window_set_buffers_smpte2086_metadata( + struct ANativeWindow* window, + const struct android_smpte2086_metadata* metadata) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_SMPTE2086_METADATA, + metadata); +} + +/* + * native_window_set_buffers_cta861_3_metadata(..., metadata) + * All buffers queued after this call will be associated with the CTA-861.3 + * metadata specified. + * + * metadata specifies additional information about the contents of the buffer + * that may affect how it's displayed. When it is nullptr, it means no such + * information is available. No CTA-861.3 metadata is associated with the + * buffers by default. + */ +static inline int native_window_set_buffers_cta861_3_metadata( + struct ANativeWindow* window, + const struct android_cta861_3_metadata* metadata) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_CTA861_3_METADATA, + metadata); +} + +/* + * native_window_set_buffers_hdr10_plus_metadata(..., metadata) + * All buffers queued after this call will be associated with the + * HDR10+ dynamic metadata specified. + * + * metadata specifies additional dynamic information about the + * contents of the buffer that may affect how it is displayed. When + * it is nullptr, it means no such information is available. No + * HDR10+ dynamic emtadata is associated with the buffers by default. + * + * Parameter "size" refers to the length of the metadata blob pointed to + * by parameter "data". The metadata blob will adhere to the HDR10+ SEI + * message standard. + */ +static inline int native_window_set_buffers_hdr10_plus_metadata(struct ANativeWindow* window, + const size_t size, + const uint8_t* metadata) { + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_HDR10_PLUS_METADATA, size, + metadata); +} + +/* + * native_window_set_buffers_transform(..., int transform) + * All buffers queued after this call will be displayed transformed according + * to the transform parameter specified. + */ +static inline int native_window_set_buffers_transform( + struct ANativeWindow* window, + int transform) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_TRANSFORM, + transform); +} + +/* + * native_window_set_buffers_sticky_transform(..., int transform) + * All buffers queued after this call will be displayed transformed according + * to the transform parameter specified applied on top of the regular buffer + * transform. Setting this transform will disable the transform hint. + * + * Temporary - This is only intended to be used by the LEGACY camera mode, do + * not use this for anything else. + */ +static inline int native_window_set_buffers_sticky_transform( + struct ANativeWindow* window, + int transform) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_STICKY_TRANSFORM, + transform); +} + +/* + * native_window_set_buffers_timestamp(..., int64_t timestamp) + * All buffers queued after this call will be associated with the timestamp + * parameter specified. If the timestamp is set to NATIVE_WINDOW_TIMESTAMP_AUTO + * (the default), timestamps will be generated automatically when queueBuffer is + * called. The timestamp is measured in nanoseconds, and is normally monotonically + * increasing. The timestamp should be unaffected by time-of-day adjustments, + * and for a camera should be strictly monotonic but for a media player may be + * reset when the position is set. + */ +static inline int native_window_set_buffers_timestamp( + struct ANativeWindow* window, + int64_t timestamp) +{ + return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP, + timestamp); +} + +/* + * native_window_set_scaling_mode(..., int mode) + * All buffers queued after this call will be associated with the scaling mode + * specified. + */ +static inline int native_window_set_scaling_mode( + struct ANativeWindow* window, + int mode) +{ + return window->perform(window, NATIVE_WINDOW_SET_SCALING_MODE, + mode); +} + +/* + * native_window_api_connect(..., int api) + * connects an API to this window. only one API can be connected at a time. + * Returns -EINVAL if for some reason the window cannot be connected, which + * can happen if it's connected to some other API. + */ +static inline int native_window_api_connect( + struct ANativeWindow* window, int api) +{ + return window->perform(window, NATIVE_WINDOW_API_CONNECT, api); +} + +/* + * native_window_api_disconnect(..., int api) + * disconnect the API from this window. + * An error is returned if for instance the window wasn't connected in the + * first place. + */ +static inline int native_window_api_disconnect( + struct ANativeWindow* window, int api) +{ + return window->perform(window, NATIVE_WINDOW_API_DISCONNECT, api); +} + +/* + * native_window_dequeue_buffer_and_wait(...) + * Dequeue a buffer and wait on the fence associated with that buffer. The + * buffer may safely be accessed immediately upon this function returning. An + * error is returned if either of the dequeue or the wait operations fail. + */ +static inline int native_window_dequeue_buffer_and_wait(ANativeWindow *anw, + struct ANativeWindowBuffer** anb) { + return anw->dequeueBuffer_DEPRECATED(anw, anb); +} + +/* + * native_window_set_sideband_stream(..., native_handle_t*) + * Attach a sideband buffer stream to a native window. + */ +static inline int native_window_set_sideband_stream( + struct ANativeWindow* window, + native_handle_t* sidebandHandle) +{ + return window->perform(window, NATIVE_WINDOW_SET_SIDEBAND_STREAM, + sidebandHandle); +} + +/* + * native_window_set_surface_damage(..., android_native_rect_t* rects, int numRects) + * Set the surface damage (i.e., the region of the surface that has changed + * since the previous frame). The damage set by this call will be reset (to the + * default of full-surface damage) after calling queue, so this must be called + * prior to every frame with damage that does not cover the whole surface if the + * caller desires downstream consumers to use this optimization. + * + * The damage region is specified as an array of rectangles, with the important + * caveat that the origin of the surface is considered to be the bottom-left + * corner, as in OpenGL ES. + * + * If numRects is set to 0, rects may be NULL, and the surface damage will be + * set to the full surface (the same as if this function had not been called for + * this frame). + */ +static inline int native_window_set_surface_damage( + struct ANativeWindow* window, + const android_native_rect_t* rects, size_t numRects) +{ + return window->perform(window, NATIVE_WINDOW_SET_SURFACE_DAMAGE, + rects, numRects); +} + +/* + * native_window_set_shared_buffer_mode(..., bool sharedBufferMode) + * Enable/disable shared buffer mode + */ +static inline int native_window_set_shared_buffer_mode( + struct ANativeWindow* window, + bool sharedBufferMode) +{ + return window->perform(window, NATIVE_WINDOW_SET_SHARED_BUFFER_MODE, + sharedBufferMode); +} + +/* + * native_window_set_auto_refresh(..., autoRefresh) + * Enable/disable auto refresh when in shared buffer mode + */ +static inline int native_window_set_auto_refresh( + struct ANativeWindow* window, + bool autoRefresh) +{ + return window->perform(window, NATIVE_WINDOW_SET_AUTO_REFRESH, autoRefresh); +} + +static inline int native_window_get_refresh_cycle_duration( + struct ANativeWindow* window, + int64_t* outRefreshDuration) +{ + return window->perform(window, NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION, + outRefreshDuration); +} + +static inline int native_window_get_next_frame_id( + struct ANativeWindow* window, uint64_t* frameId) +{ + return window->perform(window, NATIVE_WINDOW_GET_NEXT_FRAME_ID, frameId); +} + +static inline int native_window_enable_frame_timestamps( + struct ANativeWindow* window, bool enable) +{ + return window->perform(window, NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS, + enable); +} + +static inline int native_window_get_compositor_timing( + struct ANativeWindow* window, + int64_t* compositeDeadline, int64_t* compositeInterval, + int64_t* compositeToPresentLatency) +{ + return window->perform(window, NATIVE_WINDOW_GET_COMPOSITOR_TIMING, + compositeDeadline, compositeInterval, compositeToPresentLatency); +} + +static inline int native_window_get_frame_timestamps( + struct ANativeWindow* window, uint64_t frameId, + int64_t* outRequestedPresentTime, int64_t* outAcquireTime, + int64_t* outLatchTime, int64_t* outFirstRefreshStartTime, + int64_t* outLastRefreshStartTime, int64_t* outGpuCompositionDoneTime, + int64_t* outDisplayPresentTime, int64_t* outDequeueReadyTime, + int64_t* outReleaseTime) +{ + return window->perform(window, NATIVE_WINDOW_GET_FRAME_TIMESTAMPS, + frameId, outRequestedPresentTime, outAcquireTime, outLatchTime, + outFirstRefreshStartTime, outLastRefreshStartTime, + outGpuCompositionDoneTime, outDisplayPresentTime, + outDequeueReadyTime, outReleaseTime); +} + +static inline int native_window_get_wide_color_support( + struct ANativeWindow* window, bool* outSupport) { + return window->perform(window, NATIVE_WINDOW_GET_WIDE_COLOR_SUPPORT, + outSupport); +} + +static inline int native_window_get_hdr_support(struct ANativeWindow* window, + bool* outSupport) { + return window->perform(window, NATIVE_WINDOW_GET_HDR_SUPPORT, outSupport); +} + +static inline int native_window_get_consumer_usage(struct ANativeWindow* window, + uint64_t* outUsage) { + return window->perform(window, NATIVE_WINDOW_GET_CONSUMER_USAGE64, outUsage); +} + +__END_DECLS diff --git a/include/android_stub/vndk/hardware_buffer.h b/include/android_stub/vndk/hardware_buffer.h new file mode 100644 index 00000000000..3392d7f0940 --- /dev/null +++ b/include/android_stub/vndk/hardware_buffer.h @@ -0,0 +1,86 @@ +/* + * Copyright 2017 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. + */ + +#ifndef ANDROID_VNDK_NATIVEWINDOW_AHARDWAREBUFFER_H +#define ANDROID_VNDK_NATIVEWINDOW_AHARDWAREBUFFER_H + +// vndk is a superset of the NDK +#include <android/hardware_buffer.h> + +#include <cutils/native_handle.h> + +__BEGIN_DECLS + +const native_handle_t* AHardwareBuffer_getNativeHandle(const AHardwareBuffer* buffer); + +enum CreateFromHandleMethod { + // enum values chosen to match internal GraphicBuffer::HandleWrapMethod + AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_REGISTER = 2, + AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE = 3, +}; + +/** + * Create a AHardwareBuffer from a native handle. + * + * This function wraps a native handle in a AHardwareBuffer suitable for use by applications or + * other parts of the system. The contents of desc will be returned by AHardwareBuffer_describe(). + * + * If method is AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_REGISTER, the handle is assumed to be + * unregistered, and it will be registered/imported before being wrapped in the AHardwareBuffer. + * If successful, the AHardwareBuffer will own the handle. + * + * If method is AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE, the handle will be cloned and the + * clone registered. The AHardwareBuffer will own the cloned handle but not the original. + */ +int AHardwareBuffer_createFromHandle(const AHardwareBuffer_Desc* desc, + const native_handle_t* handle, int32_t method, + AHardwareBuffer** outBuffer); + +/** + * Buffer pixel formats. + */ +enum { + /* for future proofing, keep these in sync with system/graphics-base.h */ + + /* same as HAL_PIXEL_FORMAT_BGRA_8888 */ + AHARDWAREBUFFER_FORMAT_B8G8R8A8_UNORM = 5, + /* same as HAL_PIXEL_FORMAT_YV12 */ + AHARDWAREBUFFER_FORMAT_YV12 = 0x32315659, + /* same as HAL_PIXEL_FORMAT_Y8 */ + AHARDWAREBUFFER_FORMAT_Y8 = 0x20203859, + /* same as HAL_PIXEL_FORMAT_Y16 */ + AHARDWAREBUFFER_FORMAT_Y16 = 0x20363159, + /* same as HAL_PIXEL_FORMAT_RAW16 */ + AHARDWAREBUFFER_FORMAT_RAW16 = 0x20, + /* same as HAL_PIXEL_FORMAT_RAW10 */ + AHARDWAREBUFFER_FORMAT_RAW10 = 0x25, + /* same as HAL_PIXEL_FORMAT_RAW12 */ + AHARDWAREBUFFER_FORMAT_RAW12 = 0x26, + /* same as HAL_PIXEL_FORMAT_RAW_OPAQUE */ + AHARDWAREBUFFER_FORMAT_RAW_OPAQUE = 0x24, + /* same as HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED */ + AHARDWAREBUFFER_FORMAT_IMPLEMENTATION_DEFINED = 0x22, + /* same as HAL_PIXEL_FORMAT_YCBCR_422_SP */ + AHARDWAREBUFFER_FORMAT_YCbCr_422_SP = 0x10, + /* same as HAL_PIXEL_FORMAT_YCRCB_420_SP */ + AHARDWAREBUFFER_FORMAT_YCrCb_420_SP = 0x11, + /* same as HAL_PIXEL_FORMAT_YCBCR_422_I */ + AHARDWAREBUFFER_FORMAT_YCbCr_422_I = 0x14, +}; + +__END_DECLS + +#endif /* ANDROID_VNDK_NATIVEWINDOW_AHARDWAREBUFFER_H */ diff --git a/include/android_stub/vndk/window.h b/include/android_stub/vndk/window.h new file mode 100644 index 00000000000..995ba44d209 --- /dev/null +++ b/include/android_stub/vndk/window.h @@ -0,0 +1,324 @@ +/* + * Copyright (C) 2017 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. + */ + +#ifndef ANDROID_VNDK_NATIVEWINDOW_ANATIVEWINDOW_H +#define ANDROID_VNDK_NATIVEWINDOW_ANATIVEWINDOW_H + +#include <nativebase/nativebase.h> + +// vndk is a superset of the NDK +#include <android/native_window.h> + + +__BEGIN_DECLS + +/* + * Convert this ANativeWindowBuffer into a AHardwareBuffer + */ +AHardwareBuffer* ANativeWindowBuffer_getHardwareBuffer(ANativeWindowBuffer* anwb); + +/*****************************************************************************/ + +/* + * Stores a value into one of the 4 available slots + * Retrieve the value with ANativeWindow_OemStorageGet() + * + * slot: 0 to 3 + * + * Returns 0 on success or -errno on error. + */ +int ANativeWindow_OemStorageSet(ANativeWindow* window, uint32_t slot, intptr_t value); + + +/* + * Retrieves a value from one of the 4 available slots + * By default the returned value is 0 if it wasn't set by ANativeWindow_OemStorageSet() + * + * slot: 0 to 3 + * + * Returns 0 on success or -errno on error. + */ +int ANativeWindow_OemStorageGet(ANativeWindow* window, uint32_t slot, intptr_t* value); + + +/* + * Set the swap interval for this surface. + * + * Returns 0 on success or -errno on error. + */ +int ANativeWindow_setSwapInterval(ANativeWindow* window, int interval); + + +/* + * queries that can be used with ANativeWindow_query() and ANativeWindow_queryf() + */ +enum ANativeWindowQuery { + /* The minimum number of buffers that must remain un-dequeued after a buffer + * has been queued. This value applies only if set_buffer_count was used to + * override the number of buffers and if a buffer has since been queued. + * Users of the set_buffer_count ANativeWindow method should query this + * value before calling set_buffer_count. If it is necessary to have N + * buffers simultaneously dequeued as part of the steady-state operation, + * and this query returns M then N+M buffers should be requested via + * native_window_set_buffer_count. + * + * Note that this value does NOT apply until a single buffer has been + * queued. In particular this means that it is possible to: + * + * 1. Query M = min undequeued buffers + * 2. Set the buffer count to N + M + * 3. Dequeue all N + M buffers + * 4. Cancel M buffers + * 5. Queue, dequeue, queue, dequeue, ad infinitum + */ + ANATIVEWINDOW_QUERY_MIN_UNDEQUEUED_BUFFERS = 3, + + /* + * Default width of ANativeWindow buffers, these are the + * dimensions of the window buffers irrespective of the + * ANativeWindow_setBuffersDimensions() call and match the native window + * size. + */ + ANATIVEWINDOW_QUERY_DEFAULT_WIDTH = 6, + ANATIVEWINDOW_QUERY_DEFAULT_HEIGHT = 7, + + /* + * transformation that will most-likely be applied to buffers. This is only + * a hint, the actual transformation applied might be different. + * + * INTENDED USE: + * + * The transform hint can be used by a producer, for instance the GLES + * driver, to pre-rotate the rendering such that the final transformation + * in the composer is identity. This can be very useful when used in + * conjunction with the h/w composer HAL, in situations where it + * cannot handle arbitrary rotations. + * + * 1. Before dequeuing a buffer, the GL driver (or any other ANW client) + * queries the ANW for NATIVE_WINDOW_TRANSFORM_HINT. + * + * 2. The GL driver overrides the width and height of the ANW to + * account for NATIVE_WINDOW_TRANSFORM_HINT. This is done by querying + * NATIVE_WINDOW_DEFAULT_{WIDTH | HEIGHT}, swapping the dimensions + * according to NATIVE_WINDOW_TRANSFORM_HINT and calling + * native_window_set_buffers_dimensions(). + * + * 3. The GL driver dequeues a buffer of the new pre-rotated size. + * + * 4. The GL driver renders to the buffer such that the image is + * already transformed, that is applying NATIVE_WINDOW_TRANSFORM_HINT + * to the rendering. + * + * 5. The GL driver calls native_window_set_transform to apply + * inverse transformation to the buffer it just rendered. + * In order to do this, the GL driver needs + * to calculate the inverse of NATIVE_WINDOW_TRANSFORM_HINT, this is + * done easily: + * + * int hintTransform, inverseTransform; + * query(..., NATIVE_WINDOW_TRANSFORM_HINT, &hintTransform); + * inverseTransform = hintTransform; + * if (hintTransform & HAL_TRANSFORM_ROT_90) + * inverseTransform ^= HAL_TRANSFORM_ROT_180; + * + * + * 6. The GL driver queues the pre-transformed buffer. + * + * 7. The composer combines the buffer transform with the display + * transform. If the buffer transform happens to cancel out the + * display transform then no rotation is needed. + * + */ + ANATIVEWINDOW_QUERY_TRANSFORM_HINT = 8, + + /* + * Returns the age of the contents of the most recently dequeued buffer as + * the number of frames that have elapsed since it was last queued. For + * example, if the window is double-buffered, the age of any given buffer in + * steady state will be 2. If the dequeued buffer has never been queued, its + * age will be 0. + */ + ANATIVEWINDOW_QUERY_BUFFER_AGE = 13, + + /* min swap interval supported by this compositor */ + ANATIVEWINDOW_QUERY_MIN_SWAP_INTERVAL = 0x10000, + + /* max swap interval supported by this compositor */ + ANATIVEWINDOW_QUERY_MAX_SWAP_INTERVAL = 0x10001, + + /* horizontal resolution in DPI. value is float, use queryf() */ + ANATIVEWINDOW_QUERY_XDPI = 0x10002, + + /* vertical resolution in DPI. value is float, use queryf() */ + ANATIVEWINDOW_QUERY_YDPI = 0x10003, +}; + +typedef enum ANativeWindowQuery ANativeWindowQuery; + +/* + * hook used to retrieve information about the native window. + * + * Returns 0 on success or -errno on error. + */ +int ANativeWindow_query(const ANativeWindow* window, ANativeWindowQuery query, int* value); +int ANativeWindow_queryf(const ANativeWindow* window, ANativeWindowQuery query, float* value); + + +/* + * Hook called by EGL to acquire a buffer. This call may block if no + * buffers are available. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * The libsync fence file descriptor returned in the int pointed to by the + * fenceFd argument will refer to the fence that must signal before the + * dequeued buffer may be written to. A value of -1 indicates that the + * caller may access the buffer immediately without waiting on a fence. If + * a valid file descriptor is returned (i.e. any value except -1) then the + * caller is responsible for closing the file descriptor. + * + * Returns 0 on success or -errno on error. + */ +int ANativeWindow_dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd); + + +/* + * Hook called by EGL when modifications to the render buffer are done. + * This unlocks and post the buffer. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * The fenceFd argument specifies a libsync fence file descriptor for a + * fence that must signal before the buffer can be accessed. If the buffer + * can be accessed immediately then a value of -1 should be used. The + * caller must not use the file descriptor after it is passed to + * queueBuffer, and the ANativeWindow implementation is responsible for + * closing it. + * + * Returns 0 on success or -errno on error. + */ +int ANativeWindow_queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd); + + +/* + * Hook used to cancel a buffer that has been dequeued. + * No synchronization is performed between dequeue() and cancel(), so + * either external synchronization is needed, or these functions must be + * called from the same thread. + * + * The window holds a reference to the buffer between dequeueBuffer and + * either queueBuffer or cancelBuffer, so clients only need their own + * reference if they might use the buffer after queueing or canceling it. + * Holding a reference to a buffer after queueing or canceling it is only + * allowed if a specific buffer count has been set. + * + * The fenceFd argument specifies a libsync fence file decsriptor for a + * fence that must signal before the buffer can be accessed. If the buffer + * can be accessed immediately then a value of -1 should be used. + * + * Note that if the client has not waited on the fence that was returned + * from dequeueBuffer, that same fence should be passed to cancelBuffer to + * ensure that future uses of the buffer are preceded by a wait on that + * fence. The caller must not use the file descriptor after it is passed + * to cancelBuffer, and the ANativeWindow implementation is responsible for + * closing it. + * + * Returns 0 on success or -errno on error. + */ +int ANativeWindow_cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd); + +/* + * Sets the intended usage flags for the next buffers. + * + * usage: one of AHARDWAREBUFFER_USAGE_* constant + * + * By default (if this function is never called), a usage of + * AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT + * is assumed. + * + * Calling this function will usually cause following buffers to be + * reallocated. + */ +int ANativeWindow_setUsage(ANativeWindow* window, uint64_t usage); + + +/* + * Sets the number of buffers associated with this native window. + */ +int ANativeWindow_setBufferCount(ANativeWindow* window, size_t bufferCount); + + +/* + * All buffers dequeued after this call will have the dimensions specified. + * In particular, all buffers will have a fixed-size, independent from the + * native-window size. They will be scaled according to the scaling mode + * (see native_window_set_scaling_mode) upon window composition. + * + * If w and h are 0, the normal behavior is restored. That is, dequeued buffers + * following this call will be sized to match the window's size. + * + * Calling this function will reset the window crop to a NULL value, which + * disables cropping of the buffers. + */ +int ANativeWindow_setBuffersDimensions(ANativeWindow* window, uint32_t w, uint32_t h); + + +/* + * All buffers dequeued after this call will have the format specified. + * format: one of AHARDWAREBUFFER_FORMAT_* constant + * + * If the specified format is 0, the default buffer format will be used. + */ +int ANativeWindow_setBuffersFormat(ANativeWindow* window, int format); + + +/* + * All buffers queued after this call will be associated with the timestamp in nanosecond + * parameter specified. If the timestamp is set to NATIVE_WINDOW_TIMESTAMP_AUTO + * (the default), timestamps will be generated automatically when queueBuffer is + * called. The timestamp is measured in nanoseconds, and is normally monotonically + * increasing. The timestamp should be unaffected by time-of-day adjustments, + * and for a camera should be strictly monotonic but for a media player may be + * reset when the position is set. + */ +int ANativeWindow_setBuffersTimestamp(ANativeWindow* window, int64_t timestamp); + + +/* + * Enable/disable shared buffer mode + */ +int ANativeWindow_setSharedBufferMode(ANativeWindow* window, bool sharedBufferMode); + + +/* + * Enable/disable auto refresh when in shared buffer mode + */ +int ANativeWindow_setAutoRefresh(ANativeWindow* window, bool autoRefresh); + + +/*****************************************************************************/ + +__END_DECLS + +#endif /* ANDROID_VNDK_NATIVEWINDOW_ANATIVEWINDOW_H */ diff --git a/include/meson.build b/include/meson.build index bddbd67d328..981ab97913f 100644 --- a/include/meson.build +++ b/include/meson.build @@ -18,10 +18,17 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -inc_include = include_directories('.') +inc_include = [include_directories('.')] inc_d3d9 = include_directories('D3D9') inc_haikugl = include_directories('HaikuGL') +# Most things assume that Android headers are in the default include +# path when compiling for Android so add the stub headers to +# inc_include when using the stub. +if with_android_stub + inc_include += [include_directories('android_stub')] +endif + if not with_glvnd if with_gles1 or with_gles2 or with_opengl or with_egl install_headers('KHR/khrplatform.h', subdir : 'KHR') diff --git a/meson.build b/meson.build index 2dabd8188e2..a019e4d8d41 100644 --- a/meson.build +++ b/meson.build @@ -836,15 +836,23 @@ endif if with_gbm pre_args += '-DHAVE_DRM_PLATFORM' endif + +with_android_stub = get_option('android-stub') +if with_android_stub and not with_platform_android + error('`-D android-stub=true` makes no sense without `-D platforms=android`') +endif + if with_platform_android - dep_android = [ - dependency('cutils'), - dependency('hardware'), - dependency('sync'), - dependency('backtrace') - ] - if get_option('platform-sdk-version') >= 26 - dep_android += dependency('nativewindow') + if not with_android_stub + dep_android = [ + dependency('cutils'), + dependency('hardware'), + dependency('sync'), + dependency('backtrace') + ] + if get_option('platform-sdk-version') >= 26 + dep_android += dependency('nativewindow') + endif endif pre_args += '-DHAVE_ANDROID_PLATFORM' endif diff --git a/meson_options.txt b/meson_options.txt index ae0e7cc1d71..2d39d13b6ad 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -29,6 +29,13 @@ option( description : 'window systems to support. If this is set to `auto`, all platforms applicable will be enabled.' ) option( + 'android-stub', + type : 'boolean', + value : false, + description : 'Build against android-stub', +) + +option( 'dri3', type : 'combo', value : 'auto', diff --git a/src/android_stub/android_stub.cpp b/src/android_stub/android_stub.cpp new file mode 100644 index 00000000000..f31e3cc0c37 --- /dev/null +++ b/src/android_stub/android_stub.cpp @@ -0,0 +1,54 @@ +#include <cutils/properties.h> +#include <sync/sync.h> +#include <hardware/hardware.h> +#include <android/log.h> +#include <backtrace/Backtrace.h> + +extern "C" { + +int property_get(const char* key, char* value, const char* default_value) +{ + return 0; +} + +/* timeout in msecs */ +int sync_wait(int fd, int timeout) +{ + return 0; +} + +/* From hardware/hardware.h */ + +int hw_get_module(const char *id, const struct hw_module_t **module) +{ + return 0; +} + +/* From android/log.h */ + +int __android_log_print(int prio, const char* tag, const char* fmt, ...) +{ + return 0; +} + +int __android_log_vprint(int prio, const char* tag, const char* fmt, va_list ap) +{ + return 0; +} + +} + +/* From backtrace/Backtrace.h */ + +Backtrace* +Backtrace::Create(pid_t pid, pid_t tid, BacktraceMap* map) +{ + return NULL; +} + +std::string +backtrace_map_t::Name() const +{ + return ""; +} + diff --git a/src/android_stub/meson.build b/src/android_stub/meson.build new file mode 100644 index 00000000000..ad9abf50e03 --- /dev/null +++ b/src/android_stub/meson.build @@ -0,0 +1,12 @@ +if with_android_stub + _libmesa_android_stub = static_library( + 'mesa_android_stub', + files('android_stub.cpp'), + include_directories : inc_include, + gnu_symbol_visibility : 'hidden', + ) + + dep_android = declare_dependency( + link_with : _libmesa_android_stub, + ) +endif diff --git a/src/meson.build b/src/meson.build index 26a815d6a15..b16717193e9 100644 --- a/src/meson.build +++ b/src/meson.build @@ -53,6 +53,7 @@ if cc.get_id() == 'msvc' else idep_getopt = null_dep endif +subdir('android_stub') subdir('util') subdir('mapi') # TODO: opengl |