types.h

Go to the documentation of this file.

/*
 * This file is part of Anbox Platform SDK
 *
 * Copyright 2021 Canonical Ltd.
 *
 * 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 ANBOX_SDK_TYPES_H_
#define ANBOX_SDK_TYPES_H_
 
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
 
#include <linux/limits.h>
#include <linux/input.h>
 
#include <EGL/egl.h>
 
#define MAX_NAME_LENGTH 100
#define MAX_STRING_LENGTH 256
#define MAX_VHAL_AREA_NAME_LENGTH 32
 
#define ANBOX_PLATFORM_DESCRIPTOR_SECTION ".anbox_platform_descriptor_section"
 
typedef struct {
  uint32_t width;
 
  uint32_t height;
 
  uint32_t density;
} AnboxDisplaySpec;
 
typedef struct {
  uint32_t width;
 
  uint32_t height;
 
  uint32_t density;
 
  uint32_t fps;
} AnboxDisplaySpec2;
 
typedef enum {
    AUDIO_FORMAT_PCM_SUB_16_BIT          = 0x1,
    AUDIO_FORMAT_PCM_SUB_8_BIT           = 0x2,
    AUDIO_FORMAT_PCM_SUB_32_BIT          = 0x3,
    AUDIO_FORMAT_PCM_SUB_8_24_BIT        = 0x4,
    AUDIO_FORMAT_PCM_SUB_FLOAT           = 0x5,
    AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED   = 0x6,
} AnboxAudioPcmSubFormat;
 
/* The audio_format_*_sub_fmt_t declarations are not currently used */
 
typedef enum {
    AUDIO_FORMAT_INVALID             = 0xFFFFFFFFUL,
    AUDIO_FORMAT_DEFAULT             = 0,
    /* DO NOT CHANGE */
    AUDIO_FORMAT_PCM                 = 0x00000000UL,
 
    /* Aliases */
    /* note != AudioFormat.ENCODING_PCM_16BIT */
    AUDIO_FORMAT_PCM_16_BIT          = (AUDIO_FORMAT_PCM |
                                        AUDIO_FORMAT_PCM_SUB_16_BIT),
    /* note != AudioFormat.ENCODING_PCM_8BIT */
    AUDIO_FORMAT_PCM_8_BIT           = (AUDIO_FORMAT_PCM |
                                        AUDIO_FORMAT_PCM_SUB_8_BIT),
    AUDIO_FORMAT_PCM_32_BIT          = (AUDIO_FORMAT_PCM |
                                        AUDIO_FORMAT_PCM_SUB_32_BIT),
    AUDIO_FORMAT_PCM_8_24_BIT        = (AUDIO_FORMAT_PCM |
                                        AUDIO_FORMAT_PCM_SUB_8_24_BIT),
    AUDIO_FORMAT_PCM_FLOAT           = (AUDIO_FORMAT_PCM |
                                        AUDIO_FORMAT_PCM_SUB_FLOAT),
    AUDIO_FORMAT_PCM_24_BIT_PACKED   = (AUDIO_FORMAT_PCM |
                                        AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED),
} AnboxAudioFormat;
 
typedef enum {
  AUDIO_OUTPUT_STREAM = 0,
  AUDIO_INPUT_STREAM = 1,
} AnboxAudioStreamType;
 
struct AnboxAudioSpec {
  uint32_t freq;
  AnboxAudioFormat format;
  uint8_t channels;
  uint16_t samples;
};
 
struct AnboxBinderDevices {
  char framework[PATH_MAX];
  char hardware[PATH_MAX];
  char vendor[PATH_MAX];
};
 
typedef uintptr_t AnboxNativeHandle;
 
typedef enum {
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_UNKNOWN = 0,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_ARGB_8888 = 1,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_XRGB_8888 = 2,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_RGB_888 = 3,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_RGB_565 = 4,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_ABGR_8888 = 5,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_ABGR_16161616F = 6,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_RGBA_16F = ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_ABGR_16161616F,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_GR_88 = 7,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_ABGR_2101010 = 8,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_YUV_420 = 9,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_R_8 = 10,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_NV_12 = 11,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_XBGR_8888 = 12,
  ANBOX_GRAPHICS_BUFFER_PIXEL_FORMAT_YVU_420 = 13,
} AnboxGraphicsBufferPixelFormat;
 
typedef enum {
  ANBOX_GRAPHICS_BUFFER_USAGE_UNKNOWN = 0,
  ANBOX_GRAPHICS_BUFFER_USAGE_SCANOUT = (1 << 0),
  ANBOX_GRAPHICS_BUFFER_USAGE_RENDERING = (1 << 1),
  ANBOX_GRAPHICS_BUFFER_USAGE_WRITE = (1 << 2),
  ANBOX_GRAPHICS_BUFFER_USAGE_LINEAR = (1 << 3),
} AnboxGraphicsBufferUsage;
 
typedef struct {
  AnboxNativeHandle handle;
  uint32_t width;
  uint32_t height;
  uint32_t stride;
  uint32_t format;
} AnboxGraphicsBuffer;
 
#define ANBOX_GRAPHICS_BUFFER_MAX_PLANES 4
 
typedef struct {
  uint32_t width;
  uint32_t height;
  uint32_t format;
  uint64_t modifier;
  uint8_t num_planes;
  AnboxNativeHandle handle[ANBOX_GRAPHICS_BUFFER_MAX_PLANES];
  uint32_t stride[ANBOX_GRAPHICS_BUFFER_MAX_PLANES];
  uint32_t offset[ANBOX_GRAPHICS_BUFFER_MAX_PLANES];
} AnboxGraphicsBuffer2;
 
typedef struct {
  void (*callback)(void* user_data);
  void* user_data;
} AnboxCallback;
 
typedef enum : uint8_t {
  /* Unknown graphics implementation */
  ANBOX_GRAPHICS_IMPLEMENTATION_TYPE_UNKNOWN = 0,
  /* Host rendering on the Anbox side */
  ANBOX_GRAPHICS_IMPLEMENTATION_TYPE_HOST_RENDERING = 1,
  /* Direct rendering inside the Android container */
  ANBOX_GRAPHICS_IMPLEMENTATION_TYPE_DIRECT_RENDERING = 2,
} AnboxGraphicsImplementationType;
 
 
typedef enum {
  /* OpenGL ES 2.0 */
  ANBOX_GRAPHICS_OPENGL_ES_VERSION_2_0 = 0,
  /* OpenGL ES 3.0 */
  ANBOX_GRAPHICS_OPENGL_ES_VERSION_3_0 = 1,
  /* OpenGL ES 3.1 */
  ANBOX_GRAPHICS_OPENGL_ES_VERSION_3_1 = 2,
  /* OpenGL ES 3.2 */
  ANBOX_GRAPHICS_OPENGL_ES_VERSION_3_2 = 3,
} AnboxGraphicsOpenGLESVersion;
 
typedef enum {
  /* Vulkan is not supported */
  ANBOX_GRAPHICS_VULKAN_VERSION_UNSUPPORTED = 0,
  /* Vulkan 1.0 */
  ANBOX_GRAPHICS_VULKAN_VERSION_1_0 = 1,
  /* Vulkan 1.1 */
  ANBOX_GRAPHICS_VULKAN_VERSION_1_1 = 2,
  /* Vulkan 1.2 */
  ANBOX_GRAPHICS_VULKAN_VERSION_1_2 = 3,
  /* Vulkan 1.3 */
  ANBOX_GRAPHICS_VULKAN_VERSION_1_3 = 4,
} AnboxGraphicsVulkanVersion;
 
typedef struct {
  /*
   * Name of the vendor whichs OpenGL ES implementation Android should use. Value
   * will be set to the `ro.hardware.egl` Android system property.
   */
  char gl_vendor[MAX_NAME_LENGTH];
 
  /* Maximum OpenGL ES version supported, see AnboxGraphicsOpenGLESVersion */
  uint32_t gl_version;
 
  /*
   * Name of the vendor whichs Vulkan implementation Android should use. Value will
   * be set to the `ro.hardware.vulkan` Android system property.
   */
  char vulkan_vendor[MAX_NAME_LENGTH];
 
  /* Maximum Vulkan version supported, see AnboxGraphicsVulkanVersion */
  uint32_t vulkan_version;
 
  /*
   * Name of the gralloc implementation Android should use. Value will be set to the
   * `ro.hardware.gralloc` Android system property.
   */
  char gralloc_vendor[MAX_NAME_LENGTH];
} AnboxDirectGraphicsConfiguration;
 
/*
 * @brief Defines the type of the value stored for a configuration item described by
 * AnboxPlatformConfigurationItemInfo
 */
typedef enum {
  /* boolean value, represented as 8 bit unsigned integer type (uint8_t) where 0 = false and > 0 = true */
  BOOLEAN,
} AnboxPlatformConfigurationItemValueType;
 
/*
 * @brief AnboxPlatformConfigurationItemInfo describes a single platform configuration item
 *
 * It allows the platform to define a set of configuration items which will remain transparent
 * to Anbox but can be changed through it's /1.0/platform HTTP API endpoint at runtime.
 */
typedef struct {
  /* ID of the configuration item, must be >= PLATFORM_CONFIGURATION_ID_START and <= PLATFORM_CONFIGURATION_ID_END */
  int id;
  /* Name of the configuration item */
  char name[MAX_NAME_LENGTH];
  /* Type of the value the configuration item stores */
  AnboxPlatformConfigurationItemValueType type;
} AnboxPlatformConfigurationItemInfo;
 
/*
 * @brief AnboxPlatformConfigurationInfo describes a set of platform specific
 * configuration items.
 *
 * Anbox will query the platform for available configuration items and make
 * them accessible through its /1.0/platform HTTP API endpoint. This allows
 * runtime configuration of the platform.
 */
typedef struct {
  /* Number of available configuration items */
  uint16_t num_items;
  /* Available configuration items or NULL if none are available */
  AnboxPlatformConfigurationItemInfo **items;
} AnboxPlatformConfigurationInfo;
 
typedef struct {
  /* Number of Android system properties required by a platform*/
  uint16_t size;
  /* Array of Android system properties */
  const char** properties;
} AnboxAndroidSystemProperties;
 
typedef enum {
  EGL_DRIVER_PATH = 0,
 
  OPENGL_ES1_CM_DRIVER_PATH = 1,
 
  OPENGL_ES2_DRIVER_PATH = 2,
 
  DISPLAY_SPEC = 3,
 
  AUDIO_SPEC = 4,
 
  DISPLAY_SPEC2 = 5,
 
  AUDIO_INPUT_SPEC = 6,
 
  BINDER_DEVICES = 7,
 
  /*
   * List of supported video codecs supported by the video decoder implemented
   * by the platform.
   *
   * Anbox will instruct it's HAL layer on the Android side to only exposed
   * support for the codecs listed.
   *
   * The value of this configuration item is of type AnboxVideoCodecType[]
   */
  SUPPORTED_VIDEO_DECODE_CODECS = 8,
 
  /*
   * The graphics implementation type defines how graphics acceleration will be
   * provided to the Android container.
   *
   * Anbox supports different ways of exposing graphic acceleration to the Android
   * container. Graphics acceleration can either be provided through a translation
   * layer where all access to the GPU happens on the Anbox side and Android has
   * no direct access to the GPU. Alternatively Android can get direct GPU access
   * and perform all graphics acceleration directly.
   *
   * If not provided by a platform implementation, Anbox will default to
   * ANBOX_GRAPHICS_IMPLEMENTATION_TYPE_HOST_RENDERING
   *
   * The value of this configuration item is of type `AnboxGraphicsImplementationType`
   */
  GRAPHICS_IMPLEMENTATION_TYPE = 9,
 
  /*
   * Configuration details for direct graphics acceleration
   *
   * The platform can further detail on how nativ graphics acceleration will be
   * made available inside the Android container. This allows defining GL/Vulkan
   * driver implementation names and other things.
   *
   * The value of this configuration item is of type `AnboxDirectGraphicsConfiguration`
   */
  DIRECT_GRAPHICS_CONFIGURATION = 10,
 
  /*
   * Information about platform specific configuration options
   *
   * The value of this configuration is of type AnboxPlatformConfigurationInfo
   */
  PLATFORM_CONFIGURATION_INFO = 11,
 
  /*
   * Base uid used in the Android contaienr
   *
   * The value of this configuration item is of type `uint32_t`.
   */
  CONTAINER_BASE_UID = 12,
 
  /*
   * Path to Vulkan ICD to be used for host side rendering
   *
   * The value of this configuration item is of type `const char*`
   */
  VULKAN_ICD_PATH = 13,
 
  /*
   * Path to the DRM render node Anbox should use for host side
   * rendering.
   *
   * The value of this configuration item is of type `const char*`
   */
  DRM_RENDER_NODE_PATH = 14,
 
  /*
   * Whether the platform requires support for sw sync primitives or not.
   *
   * The value of this configuration item is of type `uint8_t` which
   * represents a boolean value, encoded as 8 bit unsigned integer type
   * (uint8_t) where 0 = false and > 0 = true
   */
  ENABLE_SW_SYNC_SUPPORT = 15,
 
  /*
   * Android system properties required to forward to Android container
   *
   * The value of this configuration item is of type `AnboxAndroidSystemProperties`
   */
  ANDROID_SYSTEM_PROPERTIES = 16,
 
  /*
   * The API defines a range of platform specific configuration items which can be
   * dynamically exposed by the platform. PLATFORM_CONFIGURATION_START specifies
   * the first configuration item id.
   */
  PLATFORM_CONFIGURATION_ID_START = 1000,
 
  /*
   * The API defines a range of platform specific configuration items which can be
   * dynamically exposed by the platform. PLATFORM_CONFIGURATION_END specifies
   * the last configuration item id.
   */
  PLATFORM_CONFIGURATION_ID_END = 1999,
} AnboxPlatformConfigurationKey;
 
struct AnboxPlatformConfiguration {
  uint32_t android_api_level;
 
  /*
   * A pointer to a null-terminated ('\0') string containing additional configuration
   * data used by the platform during initialization or NULL if no additional
   * configuration data is available.
   */
  const char* extra_config_data;
};
 
struct AnboxPlatformDescriptor {
  const char name[MAX_STRING_LENGTH];
  const char vendor[MAX_STRING_LENGTH];
  const char description[MAX_STRING_LENGTH];
  uint32_t platform_version;
};
 
typedef enum {
  ANBOX_EVENT_TYPE_ANDROID_BOOT_FINISHED = 0,
  ANBOX_EVENT_TYPE_INITIALIZATION_FINISHED,
  ANBOX_EVENT_TYPE_TERMINATING,
} AnboxEventType;
 
typedef enum {
  PORTRAIT = 0,
  LANDSCAPE,
  PORTRAIT_REVERSED,
  LANDSCAPE_REVERSED,
} AnboxScreenOrientationType;
 
typedef enum {
 VIDEO_FRAME_FORMAT_UNKNOWN = 0,
 VIDEO_FRAME_FORMAT_YUV420,
 VIDEO_FRAME_FORMAT_RGBA,
} AnboxVideoColorSpaceFormat;
 
typedef enum {
  CAMERA_ORIENTATION_PORTRAIT = 0,
  CAMERA_ORIENTATION_LANDSCAPE = 1,
} AnboxCameraOrientation;
 
typedef enum {
  CAMERA_FACING_MODE_FRONT = 0,
  CAMERA_FACING_MODE_REAR = 1,
} AnboxCameraFacingMode;
 
struct AnboxCameraSpec {
 AnboxVideoColorSpaceFormat format;
 AnboxCameraFacingMode facing_mode;
 uint32_t fps;
 uint32_t width;
 uint32_t height;
};
 
struct AnboxVideoFrame {
 uint8_t* data;
 size_t size;
};
 
#define GNSS_MAX_MEASUREMENT 64
 
typedef int64_t GpsUtcTime;
 
typedef enum : uint8_t {
  UNKNOWN = 0,
  GPS     = 1,
  SBAS    = 2,
  GLONASS = 3,
  QZSS    = 4,
  BEIDOU  = 5,
  GALILEO = 6,
} GnssConstellationType;
 
typedef enum : uint32_t {
  STATE_UNKNOWN                = 0,
  STATE_CODE_LOCK              = 1 << 0,
  STATE_BIT_SYNC               = 1 << 1,
  STATE_SUBFRAME_SYNC          = 1 << 2,
  STATE_TOW_DECODED            = 1 << 3,
  STATE_MSEC_AMBIGUOUS         = 1 << 4,
  STATE_SYMBOL_SYNC            = 1 << 5,
  STATE_GLO_STRING_SYNC        = 1 << 6,
  STATE_GLO_TOD_DECODED        = 1 << 7,
  STATE_BDS_D2_BIT_SYNC        = 1 << 8,
  STATE_BDS_D2_SUBFRAME_SYNC   = 1 << 9,
  STATE_GAL_E1BC_CODE_LOCK     = 1 << 10,
  STATE_GAL_E1C_2ND_CODE_LOCK  = 1 << 11,
  STATE_GAL_E1B_PAGE_SYNC      = 1 << 12,
  STATE_SBAS_SYNC              = 1 << 13,
  STATE_TOW_KNOWN              = 1 << 14,
  STATE_GLO_TOD_KNOWN          = 1 << 15,
} GnssMeasurementState;
 
typedef enum : uint16_t {
  HAS_LEAP_SECOND        = 1 << 0,
  HAS_TIME_UNCERTAINTY   = 1 << 1,
  HAS_FULL_BIAS          = 1 << 2,
  HAS_BIAS               = 1 << 3,
  HAS_BIAS_UNCERTAINTY   = 1 << 4,
  HAS_DRIFT              = 1 << 5,
  HAS_DRIFT_UNCERTAINTY  = 1 << 6
} GnssClockFlags;
 
struct GnssMeasurement {
  int16_t svid;
 
  GnssConstellationType constellation;
 
  GnssMeasurementState state;
 
  int64_t received_sv_time_in_ns;
 
  int64_t received_sv_time_uncertainty_in_ns;
 
  double c_n0_dbhz;
 
  double pseudorange_rate_mps;
 
  double pseudorange_rate_uncertainty_mps;
 
  float carrier_frequency_hz;
};
 
struct GnssClock {
  int64_t time_ns;
 
  int64_t full_bias_ns;
 
  double bias_ns;
 
  double bias_uncertainty_ns;
 
  double drift_nsps;
 
  double drift_uncertainty_nsps;
 
  uint32_t hw_clock_discontinuity_count;
 
  GnssClockFlags flags;
};
struct AnboxGGAData {
  GpsUtcTime      time;
  double          latitude;
  char            latitudeHemi;
  double          longitude;
  char            longitudeHemi;
  double          altitude;
  char            altitudeUnit;
  float           horizontalAccuracy;
  float           verticalAccuracy;
};
 
struct AnboxRMCData {
  GpsUtcTime      time;
  char            status;
  double          latitude;
  char            latitudeHemi;
  double          longitude;
  char            longitudeHemi;
  float           speed;
  float           bearing;
  GpsUtcTime      date;
  float           horizontalAccuracy;
  float           verticalAccuracy;
};
 
struct AnboxGnssData {
  GnssClock clock;
 
  size_t measurement_count;
 
  GnssMeasurement measurements[GNSS_MAX_MEASUREMENT];
};
 
 
typedef enum : uint32_t {
  Unknown = 1 << 0,
  GGA     = 1 << 1,
  RMC     = 1 << 2,
  GNSSv1  = 1 << 3,
} AnboxGpsDataType;
 
struct AnboxGpsData {
  AnboxGpsDataType data_type;
  union {
    AnboxGGAData gga_data;
    AnboxRMCData rmc_data;
    AnboxGnssData  gnss_data;
  };
};
 
typedef enum {
  FLIP_MODE_NONE = 0,
  FLIP_MODE_VERTICAL = 1,
  FLIP_MODE_HORIZONTAL = 2,
} AnboxGraphicsFlipMode;
 
typedef enum {
  TEXTURE_FORMAT_RGBA = 0,
  TEXTURE_FORMAT_BGRA = 1,
} AnboxGraphicsTextureFormat;
 
typedef struct {
  EGLNativeDisplayType native_display;
 
  EGLNativeWindowType native_window;
 
  AnboxGraphicsFlipMode output_flip_mode;
 
  AnboxGraphicsTextureFormat texture_format;
 
  bool avoid_pbuffers;
} AnboxGraphicsConfiguration;
 
typedef enum {
  POINTER = 0,
  KEYBOARD,
  TOUCHPANEL,
  GAMEPAD,
} AnboxInputDeviceType;
 
struct AnboxInputEvent {
  AnboxInputDeviceType device_type;
  int32_t device_id;
  uint16_t type;
  uint16_t code;
  int32_t value;
};
 
#define MAX_SENSOR_DATA_LENGTH 16
#define MAX_VECTOR_DATA_LENGTH 3
 
typedef enum : uint32_t {
  NONE = 0,
  ACCELERATION  = 1 << 0,
  GYROSCOPE     = 1 << 1,
  MAGNETOMETER  = 1 << 2,
  ORIENTATION   = 1 << 3,
  TEMPERATURE   = 1 << 4,
  PROXIMITY     = 1 << 5,
  LIGHT         = 1 << 6,
  PRESSURE      = 1 << 7,
  HUMIDITY      = 1 << 8,
} AnboxSensorType;
 
struct AnboxSensorVector {
  union {
    float v[MAX_VECTOR_DATA_LENGTH];
    struct {
      float x;
      float y;
      float z;
    } axis;
    struct {
      float azimuth;
      float pitch;
      float roll;
    } angle;
  };
};
 
struct AnboxSensorData {
  AnboxSensorType sensor_type;
  union {
    float  values[MAX_SENSOR_DATA_LENGTH];
    AnboxSensorVector acceleration;
    AnboxSensorVector gyroscope;
    AnboxSensorVector orientation;
    AnboxSensorVector magnetic;
    float           temperature;
    float           proximity;
    float           light;
    float           pressure;
    float           humidity;
  };
};
 
typedef enum {
  ANBOX_VHAL_PROPERTY_STATUS_AVAILABLE   = 0x0,
  ANBOX_VHAL_PROPERTY_STATUS_UNAVAILABLE = 0x1,
  ANBOX_VHAL_PROPERTY_STATUS_ERROR       = 0x2,
} AnboxVhalPropertyStatus;
 
typedef enum {
  ANBOX_VHAL_PROPERTY_TYPE_STRING    = 0x00100000,
  ANBOX_VHAL_PROPERTY_TYPE_BOOLEAN   = 0x00200000,
  ANBOX_VHAL_PROPERTY_TYPE_INT32     = 0x00400000,
  ANBOX_VHAL_PROPERTY_TYPE_INT32_VEC = 0x00410000,
  ANBOX_VHAL_PROPERTY_TYPE_INT64     = 0x00500000,
  ANBOX_VHAL_PROPERTY_TYPE_INT64_VEC = 0x00510000,
  ANBOX_VHAL_PROPERTY_TYPE_FLOAT     = 0x00600000,
  ANBOX_VHAL_PROPERTY_TYPE_FLOAT_VEC = 0x00610000,
  ANBOX_VHAL_PROPERTY_TYPE_BYTES     = 0x00700000,
  ANBOX_VHAL_PROPERTY_TYPE_MIXED     = 0x00e00000,
} AnboxVhalPropertyType;
 
typedef enum {
  ANBOX_VHAL_PROPERTY_ACCESS_NONE       = 0x00,
  ANBOX_VHAL_PROPERTY_ACCESS_READ       = 0x01,
  ANBOX_VHAL_PROPERTY_ACCESS_WRITE      = 0x02,
  ANBOX_VHAL_PROPERTY_ACCESS_READ_WRITE = 0x03,
} AnboxVhalPropertyAccess;
 
typedef enum {
  ANBOX_VHAL_PROPERTY_CHANGE_MODE_STATIC     = 0x00,
  ANBOX_VHAL_PROPERTY_CHANGE_MODE_ON_CHANGE  = 0x01,
  ANBOX_VHAL_PROPERTY_CHANGE_MODE_CONTINUOUS = 0x02,
} AnboxVhalPropertyChangeMode;
 
struct AnboxVhalPropertyValue {
  int64_t timestamp;
  int32_t area_id;
  int32_t prop;
  AnboxVhalPropertyStatus status;
  uint32_t int32_values_size;
  int32_t* int32_values;
  uint32_t float_values_size;
  float* float_values;
  uint32_t int64_values_size;
  int64_t* int64_values;
  uint32_t bytes_size;
  uint8_t* bytes;
  uint32_t string_value_size;
  char* string_value;
};
 
struct AnboxVhalAreaConfig {
  int32_t area_id;
  int32_t min_int32_value;
  int32_t max_int32_value;
  int64_t min_int64_value;
  int64_t max_int64_value;
  float min_float_value;
  float max_float_value;
  uint32_t area_names_size;
  char (*area_names)[MAX_VHAL_AREA_NAME_LENGTH];
};
 
struct AnboxVhalPropertyConfig {
  int32_t prop;
  AnboxVhalPropertyType value_type;
  AnboxVhalPropertyAccess access;
  AnboxVhalPropertyChangeMode change_mode;
  uint32_t area_configs_size;
  AnboxVhalAreaConfig* area_configs;
  uint32_t config_array_size;
  int32_t* config_array;
  uint32_t config_string_size;
  char* config_string;
  float min_sample_rate;
  float max_sample_rate;
  uint32_t prop_name_size;
  char* prop_name;
};
 
typedef enum {
  ANBOX_VHAL_ANSWER_STATUS_OK = 0,
  ANBOX_VHAL_ANSWER_STATUS_INVALID = 1,
  ANBOX_VHAL_ANSWER_STATUS_UNKNOWN = 2,
} AnboxVhalAnswerStatus;
 
struct AnboxVhalAnswerGetConfigs {
  uint32_t configs_size;
  AnboxVhalPropertyConfig* configs;
};
 
struct AnboxVhalCommandGet {
  int32_t prop_id;
  int32_t area_id;
  uint32_t int32_values_size;
  int32_t* int32_values;
  uint32_t float_values_size;
  float* float_values;
  uint32_t int64_values_size;
  int64_t* int64_values;
  uint32_t bytes_size;
  uint8_t* bytes;
  uint32_t string_value_size;
  char* string_value;
};
 
struct AnboxVhalCommandSet {
  int32_t prop_id;
  int32_t area_id;
  AnboxVhalPropertyStatus status;
  uint32_t int32_values_size;
  int32_t* int32_values;
  uint32_t float_values_size;
  float* float_values;
  uint32_t int64_values_size;
  int64_t* int64_values;
  uint32_t bytes_size;
  uint8_t* bytes;
  uint32_t string_value_size;
  char* string_value;
};
 
typedef enum : uint8_t {
  ANBOX_VIDEO_CODEC_TYPE_UNKNOWN = 0,
  /* H.264 / AVC */
  ANBOX_VIDEO_CODEC_TYPE_H264 = 1,
} AnboxVideoCodecType;
 
typedef enum : uint8_t {
  ANBOX_VIDEO_PIXEL_FORMAT_UNKNOWN = 0,
  /* YUV420P */
  ANBOX_VIDEO_PIXEL_FORMAT_YUV420P = 1,
} AnboxVideoPixelFormat;
 
struct AnboxVideoDecoderConfig {
  /* Target output width */
  uint32_t width = 0;
  /* Target output height */
  uint32_t height = 0;
  /* Expected output pixel format */
  AnboxVideoPixelFormat output_format = ANBOX_VIDEO_PIXEL_FORMAT_UNKNOWN;
};
 
struct AnboxVideoImage {
  /* Pixel format of the image */
  AnboxVideoPixelFormat pixel_format = ANBOX_VIDEO_PIXEL_FORMAT_UNKNOWN;
  /* Width of the image */
  uint32_t width = 0;
  /* Height of the image */
  uint32_t height = 0;
  /* Presentation timestmap of the image in milliseconds */
  int64_t pts = 0;
  /* Color matrix coefficients of the image as defined in E.2.1 (VUI parameters semantics) of the H264 specification */
  uint8_t color_matrix = 0;
  /* Color primaries of the image as defined in E.2.1 (VUI parameters semantics) of the H264 specification */
  uint8_t color_primaries = 0;
  /* Color transfer of the image as defined in E.2.1 (VUI parameters semantics) of the H264 specification */
  uint8_t color_transfer = 0;
  /* Color range of the image as defined in E.2.1 (VUI parameters semantics) of the H264 specification */
  uint8_t color_range = 0;
  /* Size of the image data */
  uint64_t size = 0;
  /* Data of the image */
  uint8_t* data = nullptr;
};
 
typedef const unsigned char* (*AnboxTracerGetCategoryEnabledFunc)(const char* name);
 
typedef enum {
  ANBOX_TRACE_EVENT_PHASE_BEGIN = 'B',
  ANBOX_TRACE_EVENT_PHASE_END = 'E',
  ANBOX_TRACE_EVENT_PHASE_INSTANT = 'I',
  ANBOX_TRACE_EVENT_PHASE_COUNTER = 'C',
} AnboxTraceEventPhase;
 
 
typedef enum {
  ANBOX_TRACE_EVENT_ARG_TYPE_BOOL = 1,
  ANBOX_TRACE_EVENT_ARG_TYPE_UINT = 2,
  ANBOX_TRACE_EVENT_ARG_TYPE_INT = 3,
  ANBOX_TRACE_EVENT_ARG_TYPE_DOUBLE = 4,
  ANBOX_TRACE_EVENT_ARG_TYPE_POINTER = 5,
  ANBOX_TRACE_EVENT_ARG_TYPE_STRING = 6,
  ANBOX_TRACE_EVENT_ARG_TYPE_COPY_STRING = 7,
} AnboxTraceEventArgType;
 
typedef void (*AnboxTracerAddEventFunc)(
  char phase,
  const unsigned char* category,
  const char* name,
  unsigned long long id,
  int num_args,
  const char** arg_names,
  const unsigned char* arg_types,
  const unsigned long long* arg_values,
  unsigned char flags);
 
#endif