src/modules/coregl_tracepath_egl.c

   1 #include "coregl_tracepath.h"
   2
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <sys/time.h>
   6
   7 #include <sys/types.h>
   8 #include <unistd.h>
   9 #include <inttypes.h>
  10
  11 Mutex ctx_access_mutex = MUTEX_INITIALIZER;
  12 Ctx_Data *ctx_data = NULL;
  13
  14 static char *_get_value(EGLint key)
  15 {
  16         switch(key) {
  17                 case 0x0000: return "EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR";
  18                 case 0x0001: return "EGL_TRUE";
  19                 case 0x2097: return "EGL_CONTEXT_RELEASE_BEHAVIOR_KHR";
  20                 case 0x2098: return "EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR";
  21                 case 0x2710: return "EGL_DISPLAY_SCALING";
  22                 case 0x3000: return "EGL_SUCCESS";
  23                 case 0x3001: return "EGL_NOT_INITIALIZED";
  24                 case 0x3002: return "EGL_BAD_ACCESS";
  25                 case 0x3003: return "EGL_BAD_ALLOC";
  26                 case 0x3004: return "EGL_BAD_ATTRIBUTE";
  27                 case 0x3005: return "EGL_BAD_CONFIG";
  28                 case 0x3006: return "EGL_BAD_CONTEXT";
  29                 case 0x3007: return "EGL_BAD_CURRENT_SURFACE";
  30                 case 0x3008: return "EGL_BAD_DISPLAY";
  31                 case 0x3009: return "EGL_BAD_MATCH";
  32                 case 0x300a: return "EGL_BAD_NATIVE_PIXMAP";
  33                 case 0x300b: return "EGL_BAD_NATIVE_WINDOW";
  34                 case 0x300c: return "EGL_BAD_PARAMETER";
  35                 case 0x300d: return "EGL_BAD_SURFACE";
  36                 case 0x300e: return "EGL_CONTEXT_LOST";
  37                 case 0x3020: return "EGL_BUFFER_SIZE";
  38                 case 0x3021: return "EGL_ALPHA_SIZE";
  39                 case 0x3022: return "EGL_BLUE_SIZE";
  40                 case 0x3023: return "EGL_GREEN_SIZE";
  41                 case 0x3024: return "EGL_RED_SIZE";
  42                 case 0x3025: return "EGL_DEPTH_SIZE";
  43                 case 0x3026: return "EGL_STENCIL_SIZE";
  44                 case 0x3027: return "EGL_CONFIG_CAVEAT";
  45                 case 0x3028: return "EGL_CONFIG_ID";
  46                 case 0x3029: return "EGL_LEVEL";
  47                 case 0x302a: return "EGL_MAX_PBUFFER_HEIGHT";
  48                 case 0x302b: return "EGL_MAX_PBUFFER_PIXELS";
  49                 case 0x302c: return "EGL_MAX_PBUFFER_WIDTH";
  50                 case 0x302d: return "EGL_NATIVE_RENDERABLE";
  51                 case 0x302e: return "EGL_NATIVE_VISUAL_ID";
  52                 case 0x302f: return "EGL_NATIVE_VISUAL_TYPE";
  53                 case 0x3031: return "EGL_SAMPLES";
  54                 case 0x3032: return "EGL_SAMPLE_BUFFERS";
  55                 case 0x3033: return "EGL_SURFACE_TYPE";
  56                 case 0x3034: return "EGL_TRANSPARENT_TYPE";
  57                 case 0x3035: return "EGL_TRANSPARENT_BLUE_VALUE";
  58                 case 0x3036: return "EGL_TRANSPARENT_GREEN_VALUE";
  59                 case 0x3037: return "EGL_TRANSPARENT_RED_VALUE";
  60                 case 0x3038: return "EGL_NONE";
  61                 case 0x3039: return "EGL_BIND_TO_TEXTURE_RGB";
  62                 case 0x303a: return "EGL_BIND_TO_TEXTURE_RGBA";
  63                 case 0x303b: return "EGL_MIN_SWAP_INTERVAL";
  64                 case 0x303c: return "EGL_MAX_SWAP_INTERVAL";
  65                 case 0x303d: return "EGL_LUMINANCE_SIZE";
  66                 case 0x303e: return "EGL_ALPHA_MASK_SIZE";
  67                 case 0x303f: return "EGL_COLOR_BUFFER_TYPE";
  68                 case 0x3040: return "EGL_RENDERABLE_TYPE";
  69                 case 0x3041: return "EGL_MATCH_NATIVE_PIXMAP";
  70                 case 0x3042: return "EGL_CONFORMANT";
  71                 case 0x3043: return "EGL_MATCH_FORMAT_KHR";
  72                 case 0x3050: return "EGL_SLOW_CONFIG";
  73                 case 0x3051: return "EGL_NON_CONFORMANT_CONFIG";
  74                 case 0x3052: return "EGL_TRANSPARENT_RGB";
  75                 case 0x3053: return "EGL_VENDOR";
  76                 case 0x3054: return "EGL_VERSION";
  77                 case 0x3055: return "EGL_EXTENSIONS";
  78                 case 0x3056: return "EGL_HEIGHT";
  79                 case 0x3057: return "EGL_WIDTH";
  80                 case 0x3058: return "EGL_LARGEST_PBUFFER";
  81                 case 0x3059: return "EGL_DRAW";
  82                 case 0x305a: return "EGL_READ";
  83                 case 0x305b: return "EGL_CORE_NATIVE_ENGINE";
  84                 case 0x305c: return "EGL_NO_TEXTURE";
  85                 case 0x305d: return "EGL_TEXTURE_RGB";
  86                 case 0x305e: return "EGL_TEXTURE_RGBA";
  87                 case 0x305f: return "EGL_TEXTURE_2D";
  88                 case 0x307f: return "EGL_Y_INVERTED_NOK";
  89                 case 0x3080: return "EGL_TEXTURE_FORMAT";
  90                 case 0x3081: return "EGL_TEXTURE_TARGET";
  91                 case 0x3082: return "EGL_MIPMAP_TEXTURE";
  92                 case 0x3083: return "EGL_MIPMAP_LEVEL";
  93                 case 0x3084: return "EGL_BACK_BUFFER";
  94                 case 0x3085: return "EGL_SINGLE_BUFFER";
  95                 case 0x3086: return "EGL_RENDER_BUFFER";
  96                 case 0x3087: return "EGL_COLORSPACE";
  97                 case 0x3088: return "EGL_ALPHA_FORMAT";
  98                 case 0x3089: return "EGL_COLORSPACE_sRGB";
  99                 case 0x308a: return "EGL_COLORSPACE_LINEAR";
 100                 case 0x308b: return "EGL_ALPHA_FORMAT_NONPRE";
 101                 case 0x308c: return "EGL_ALPHA_FORMAT_PRE";
 102                 case 0x308d: return "EGL_CLIENT_APIS";
 103                 case 0x308e: return "EGL_RGB_BUFFER";
 104                 case 0x308f: return "EGL_LUMINANCE_BUFFER";
 105                 case 0x3090: return "EGL_HORIZONTAL_RESOLUTION";
 106                 case 0x3091: return "EGL_VERTICAL_RESOLUTION";
 107                 case 0x3092: return "EGL_PIXEL_ASPECT_RATIO";
 108                 case 0x3093: return "EGL_SWAP_BEHAVIOR";
 109                 case 0x3094: return "EGL_BUFFER_PRESERVED";
 110                 case 0x3095: return "EGL_BUFFER_DESTROYED";
 111                 case 0x3096: return "EGL_OPENVG_IMAGE";
 112                 case 0x3097: return "EGL_CONTEXT_CLIENT_TYPE";
 113                 case 0x3098: return "EGL_CONTEXT_CLIENT_VERSION";
 114                 case 0x3099: return "EGL_MULTISAMPLE_RESOLVE";
 115                 case 0x309a: return "EGL_MULTISAMPLE_RESOLVE_DEFAULT";
 116                 case 0x309b: return "EGL_MULTISAMPLE_RESOLVE_BOX";
 117                 case 0x309c: return "EGL_CL_EVENT_HANDLE";
 118                 case 0x309d: return "EGL_GL_COLORSPACE";
 119                 case 0x30a0: return "EGL_OPENGL_ES_API";
 120                 case 0x30a1: return "EGL_OPENVG_API";
 121                 case 0x30a2: return "EGL_OPENGL_API";
 122                 case 0x30b0: return "EGL_NATIVE_PIXMAP_KHR";
 123                 case 0x30b1: return "EGL_GL_TEXTURE_2D";
 124                 case 0x30b2: return "EGL_GL_TEXTURE_3D";
 125                 case 0x30b3: return "EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X";
 126                 case 0x30b4: return "EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X";
 127                 case 0x30b5: return "EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y";
 128                 case 0x30b6: return "EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y";
 129                 case 0x30b7: return "EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z";
 130                 case 0x30b8: return "EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z";
 131                 case 0x30b9: return "EGL_GL_RENDERBUFFER";
 132                 case 0x30ba: return "EGL_VG_PARENT_IMAGE_KHR";
 133                 case 0x30bc: return "EGL_GL_TEXTURE_LEVEL";
 134                 case 0x30bd: return "EGL_GL_TEXTURE_ZOFFSET";
 135                 case 0x30be: return "EGL_POST_SUB_BUFFER_SUPPORTED_NV";
 136                 case 0x30bf: return "EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT";
 137                 case 0x30c0: return "EGL_FORMAT_RGB_565_EXACT_KHR";
 138                 case 0x30c1: return "EGL_FORMAT_RGB_565_KHR";
 139                 case 0x30c2: return "EGL_FORMAT_RGBA_8888_EXACT_KHR";
 140                 case 0x30c3: return "EGL_FORMAT_RGBA_8888_KHR";
 141                 case 0x30c4: return "EGL_MAP_PRESERVE_PIXELS_KHR";
 142                 case 0x30c5: return "EGL_LOCK_USAGE_HINT_KHR";
 143                 case 0x30c6: return "EGL_BITMAP_POINTER_KHR";
 144                 case 0x30c7: return "EGL_BITMAP_PITCH_KHR";
 145                 case 0x30c8: return "EGL_BITMAP_ORIGIN_KHR";
 146                 case 0x30c9: return "EGL_BITMAP_PIXEL_RED_OFFSET_KHR";
 147                 case 0x30ca: return "EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR";
 148                 case 0x30cb: return "EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR";
 149                 case 0x30cc: return "EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR";
 150                 case 0x30cd: return "EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR";
 151                 case 0x30ce: return "EGL_LOWER_LEFT_KHR";
 152                 case 0x30cf: return "EGL_UPPER_LEFT_KHR";
 153                 case 0x30d2: return "EGL_IMAGE_PRESERVED";
 154                 case 0x30da: return "EGL_SHARED_IMAGE_NOK";
 155                 case 0x30e0: return "EGL_COVERAGE_BUFFERS_NV";
 156                 case 0x30e1: return "EGL_COVERAGE_SAMPLES_NV";
 157                 case 0x30e2: return "EGL_DEPTH_ENCODING_NV";
 158                 case 0x30e3: return "EGL_DEPTH_ENCODING_NONLINEAR_NV";
 159                 case 0x30e6: return "EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV";
 160                 case 0x30e7: return "EGL_SYNC_STATUS_NV";
 161                 case 0x30e8: return "EGL_SIGNALED_NV";
 162                 case 0x30e9: return "EGL_UNSIGNALED_NV";
 163                 case 0x30ea: return "EGL_ALREADY_SIGNALED_NV";
 164                 case 0x30eb: return "EGL_TIMEOUT_EXPIRED_NV";
 165                 case 0x30ec: return "EGL_CONDITION_SATISFIED_NV";
 166                 case 0x30ed: return "EGL_SYNC_TYPE_NV";
 167                 case 0x30ee: return "EGL_SYNC_CONDITION_NV";
 168                 case 0x30ef: return "EGL_SYNC_FENCE_NV";
 169                 case 0x30f0: return "EGL_SYNC_PRIOR_COMMANDS_COMPLETE";
 170                 case 0x30f1: return "EGL_SYNC_STATUS";
 171                 case 0x30f2: return "EGL_SIGNALED";
 172                 case 0x30f3: return "EGL_UNSIGNALED";
 173                 case 0x30f5: return "EGL_TIMEOUT_EXPIRED";
 174                 case 0x30f6: return "EGL_CONDITION_SATISFIED";
 175                 case 0x30f7: return "EGL_SYNC_TYPE";
 176                 case 0x30f8: return "EGL_SYNC_CONDITION";
 177                 case 0x30f9: return "EGL_SYNC_FENCE";
 178                 case 0x30fa: return "EGL_SYNC_REUSABLE_KHR";
 179                 case 0x30fb: return "EGL_CONTEXT_MINOR_VERSION";
 180                 case 0x30fc: return "EGL_CONTEXT_FLAGS_KHR";
 181                 case 0x30fd: return "EGL_CONTEXT_OPENGL_PROFILE_MASK";
 182                 case 0x30fe: return "EGL_SYNC_CL_EVENT";
 183                 case 0x30ff: return "EGL_SYNC_CL_EVENT_COMPLETE";
 184                 case 0x3100: return "EGL_CONTEXT_PRIORITY_LEVEL_IMG";
 185                 case 0x3101: return "EGL_CONTEXT_PRIORITY_HIGH_IMG";
 186                 case 0x3102: return "EGL_CONTEXT_PRIORITY_MEDIUM_IMG";
 187                 case 0x3103: return "EGL_CONTEXT_PRIORITY_LOW_IMG";
 188                 case 0x3105: return "EGL_NATIVE_BUFFER_MULTIPLANE_SEPARATE_IMG";
 189                 case 0x3106: return "EGL_NATIVE_BUFFER_PLANE_OFFSET_IMG";
 190                 case 0x3110: return "EGL_BITMAP_PIXEL_SIZE_KHR";
 191                 case 0x3131: return "EGL_COVERAGE_SAMPLE_RESOLVE_NV";
 192                 case 0x3132: return "EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV";
 193                 case 0x3133: return "EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV";
 194                 case 0x3134: return "EGL_MULTIVIEW_VIEW_COUNT_EXT";
 195                 case 0x3136: return "EGL_AUTO_STEREO_NV";
 196                 case 0x3138: return "EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT";
 197                 case 0x313d: return "EGL_BUFFER_AGE_KHR";
 198                 case 0x313f: return "EGL_PLATFORM_DEVICE_EXT";
 199                 case 0x3140: return "EGL_NATIVE_BUFFER_ANDROID";
 200                 case 0x3141: return "EGL_PLATFORM_ANDROID_KHR";
 201                 case 0x3142: return "EGL_RECORDABLE_ANDROID";
 202                 case 0x3143: return "EGL_NATIVE_BUFFER_USAGE_ANDROID";
 203                 case 0x3144: return "EGL_SYNC_NATIVE_FENCE_ANDROID";
 204                 case 0x3145: return "EGL_SYNC_NATIVE_FENCE_FD_ANDROID";
 205                 case 0x3146: return "EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID";
 206                 case 0x3147: return "EGL_FRAMEBUFFER_TARGET_ANDROID";
 207                 case 0x314c: return "EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID";
 208                 case 0x314d: return "EGL_GL_COLORSPACE_DEFAULT_EXT";
 209                 case 0x31b0: return "EGL_CONTEXT_OPENGL_DEBUG";
 210                 case 0x31b1: return "EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE";
 211                 case 0x31b2: return "EGL_CONTEXT_OPENGL_ROBUST_ACCESS";
 212                 case 0x31b3: return "EGL_CONTEXT_OPENGL_NO_ERROR_KHR";
 213                 case 0x31bd: return "EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR";
 214                 case 0x31be: return "EGL_NO_RESET_NOTIFICATION";
 215                 case 0x31bf: return "EGL_LOSE_CONTEXT_ON_RESET";
 216                 case 0x31d0: return "EGL_DRM_BUFFER_FORMAT_MESA";
 217                 case 0x31d1: return "EGL_DRM_BUFFER_USE_MESA";
 218                 case 0x31d2: return "EGL_DRM_BUFFER_FORMAT_ARGB32_MESA";
 219                 case 0x31d3: return "EGL_DRM_BUFFER_MESA";
 220                 case 0x31d4: return "EGL_DRM_BUFFER_STRIDE_MESA";
 221                 case 0x31d5: return "EGL_PLATFORM_X11_KHR";
 222                 case 0x31d6: return "EGL_PLATFORM_X11_SCREEN_KHR";
 223                 case 0x31d7: return "EGL_PLATFORM_GBM_KHR";
 224                 case 0x31d8: return "EGL_PLATFORM_WAYLAND_KHR";
 225                 case 0x31dd: return "EGL_PLATFORM_SURFACELESS_MESA";
 226                 case 0x31fc: return "EGL_STREAM_FIFO_LENGTH_KHR";
 227                 case 0x31fd: return "EGL_STREAM_TIME_NOW_KHR";
 228                 case 0x31fe: return "EGL_STREAM_TIME_CONSUMER_KHR";
 229                 case 0x31ff: return "EGL_STREAM_TIME_PRODUCER_KHR";
 230                 case 0x3200: return "EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE";
 231                 case 0x3201: return "EGL_FIXED_SIZE_ANGLE";
 232                 case 0x3210: return "EGL_CONSUMER_LATENCY_USEC_KHR";
 233                 case 0x3212: return "EGL_PRODUCER_FRAME_KHR";
 234                 case 0x3213: return "EGL_CONSUMER_FRAME_KHR";
 235                 case 0x3214: return "EGL_STREAM_STATE_KHR";
 236                 case 0x3215: return "EGL_STREAM_STATE_CREATED_KHR";
 237                 case 0x3216: return "EGL_STREAM_STATE_CONNECTING_KHR";
 238                 case 0x3217: return "EGL_STREAM_STATE_EMPTY_KHR";
 239                 case 0x3218: return "EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR";
 240                 case 0x3219: return "EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR";
 241                 case 0x321a: return "EGL_STREAM_STATE_DISCONNECTED_KHR";
 242                 case 0x321b: return "EGL_BAD_STREAM_KHR";
 243                 case 0x321c: return "EGL_BAD_STATE_KHR";
 244                 case 0x321d: return "EGL_BUFFER_COUNT_NV";
 245                 case 0x321e: return "EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR";
 246                 case 0x321f: return "EGL_SYNC_NEW_FRAME_NV";
 247                 case 0x322b: return "EGL_BAD_DEVICE_EXT";
 248                 case 0x322c: return "EGL_DEVICE_EXT";
 249                 case 0x322d: return "EGL_BAD_OUTPUT_LAYER_EXT";
 250                 case 0x322e: return "EGL_BAD_OUTPUT_PORT_EXT";
 251                 case 0x322f: return "EGL_SWAP_INTERVAL_EXT";
 252                 case 0x3233: return "EGL_DRM_DEVICE_FILE_EXT";
 253                 case 0x3234: return "EGL_DRM_CRTC_EXT";
 254                 case 0x3235: return "EGL_DRM_PLANE_EXT";
 255                 case 0x3236: return "EGL_DRM_CONNECTOR_EXT";
 256                 case 0x3237: return "EGL_OPENWF_DEVICE_ID_EXT";
 257                 case 0x3238: return "EGL_OPENWF_PIPELINE_ID_EXT";
 258                 case 0x3239: return "EGL_OPENWF_PORT_ID_EXT";
 259                 case 0x323a: return "EGL_CUDA_DEVICE_NV";
 260                 case 0x323b: return "EGL_CUDA_EVENT_HANDLE_NV";
 261                 case 0x323c: return "EGL_SYNC_CUDA_EVENT_NV";
 262                 case 0x323d: return "EGL_SYNC_CUDA_EVENT_COMPLETE_NV";
 263                 case 0x323f: return "EGL_STREAM_CROSS_PARTITION_NV";
 264                 case 0x3240: return "EGL_STREAM_STATE_INITIALIZING_NV";
 265                 case 0x3241: return "EGL_STREAM_TYPE_NV";
 266                 case 0x3242: return "EGL_STREAM_PROTOCOL_NV";
 267                 case 0x3243: return "EGL_STREAM_ENDPOINT_NV";
 268                 case 0x3244: return "EGL_STREAM_LOCAL_NV";
 269                 case 0x3245: return "EGL_STREAM_CROSS_PROCESS_NV";
 270                 case 0x3246: return "EGL_STREAM_PROTOCOL_FD_NV";
 271                 case 0x3247: return "EGL_STREAM_PRODUCER_NV";
 272                 case 0x3248: return "EGL_STREAM_CONSUMER_NV";
 273                 case 0x324b: return "EGL_STREAM_PROTOCOL_SOCKET_NV";
 274                 case 0x324c: return "EGL_SOCKET_HANDLE_NV";
 275                 case 0x324d: return "EGL_SOCKET_TYPE_NV";
 276                 case 0x324e: return "EGL_SOCKET_TYPE_UNIX_NV";
 277                 case 0x324f: return "EGL_SOCKET_TYPE_INET_NV";
 278                 case 0x3250: return "EGL_MAX_STREAM_METADATA_BLOCKS_NV";
 279                 case 0x3251: return "EGL_MAX_STREAM_METADATA_BLOCK_SIZE_NV";
 280                 case 0x3252: return "EGL_MAX_STREAM_METADATA_TOTAL_SIZE_NV";
 281                 case 0x3253: return "EGL_PRODUCER_METADATA_NV";
 282                 case 0x3254: return "EGL_CONSUMER_METADATA_NV";
 283                 case 0x3255: return "EGL_METADATA0_SIZE_NV";
 284                 case 0x3256: return "EGL_METADATA1_SIZE_NV";
 285                 case 0x3257: return "EGL_METADATA2_SIZE_NV";
 286                 case 0x3258: return "EGL_METADATA3_SIZE_NV";
 287                 case 0x3259: return "EGL_METADATA0_TYPE_NV";
 288                 case 0x325a: return "EGL_METADATA1_TYPE_NV";
 289                 case 0x325b: return "EGL_METADATA2_TYPE_NV";
 290                 case 0x325c: return "EGL_METADATA3_TYPE_NV";
 291                 case 0x3270: return "EGL_LINUX_DMA_BUF_EXT";
 292                 case 0x3271: return "EGL_LINUX_DRM_FOURCC_EXT";
 293                 case 0x3272: return "EGL_DMA_BUF_PLANE0_FD_EXT";
 294                 case 0x3273: return "EGL_DMA_BUF_PLANE0_OFFSET_EXT";
 295                 case 0x3274: return "EGL_DMA_BUF_PLANE0_PITCH_EXT";
 296                 case 0x3275: return "EGL_DMA_BUF_PLANE1_FD_EXT";
 297                 case 0x3276: return "EGL_DMA_BUF_PLANE1_OFFSET_EXT";
 298                 case 0x3277: return "EGL_DMA_BUF_PLANE1_PITCH_EXT";
 299                 case 0x3278: return "EGL_DMA_BUF_PLANE2_FD_EXT";
 300                 case 0x3279: return "EGL_DMA_BUF_PLANE2_OFFSET_EXT";
 301                 case 0x327a: return "EGL_DMA_BUF_PLANE2_PITCH_EXT";
 302                 case 0x327b: return "EGL_YUV_COLOR_SPACE_HINT_EXT";
 303                 case 0x327c: return "EGL_SAMPLE_RANGE_HINT_EXT";
 304                 case 0x327d: return "EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT";
 305                 case 0x327e: return "EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT";
 306                 case 0x327f: return "EGL_ITU_REC601_EXT";
 307                 case 0x3280: return "EGL_ITU_REC709_EXT";
 308                 case 0x3281: return "EGL_ITU_REC2020_EXT";
 309                 case 0x3282: return "EGL_YUV_FULL_RANGE_EXT";
 310                 case 0x3283: return "EGL_YUV_NARROW_RANGE_EXT";
 311                 case 0x3284: return "EGL_YUV_CHROMA_SITING_0_EXT";
 312                 case 0x3285: return "EGL_YUV_CHROMA_SITING_0_5_EXT";
 313                 case 0x3286: return "EGL_DISCARD_SAMPLES_ARM";
 314                 case 0x328a: return "EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM";
 315                 case 0x32a0: return "EGL_NATIVE_BUFFER_TIZEN";
 316                 case 0x32a1: return "EGL_NATIVE_SURFACE_TIZEN";
 317                 case 0x32c0: return "EGL_PROTECTED_CONTENT_EXT";
 318                 case 0x3300: return "EGL_YUV_BUFFER_EXT";
 319                 case 0x3301: return "EGL_YUV_ORDER_EXT";
 320                 case 0x3302: return "EGL_YUV_ORDER_YUV_EXT";
 321                 case 0x3303: return "EGL_YUV_ORDER_YVU_EXT";
 322                 case 0x3304: return "EGL_YUV_ORDER_YUYV_EXT";
 323                 case 0x3305: return "EGL_YUV_ORDER_UYVY_EXT";
 324                 case 0x3306: return "EGL_YUV_ORDER_YVYU_EXT";
 325                 case 0x3307: return "EGL_YUV_ORDER_VYUY_EXT";
 326                 case 0x3308: return "EGL_YUV_ORDER_AYUV_EXT";
 327                 case 0x330a: return "EGL_YUV_CSC_STANDARD_EXT";
 328                 case 0x330b: return "EGL_YUV_CSC_STANDARD_601_EXT";
 329                 case 0x330c: return "EGL_YUV_CSC_STANDARD_709_EXT";
 330                 case 0x330d: return "EGL_YUV_CSC_STANDARD_2020_EXT";
 331                 case 0x3311: return "EGL_YUV_NUMBER_OF_PLANES_EXT";
 332                 case 0x3312: return "EGL_YUV_SUBSAMPLE_EXT";
 333                 case 0x3313: return "EGL_YUV_SUBSAMPLE_4_2_0_EXT";
 334                 case 0x3314: return "EGL_YUV_SUBSAMPLE_4_2_2_EXT";
 335                 case 0x3315: return "EGL_YUV_SUBSAMPLE_4_4_4_EXT";
 336                 case 0x3317: return "EGL_YUV_DEPTH_RANGE_EXT";
 337                 case 0x3318: return "EGL_YUV_DEPTH_RANGE_LIMITED_EXT";
 338                 case 0x3319: return "EGL_YUV_DEPTH_RANGE_FULL_EXT";
 339                 case 0x331a: return "EGL_YUV_PLANE_BPP_EXT";
 340                 case 0x331b: return "EGL_YUV_PLANE_BPP_0_EXT";
 341                 case 0x331c: return "EGL_YUV_PLANE_BPP_8_EXT";
 342                 case 0x331d: return "EGL_YUV_PLANE_BPP_10_EXT";
 343                 case 0x3328: return "EGL_PENDING_METADATA_NV";
 344                 case 0x3329: return "EGL_PENDING_FRAME_NV";
 345                 case 0x332a: return "EGL_STREAM_TIME_PENDING_NV";
 346                 case 0x332c: return "EGL_YUV_PLANE0_TEXTURE_UNIT_NV";
 347                 case 0x332d: return "EGL_YUV_PLANE1_TEXTURE_UNIT_NV";
 348                 case 0x332e: return "EGL_YUV_PLANE2_TEXTURE_UNIT_NV";
 349                 case 0x3334: return "EGL_SUPPORT_RESET_NV";
 350                 case 0x3335: return "EGL_SUPPORT_REUSE_NV";
 351                 case 0x3336: return "EGL_STREAM_FIFO_SYNCHRONOUS_NV";
 352                 case 0x3337: return "EGL_PRODUCER_MAX_FRAME_HINT_NV";
 353                 case 0x3338: return "EGL_CONSUMER_MAX_FRAME_HINT_NV";
 354                 case 0x3339: return "EGL_COLOR_COMPONENT_TYPE_EXT";
 355                 case 0x333a: return "EGL_COLOR_COMPONENT_TYPE_FIXED_EXT";
 356                 case 0x333b: return "EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT";
 357                 case 0x333c: return "EGL_DRM_MASTER_FD_EXT";
 358                 case 0x333f: return "EGL_GL_COLORSPACE_BT2020_LINEAR_EXT";
 359                 case 0x3340: return "EGL_GL_COLORSPACE_BT2020_PQ_EXT";
 360                 case 0x3341: return "EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT";
 361                 case 0x3342: return "EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT";
 362                 case 0x3343: return "EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT";
 363                 case 0x3344: return "EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT";
 364                 case 0x3345: return "EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT";
 365                 case 0x3346: return "EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT";
 366                 case 0x3347: return "EGL_SMPTE2086_WHITE_POINT_X_EXT";
 367                 case 0x3348: return "EGL_SMPTE2086_WHITE_POINT_Y_EXT";
 368                 case 0x3349: return "EGL_SMPTE2086_MAX_LUMINANCE_EXT";
 369                 case 0x334a: return "EGL_SMPTE2086_MIN_LUMINANCE_EXT";
 370                 case 0x334c: return "EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV";
 371                 case 0x334d: return "EGL_STREAM_CROSS_OBJECT_NV";
 372                 case 0x334e: return "EGL_STREAM_CROSS_DISPLAY_NV";
 373                 case 0x334f: return "EGL_STREAM_CROSS_SYSTEM_NV";
 374                 case 0x3350: return "EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT";
 375                 case 0x3351: return "EGL_GL_COLORSPACE_SCRGB_EXT";
 376                 case 0x3352: return "EGL_TRACK_REFERENCES_KHR";
 377                 case 0x3357: return "EGL_CONTEXT_PRIORITY_REALTIME_NV";
 378                 case 0x3360: return "EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT";
 379                 case 0x3361: return "EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT";
 380                 case 0x3362: return "EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT";
 381                 case 0x3363: return "EGL_GL_COLORSPACE_DISPLAY_P3_EXT";
 382                 case 0x3364: return "EGL_SYNC_CLIENT_EXT";
 383                 case 0x3365: return "EGL_SYNC_CLIENT_SIGNAL_EXT";
 384                 case 0x33a0: return "EGL_D3D9_DEVICE_ANGLE";
 385                 case 0x33a1: return "EGL_D3D11_DEVICE_ANGLE";
 386                 case 0x33b0: return "EGL_OBJECT_THREAD_KHR";
 387                 case 0x33b1: return "EGL_OBJECT_DISPLAY_KHR";
 388                 case 0x33b2: return "EGL_OBJECT_CONTEXT_KHR";
 389                 case 0x33b3: return "EGL_OBJECT_SURFACE_KHR";
 390                 case 0x33b4: return "EGL_OBJECT_IMAGE_KHR";
 391                 case 0x33b5: return "EGL_OBJECT_SYNC_KHR";
 392                 case 0x33b6: return "EGL_OBJECT_STREAM_KHR";
 393                 case 0x33b8: return "EGL_DEBUG_CALLBACK_KHR";
 394                 case 0x33b9: return "EGL_DEBUG_MSG_CRITICAL_KHR";
 395                 case 0x33ba: return "EGL_DEBUG_MSG_ERROR_KHR";
 396                 case 0x33bb: return "EGL_DEBUG_MSG_WARN_KHR";
 397                 case 0x33bc: return "EGL_DEBUG_MSG_INFO_KHR";
 398                 case 0x3430: return "EGL_TIMESTAMPS_ANDROID";
 399                 case 0x3431: return "EGL_COMPOSITE_DEADLINE_ANDROID";
 400                 case 0x3432: return "EGL_COMPOSITE_INTERVAL_ANDROID";
 401                 case 0x3433: return "EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID";
 402                 case 0x3434: return "EGL_REQUESTED_PRESENT_TIME_ANDROID";
 403                 case 0x3435: return "EGL_RENDERING_COMPLETE_TIME_ANDROID";
 404                 case 0x3436: return "EGL_COMPOSITION_LATCH_TIME_ANDROID";
 405                 case 0x3437: return "EGL_FIRST_COMPOSITION_START_TIME_ANDROID";
 406                 case 0x3438: return "EGL_LAST_COMPOSITION_START_TIME_ANDROID";
 407                 case 0x3439: return "EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID";
 408                 case 0x343a: return "EGL_DISPLAY_PRESENT_TIME_ANDROID";
 409                 case 0x343b: return "EGL_DEQUEUE_READY_TIME_ANDROID";
 410                 case 0x343c: return "EGL_READS_DONE_TIME_ANDROID";
 411                 case 0x3440: return "EGL_DMA_BUF_PLANE3_FD_EXT";
 412                 case 0x3441: return "EGL_DMA_BUF_PLANE3_OFFSET_EXT";
 413                 case 0x3442: return "EGL_DMA_BUF_PLANE3_PITCH_EXT";
 414                 case 0x3443: return "EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT";
 415                 case 0x3444: return "EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT";
 416                 case 0x3445: return "EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT";
 417                 case 0x3446: return "EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT";
 418                 case 0x3447: return "EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT";
 419                 case 0x3448: return "EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT";
 420                 case 0x3449: return "EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT";
 421                 case 0x344a: return "EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT";
 422                 case 0x3460: return "EGL_PRIMARY_COMPOSITOR_CONTEXT_EXT";
 423                 case 0x3461: return "EGL_EXTERNAL_REF_ID_EXT";
 424                 case 0x3462: return "EGL_COMPOSITOR_DROP_NEWEST_FRAME_EXT";
 425                 case 0x3463: return "EGL_COMPOSITOR_KEEP_NEWEST_FRAME_EXT";
 426                 case 0x3464: return "EGL_FRONT_BUFFER_EXT";
 427                 case 0x3470: return "EGL_IMPORT_SYNC_TYPE_EXT";
 428                 case 0x3471: return "EGL_IMPORT_IMPLICIT_SYNC_EXT";
 429                 case 0x3472: return "EGL_IMPORT_EXPLICIT_SYNC_EXT";
 430                 case 0x3490: return "EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT";
 431                 case 0x8f70: return "EGL_COLOR_FORMAT_HI";
 432                 case 0x8f71: return "EGL_COLOR_RGB_HI";
 433                 case 0x8f72: return "EGL_COLOR_RGBA_HI";
 434                 case 0x8f73: return "EGL_COLOR_ARGB_HI";
 435                 case 0x8f74: return "EGL_CLIENT_PIXMAP_POINTER_HI";
 436                 case 0xc350: return "EGL_METADATA_SCALING_EXT";
 437                 default:
 438                         {
 439                                 static char str[64];
 440                                 sprintf(str, "%d", key);
 441                                 return str;
 442                         }
 443
 444         }
 445 }
 446
 447 static Sostate_Data *
 448 _get_sostate(GLContext ctx)
 449 {
 450         Sostate_Data *ret = NULL;
 451
 452         Ctx_Data *current = ctx_data;
 453         while (current != NULL) {
 454                 if (current->handle == ctx) {
 455                         current->sostate->ref_count++;
 456                         ret = current->sostate;
 457                         break;
 458                 }
 459                 current = current->next;
 460         }
 461
 462         return ret;
 463 }
 464
 465 #ifdef COREGL_TRACEPATH_TRACE_CONTEXT_INFO
 466
 467 static void
 468 _dump_context_info(const char *ment, int force_output)
 469 {
 470         MY_MODULE_TSTATE *tstate = NULL;
 471         static struct timeval tv_last = { 0, 0 };
 472
 473         if (get_trace_ctx_flag() != 1) return;
 474
 475         AST(mutex_lock(&ctx_access_mutex) == 1);
 476         AST(mutex_lock(&general_trace_lists_access_mutex) == 1);
 477
 478         if (!force_output && !get_trace_ctx_force_flag()) {
 479                 struct timeval tv_now = { 0, 0 };
 480                 AST(gettimeofday(&tv_now, NULL) == 0);
 481                 if (tv_now.tv_sec - tv_last.tv_sec < _COREGL_TRACE_OUTPUT_INTERVAL_SEC) {
 482                         goto finish;
 483                 }
 484                 tv_last = tv_now;
 485         }
 486
 487         GET_MY_TSTATE(tstate, get_current_thread_state());
 488
 489         TRACE("\n");
 490         TRACE("\E[40;34m========================================================================================================================\E[0m\n");
 491         TRACE("\E[40;32;1m  Context info \E[1;37;1m: <PID = %d> %s\E[0m\n", getpid(),
 492                   ment);
 493         TRACE("\E[40;34m========================================================================================================================\E[0m\n");
 494
 495
 496         // Thread State List
 497         {
 498                 General_Trace_List *current = NULL;
 499                 current = thread_trace_list;
 500
 501                 while (current != NULL) {
 502                         GLThreadState *cur_tstate = (GLThreadState *)current->value;
 503                         MY_MODULE_TSTATE *cur_tstate_tm = NULL;
 504
 505                         GET_MY_TSTATE(cur_tstate_tm, cur_tstate);
 506                         AST(cur_tstate_tm != NULL);
 507
 508                         if (cur_tstate_tm == NULL)
 509                                 continue;
 510
 511                         TRACE(" %c Thread  [0x%12x] : Surf <D=[%12p] R=[%12p]>",
 512                                   (tstate == cur_tstate_tm) ? '*' : ' ',
 513                                   cur_tstate->thread_id,
 514                                   cur_tstate_tm->surf_draw,
 515                                   cur_tstate_tm->surf_read);
 516
 517                         if (cur_tstate_tm->ctx != NULL) {
 518                                 TRACE(" EGLCTX=[%12p]\E[0m\n",
 519                                           cur_tstate_tm->ctx->handle);
 520                         } else {
 521                                 TRACE(" (NOT BINDED TO THREAD)\E[0m\n");
 522                         }
 523
 524                         // Binded Context State List
 525                         {
 526                                 Ctx_Data *current = NULL;
 527                                 current = ctx_data;
 528
 529                                 while (current != NULL) {
 530                                         if (cur_tstate_tm->ctx == current) {
 531                                                 TRACE("   -> EGLCTX [%12p] : EGLDPY=[%12p] <MC count [%10d]> <Ref [%2d]>\E[0m\n",
 532                                                           current->handle,
 533                                                           current->dpy,
 534                                                           current->mc_count,
 535                                                           current->ref_count);
 536                                         }
 537
 538                                         current = current->next;
 539                                 }
 540
 541                         }
 542
 543
 544                         current = current->next;
 545                 }
 546         }
 547
 548         TRACE("\E[40;33m........................................................................................................................\E[0m\n");
 549
 550         // Not-binded Context State List
 551         {
 552                 Ctx_Data *current = NULL;
 553                 current = ctx_data;
 554
 555                 while (current != NULL) {
 556                         int isbinded = 0;
 557
 558                         General_Trace_List *current_t = NULL;
 559                         current_t = thread_trace_list;
 560
 561                         while (current_t != NULL) {
 562                                 GLThreadState *cur_tstate = (GLThreadState *)current_t->value;
 563                                 MY_MODULE_TSTATE *cur_tstate_tm = NULL;
 564
 565                                 GET_MY_TSTATE(cur_tstate_tm, cur_tstate);
 566                                 AST(cur_tstate_tm != NULL);
 567                                 if (cur_tstate_tm != NULL && cur_tstate_tm->ctx == current) {
 568                                         isbinded = 1;
 569                                         break;
 570                                 }
 571                                 current_t = current_t->next;
 572                         }
 573
 574                         if (isbinded == 0) {
 575                                 TRACE("   EGLCTX    [%12p] : EGLDPY=[%12p] <MC count [%10d]> <Ref [%2d]>\E[0m\n",
 576                                           current->handle,
 577                                           current->dpy,
 578                                           current->mc_count,
 579                                           current->ref_count);
 580                         }
 581
 582                         current = current->next;
 583                 }
 584
 585         }
 586
 587         TRACE("\E[40;34m========================================================================================================================\E[0m\n");
 588         TRACE("\n");
 589
 590         TRACE_END();
 591
 592         goto finish;
 593
 594 finish:
 595
 596         AST(mutex_unlock(&general_trace_lists_access_mutex) == 1);
 597         AST(mutex_unlock(&ctx_access_mutex) == 1);
 598
 599 }
 600
 601 #endif // COREGL_TRACEPATH_TRACE_CONTEXT_INFO
 602
 603 static Ctx_Data *
 604 _get_current_ctx_data(GLContext ctx)
 605 {
 606         Ctx_Data *current = NULL;
 607         Ctx_Data *data = NULL;
 608
 609         AST(mutex_lock(&ctx_access_mutex) == 1);
 610
 611         current = ctx_data;
 612         while (current != NULL) {
 613                 if (current->handle == ctx) {
 614                         data = current;
 615                         break;
 616                 }
 617                 current = current->next;
 618         }
 619
 620         return data;
 621 }
 622
 623
 624 void
 625 tracepath_add_context(GLContext ctx, GLDisplay dpy, GLContext share_ctx)
 626 {
 627         Ctx_Data *data = _get_current_ctx_data(ctx);
 628
 629         if (data == NULL) {
 630                 data = (Ctx_Data *)calloc(1, sizeof(Ctx_Data));
 631                 if (data == NULL) goto finish;
 632
 633                 data->ref_count = 1;
 634                 data->handle = ctx;
 635                 data->dpy = dpy;
 636
 637                 data->sostate = _get_sostate(share_ctx);
 638                 if (data->sostate == NULL) {
 639                         data->sostate = (Sostate_Data *)calloc(1, sizeof(Sostate_Data));
 640                         if (data->sostate == NULL) goto finish;
 641
 642                         data->sostate->ref_count = 1;
 643                 }
 644
 645                 if (ctx_data != NULL)
 646                         data->next = ctx_data;
 647
 648                 ctx_data = data;
 649         }
 650         goto finish;
 651
 652 finish:
 653         AST(mutex_unlock(&ctx_access_mutex) == 1);
 654         return;
 655 }
 656
 657 Ctx_Data *
 658 tracepath_get_context(GLContext ctx)
 659 {
 660         Ctx_Data *data = _get_current_ctx_data(ctx);
 661
 662         if (data == NULL) {
 663                 COREGL_WARN("Error making context [%p] current. (invalid EGL context)", ctx);
 664                 goto finish;
 665         }
 666         data->ref_count++;
 667         goto finish;
 668
 669 finish:
 670         AST(mutex_unlock(&ctx_access_mutex) == 1);
 671         return data;
 672 }
 673
 674 void
 675 tracepath_remove_context(GLContext ctx)
 676 {
 677         Ctx_Data *current = NULL;
 678         Ctx_Data *prev = NULL;
 679
 680         AST(mutex_lock(&ctx_access_mutex) == 1);
 681
 682         current = ctx_data;
 683
 684         while (current != NULL) {
 685                 if (current->handle == ctx) {
 686                         if (--current->ref_count <= 0) {
 687                                 if (prev != NULL)
 688                                         prev->next = current->next;
 689                                 else
 690                                         ctx_data = current->next;
 691
 692                                 if (--current->sostate->ref_count <= 0) {
 693                                         tracepath_glbuf_clear(current->sostate->glbuf_rb);
 694                                         tracepath_glbuf_clear(current->sostate->glbuf_tex);
 695                                         free(current->sostate);
 696                                         current->sostate = NULL;
 697                                 }
 698
 699                                 free(current);
 700                                 current = NULL;
 701                         }
 702                         break;
 703                 }
 704                 prev = current;
 705                 current = current->next;
 706         }
 707         goto finish;
 708
 709 finish:
 710         AST(mutex_unlock(&ctx_access_mutex) == 1);
 711         return;
 712 }
 713
 714 EGLint
 715 tracepath_eglGetError(void)
 716 {
 717         EGLint ret = _COREGL_INT_INIT_VALUE;
 718
 719         _COREGL_TRACEPATH_FUNC_BEGIN();
 720         ret = _orig_tracepath_eglGetError();
 721         goto finish;
 722
 723 finish:
 724         _COREGL_TRACEPATH_FUNC_END("ret[%s]", _get_value(ret));
 725         return ret;
 726 }
 727
 728 EGLDisplay
 729 tracepath_eglGetDisplay(EGLNativeDisplayType display_id)
 730 {
 731         EGLDisplay ret = EGL_NO_DISPLAY;
 732
 733         _COREGL_TRACEPATH_FUNC_BEGIN("(%p)", display_id);
 734         ret = _orig_tracepath_eglGetDisplay(display_id);
 735         goto finish;
 736
 737 finish:
 738         _COREGL_TRACEPATH_FUNC_END("display[%p]", ret);
 739         return ret;
 740 }
 741
 742 EGLBoolean
 743 tracepath_eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
 744 {
 745         EGLBoolean ret = EGL_FALSE;
 746         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p)", dpy, major, minor);
 747         ret = _orig_tracepath_eglInitialize(dpy, major, minor);
 748         goto finish;
 749
 750 finish:
 751         _COREGL_TRACEPATH_FUNC_END("ret[%d], major[%d], minor[%d])", ret, major ? (*major) : 0, minor ? (*minor) : 0);
 752         return ret;
 753 }
 754
 755 EGLBoolean
 756 tracepath_eglTerminate(EGLDisplay dpy)
 757 {
 758         EGLBoolean ret = EGL_FALSE;
 759
 760         _COREGL_TRACEPATH_FUNC_BEGIN("(%p)", dpy);
 761         ret = _orig_tracepath_eglTerminate(dpy);
 762         goto finish;
 763
 764 finish:
 765         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
 766         return ret;
 767 }
 768
 769 EGLBoolean
 770 tracepath_eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size,
 771                                                 EGLint *num_config)
 772 {
 773         EGLBoolean ret = EGL_FALSE;
 774
 775         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d, %p)", dpy, configs, config_size, num_config);
 776         ret = _orig_tracepath_eglGetConfigs(dpy, configs, config_size, num_config);
 777         goto finish;
 778
 779 finish:
 780         _COREGL_TRACEPATH_FUNC_END("ret[%d], num_config[%d]", ret, num_config ? (*num_config):0);
 781         return ret;
 782 }
 783
 784 EGLBoolean
 785 tracepath_eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
 786                                                   EGLConfig *configs, EGLint config_size, EGLint *num_config)
 787 {
 788         EGLBoolean ret = EGL_FALSE;
 789
 790         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %d, %p)", dpy, attrib_list, configs, config_size,
 791                                                                                   num_config);
 792         ret = _orig_tracepath_eglChooseConfig(dpy, attrib_list, configs, config_size,
 793                                                                                   num_config);
 794         goto finish;
 795
 796 finish:
 797         _COREGL_TRACEPATH_FUNC_END("ret[%d], num_config[%d]", ret, num_config ? (*num_config) : 0);
 798         return ret;
 799 }
 800
 801 EGLBoolean
 802 tracepath_eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute,
 803                                                          EGLint *value)
 804 {
 805         EGLBoolean ret = EGL_FALSE;
 806
 807         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %s, %p)", dpy, config, _get_value(attribute), value);
 808         ret = _orig_tracepath_eglGetConfigAttrib(dpy, config, attribute, value);
 809         goto finish;
 810
 811 finish:
 812         _COREGL_TRACEPATH_FUNC_END("attribute[%s], value[%d]", _get_value(attribute), *value);
 813         return ret;
 814 }
 815
 816
 817 EGLSurface
 818 tracepath_eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
 819                                                                  EGLNativeWindowType win, const EGLint *attrib_list)
 820 {
 821         EGLSurface ret = EGL_NO_SURFACE;
 822
 823         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %p)", dpy, config, win, attrib_list);
 824         ret = _orig_tracepath_eglCreateWindowSurface(dpy, config, win, attrib_list);
 825         goto finish;
 826
 827 finish:
 828         _COREGL_TRACEPATH_FUNC_END("window surface[%p]", ret);
 829         return ret;
 830 }
 831
 832 EGLSurface
 833 tracepath_eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
 834                                                                   const EGLint *attrib_list)
 835 {
 836         EGLSurface ret = EGL_NO_SURFACE;
 837
 838         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p)", dpy, config, attrib_list);
 839         ret = _orig_tracepath_eglCreatePbufferSurface(dpy, config, attrib_list);
 840         goto finish;
 841
 842 finish:
 843         _COREGL_TRACEPATH_FUNC_END("pbuffer surface[%p]", ret);
 844         return ret;
 845 }
 846
 847 EGLSurface
 848 tracepath_eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
 849                                                                  EGLNativePixmapType pixmap, const EGLint *attrib_list)
 850 {
 851         EGLSurface ret = EGL_NO_SURFACE;
 852
 853         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %p)", dpy, config, pixmap, attrib_list);
 854         ret = _orig_tracepath_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
 855         goto finish;
 856
 857 finish:
 858         _COREGL_TRACEPATH_FUNC_END("pixmap surface[%p]", ret);
 859         return ret;
 860 }
 861
 862 EGLBoolean
 863 tracepath_eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 864 {
 865         EGLBoolean ret = EGL_FALSE;
 866
 867         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", dpy, surface);
 868         ret = _orig_tracepath_eglDestroySurface(dpy, surface);
 869         goto finish;
 870
 871 finish:
 872         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
 873 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 874         {
 875                 char name[256];
 876                 snprintf(name, sizeof(name), "EGLSURFACE_%p", surface);
 877                 tracepath_surface_trace_add(name, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
 878         }
 879 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 880         return ret;
 881 }
 882
 883 EGLBoolean
 884 tracepath_eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
 885                                                   EGLint *value)
 886 {
 887         EGLBoolean ret = EGL_FALSE;
 888
 889         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %s, %p)", dpy, surface, _get_value(attribute), value);
 890         ret = _orig_tracepath_eglQuerySurface(dpy, surface, attribute, value);
 891         goto finish;
 892
 893 finish:
 894         _COREGL_TRACEPATH_FUNC_END("attrib[%s], %d", _get_value(attribute), *value);
 895         return ret;
 896 }
 897
 898 EGLBoolean
 899 tracepath_eglBindAPI(EGLenum api)
 900 {
 901         EGLBoolean ret = EGL_FALSE;
 902
 903         _COREGL_TRACEPATH_FUNC_BEGIN("(%s)", _get_value(api));
 904         ret = _orig_tracepath_eglBindAPI(api);
 905         goto finish;
 906
 907 finish:
 908         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
 909         return ret;
 910 }
 911
 912 EGLenum
 913 tracepath_eglQueryAPI(void)
 914 {
 915         EGLenum ret = 0;
 916
 917         _COREGL_TRACEPATH_FUNC_BEGIN();
 918         ret = _orig_tracepath_eglQueryAPI();
 919         goto finish;
 920
 921 finish:
 922         _COREGL_TRACEPATH_FUNC_END("ret[%s]", _get_value(ret));
 923         return ret;
 924 }
 925
 926 EGLBoolean
 927 tracepath_eglWaitClient(void)
 928 {
 929         EGLBoolean ret = EGL_FALSE;
 930
 931         _COREGL_TRACEPATH_FUNC_BEGIN();
 932         ret = _orig_tracepath_eglWaitClient();
 933         goto finish;
 934
 935 finish:
 936         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
 937         return ret;
 938 }
 939
 940 EGLBoolean
 941 tracepath_eglReleaseThread(void)
 942 {
 943         EGLBoolean ret = EGL_FALSE;
 944
 945         _COREGL_TRACEPATH_FUNC_BEGIN();
 946         ret = _orig_tracepath_eglReleaseThread();
 947         goto finish;
 948
 949 finish:
 950         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
 951         return ret;
 952 }
 953
 954 EGLSurface
 955 tracepath_eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
 956                 EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
 957 {
 958         EGLSurface ret = EGL_NO_SURFACE;
 959
 960         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %s, %p, %p, %p)", dpy, _get_value(buftype), buffer,
 961                         config, attrib_list);
 962         ret = _orig_tracepath_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer,
 963                         config, attrib_list);
 964         goto finish;
 965
 966 finish:
 967         _COREGL_TRACEPATH_FUNC_END("surface[%p]", ret);
 968         return ret;
 969 }
 970
 971 EGLBoolean
 972 tracepath_eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
 973                                                    EGLint value)
 974 {
 975         EGLBoolean ret = EGL_FALSE;
 976
 977         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %s, 0x%x)", dpy, surface, _get_value(attribute), value);
 978         ret = _orig_tracepath_eglSurfaceAttrib(dpy, surface, attribute, value);
 979         goto finish;
 980
 981 finish:
 982         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
 983         return ret;
 984 }
 985
 986 EGLBoolean
 987 tracepath_eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 988 {
 989         EGLBoolean ret = EGL_FALSE;
 990
 991         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, 0x%x)", dpy, surface, buffer);
 992         ret = _orig_tracepath_eglBindTexImage(dpy, surface, buffer);
 993         goto finish;
 994
 995 finish:
 996         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
 997         return ret;
 998 }
 999
1000 EGLBoolean
1001 tracepath_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1002 {
1003         EGLBoolean ret = EGL_FALSE;
1004
1005         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, 0x%x)", dpy, surface, buffer);
1006         ret = _orig_tracepath_eglReleaseTexImage(dpy, surface, buffer);
1007         goto finish;
1008
1009 finish:
1010         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1011         return ret;
1012 }
1013
1014 EGLBoolean
1015 tracepath_eglSwapInterval(EGLDisplay dpy, EGLint interval)
1016 {
1017         EGLBoolean ret = EGL_FALSE;
1018
1019         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %d)", dpy, interval);
1020         ret = _orig_tracepath_eglSwapInterval(dpy, interval);
1021         goto finish;
1022
1023 finish:
1024         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1025         return ret;
1026 }
1027
1028 EGLContext
1029 tracepath_eglCreateContext(EGLDisplay dpy, EGLConfig config,
1030                                                    EGLContext share_context, const EGLint *attrib_list)
1031 {
1032         EGLContext ret = EGL_NO_CONTEXT;
1033
1034         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %p)", dpy, config, share_context, attrib_list);
1035         ret = _orig_tracepath_eglCreateContext(dpy, config, share_context, attrib_list);
1036         goto finish;
1037
1038 finish:
1039         _COREGL_TRACEPATH_FUNC_END("context[%p]", ret);
1040         {
1041                 if (ret != EGL_NO_CONTEXT) {
1042                         tracepath_add_context(ret, dpy, share_context);
1043                 }
1044         }
1045 #ifdef COREGL_TRACEPATH_TRACE_CONTEXT_INFO
1046         if (unlikely(get_trace_ctx_flag() == 1)) {
1047                 if (_orig_tracepath_eglCreateContext == _sym_eglCreateContext) {
1048                         char ment[256];
1049                         snprintf(ment, sizeof(ment), "eglCreateContext completed (EGLCTX=[%12p])", ret);
1050                         _dump_context_info(ment, 1);
1051                 }
1052         }
1053 #endif // COREGL_TRACEPATH_TRACE_CONTEXT_INFO
1054         return ret;
1055 }
1056
1057 EGLBoolean
1058 tracepath_eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
1059 {
1060         EGLBoolean ret = EGL_FALSE;
1061
1062         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", dpy, ctx);
1063         ret = _orig_tracepath_eglDestroyContext(dpy, ctx);
1064         goto finish;
1065
1066 finish:
1067         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1068         {
1069                 AST(ctx != EGL_NO_CONTEXT);
1070
1071                 tracepath_remove_context(ctx);
1072         }
1073 #ifdef COREGL_TRACEPATH_TRACE_CONTEXT_INFO
1074         if (unlikely(get_trace_ctx_flag() == 1)) {
1075                 if (_orig_tracepath_eglDestroyContext == _sym_eglDestroyContext) {
1076                         char ment[256];
1077                         snprintf(ment, sizeof(ment), "eglDestroyContext completed (EGLCTX=[%12p])",
1078                                          ctx);
1079                         _dump_context_info(ment, 1);
1080                 }
1081         }
1082 #endif // COREGL_TRACEPATH_TRACE_CONTEXT_INFO
1083         return ret;
1084 }
1085
1086 EGLBoolean
1087 tracepath_eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
1088                                                  EGLContext ctx)
1089 {
1090         EGLBoolean ret = EGL_FALSE;
1091
1092         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %p)", dpy, draw, read, ctx);
1093         ret = _orig_tracepath_eglMakeCurrent(dpy, draw, read, ctx);
1094         goto finish;
1095
1096 finish:
1097         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1098         {
1099                 MY_MODULE_TSTATE *tstate = NULL;
1100
1101                 GET_MY_TSTATE(tstate, get_current_thread_state());
1102                 if (tstate == NULL) {
1103                         init_new_thread_state();
1104
1105                         GET_MY_TSTATE(tstate, get_current_thread_state());
1106                         AST(tstate != NULL);
1107                 }
1108
1109                 if (tstate) {
1110
1111                         Ctx_Data *oldctx = tstate->ctx;
1112
1113                         if (ctx != EGL_NO_CONTEXT) {
1114                                 tstate->ctx = tracepath_get_context(ctx);
1115                                 if (tstate->ctx != NULL)
1116                                         tstate->ctx->mc_count++;
1117                         } else {
1118                                 tstate->ctx = NULL;
1119                         }
1120
1121                         if (oldctx != NULL)
1122                                 tracepath_remove_context(oldctx->handle);
1123
1124                         tstate->surf_draw = draw;
1125                         tstate->surf_read = read;
1126                 }
1127         }
1128 #ifdef COREGL_TRACEPATH_TRACE_STATE_INFO
1129         if (unlikely(get_trace_state_flag() == 1)) {
1130                 if (_orig_tracepath_eglMakeCurrent == _sym_eglMakeCurrent)
1131                         tracepath_dump_context_states(0);
1132         }
1133 #endif // COREGL_TRACEPATH_TRACE_STATE_INFO
1134 #ifdef COREGL_TRACEPATH_TRACE_CONTEXT_INFO
1135         if (unlikely(get_trace_ctx_flag() == 1)) {
1136                 if (_orig_tracepath_eglMakeCurrent == _sym_eglMakeCurrent) {
1137                         char ment[256];
1138                         snprintf(ment, sizeof(ment),
1139                                          "eglMakeCurrent finished (EGLCTX=[%12p] Surf=[D:%12p R:%12p])",
1140                                          ctx, draw, read);
1141                         _dump_context_info(ment, 0);
1142                 }
1143         }
1144 #endif // COREGL_TRACEPATH_TRACE_CONTEXT_INFO
1145         return ret;
1146 }
1147
1148 EGLContext
1149 tracepath_eglGetCurrentContext(void)
1150 {
1151         EGLContext ret = EGL_NO_CONTEXT;
1152
1153         _COREGL_TRACEPATH_FUNC_BEGIN();
1154         ret = _orig_tracepath_eglGetCurrentContext();
1155         goto finish;
1156
1157 finish:
1158         _COREGL_TRACEPATH_FUNC_END("context[%p]", ret);
1159         return ret;
1160 }
1161
1162 EGLSurface
1163 tracepath_eglGetCurrentSurface(EGLint readdraw)
1164 {
1165         EGLSurface ret = EGL_NO_SURFACE;
1166
1167         _COREGL_TRACEPATH_FUNC_BEGIN("(%s)", _get_value(readdraw));
1168         ret = _orig_tracepath_eglGetCurrentSurface(readdraw);
1169         goto finish;
1170
1171 finish:
1172         _COREGL_TRACEPATH_FUNC_END("surface[%p]", ret);
1173         return ret;
1174 }
1175
1176 EGLDisplay
1177 tracepath_eglGetCurrentDisplay(void)
1178 {
1179         EGLDisplay ret = EGL_NO_DISPLAY;
1180
1181         _COREGL_TRACEPATH_FUNC_BEGIN();
1182         ret = _orig_tracepath_eglGetCurrentDisplay();
1183         goto finish;
1184
1185 finish:
1186         _COREGL_TRACEPATH_FUNC_END("display[%p]", ret);
1187         return ret;
1188 }
1189
1190 EGLBoolean
1191 tracepath_eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute,
1192                                                   EGLint *value)
1193 {
1194         EGLBoolean ret = EGL_FALSE;
1195
1196         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %s, %p)", dpy, ctx, _get_value(attribute), value);
1197         ret = _orig_tracepath_eglQueryContext(dpy, ctx, attribute, value);
1198         goto finish;
1199
1200 finish:
1201         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1202         return ret;
1203 }
1204
1205 EGLBoolean
1206 tracepath_eglWaitGL(void)
1207 {
1208         EGLBoolean ret = EGL_FALSE;
1209
1210         _COREGL_TRACEPATH_FUNC_BEGIN();
1211         ret = _orig_tracepath_eglWaitGL();
1212
1213         _COREGL_TRACE_SURFACE(0, 1, "EGLWAITGL");
1214
1215         goto finish;
1216
1217 finish:
1218         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1219         return ret;
1220 }
1221
1222 EGLBoolean
1223 tracepath_eglWaitNative(EGLint engine)
1224 {
1225         EGLBoolean ret = EGL_FALSE;
1226
1227         _COREGL_TRACEPATH_FUNC_BEGIN("(%s)", _get_value(engine));
1228         ret = _orig_tracepath_eglWaitNative(engine);
1229         goto finish;
1230
1231 finish:
1232         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1233         return ret;
1234 }
1235
1236 static void
1237 _trace_after_swap()
1238 {
1239         if (unlikely(get_trace_api_frame_flag() == 1)) {
1240                 if (unlikely(get_trace_api_all_flag() == 1)) {
1241                         _COREGL_TRACE_API_OUTPUT(1);
1242                 } else {
1243                         _COREGL_TRACE_API_OUTPUT(0);
1244                 }
1245                 _COREGL_TRACE_API_RESET_FRAME();
1246         } else {
1247                 _COREGL_TRACE_API_OUTPUT(0);
1248         }
1249         _COREGL_TRACE_MEM_OUTPUT(0);
1250 }
1251
1252 EGLBoolean
1253 tracepath_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
1254 {
1255         EGLBoolean ret = EGL_FALSE;
1256
1257         _COREGL_TRACE_SURFACE(0, 1, "SWAPBUFFERS");
1258
1259         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", dpy, surface);
1260         ret = _orig_tracepath_eglSwapBuffers(dpy, surface);
1261
1262         goto finish;
1263
1264 finish:
1265         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1266         _trace_after_swap();
1267         return ret;
1268 }
1269
1270 EGLBoolean
1271 tracepath_eglSwapBuffersWithDamageEXT(EGLDisplay dpy, EGLSurface surface,
1272                                                                           EGLint *rects, EGLint n_rects)
1273 {
1274         EGLBoolean ret = EGL_FALSE;
1275
1276         _COREGL_TRACE_SURFACE(0, 1, "SWAPBUFFERS");
1277
1278         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %d)", dpy, surface, rects, n_rects);
1279         ret = _orig_tracepath_eglSwapBuffersWithDamageEXT(dpy, surface, rects, n_rects);
1280
1281         goto finish;
1282
1283 finish:
1284         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1285         _trace_after_swap();
1286         return ret;
1287 }
1288
1289 EGLBoolean
1290 tracepath_eglSwapBuffersRegionEXT(EGLDisplay dpy, EGLSurface surface,
1291                                                                   EGLint numRects, const EGLint *rects)
1292 {
1293         EGLBoolean ret = EGL_FALSE;
1294
1295         _COREGL_TRACE_SURFACE(0, 1, "SWAPBUFFERS");
1296
1297         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d, %p)", dpy, surface, numRects, rects);
1298         ret = _orig_tracepath_eglSwapBuffersRegionEXT(dpy, surface, numRects, rects);
1299
1300         goto finish;
1301
1302 finish:
1303         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1304         _trace_after_swap();
1305         return ret;
1306 }
1307
1308 EGLBoolean
1309 tracepath_eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,
1310                                                  EGLNativePixmapType target)
1311 {
1312         EGLBoolean ret = EGL_FALSE;
1313
1314         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p)", dpy, surface, target);
1315         ret = _orig_tracepath_eglCopyBuffers(dpy, surface, target);
1316         goto finish;
1317
1318 finish:
1319         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1320         return ret;
1321 }
1322
1323 _eng_fn
1324 tracepath_eglGetProcAddress(const char *procname)
1325 {
1326         _eng_fn ret = NULL;
1327
1328         _COREGL_TRACEPATH_FUNC_BEGIN("eglGetProcAddress %s", procname);
1329
1330 #define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST) \
1331         if (strcmp(procname, #FUNC_NAME) == 0) \
1332         { \
1333                 _eng_fn ret_orig = NULL; \
1334                 ret_orig = _orig_tracepath_eglGetProcAddress(procname); \
1335                 if (ret_orig != NULL) \
1336                         ret = (_eng_fn)ovr_##FUNC_NAME; \
1337                 goto finish; \
1338         }
1339
1340 #define _COREGL_EXT_SYMBOL_ALIAS(ALIAS_NAME, FUNC_NAME) \
1341    if (strcmp(procname, #ALIAS_NAME) == 0) \
1342    { \
1343                 _eng_fn ret_orig = NULL; \
1344                 ret_orig = _orig_tracepath_eglGetProcAddress(#ALIAS_NAME); \
1345                 if (ret_orig != NULL) \
1346                         ret = (_eng_fn)ovr_##FUNC_NAME; \
1347                 goto finish; \
1348    }
1349
1350 #include "../headers/sym_egl.h"
1351 #include "../headers/sym_gl1.h"
1352 #include "../headers/sym_gl2.h"
1353 #undef _COREGL_SYMBOL
1354 #undef _COREGL_EXT_SYMBOL_ALIAS
1355
1356         ret = _orig_tracepath_eglGetProcAddress(procname);
1357         if (ret != NULL) {
1358                 COREGL_WARN("TRACEPATH can't support '%s' (tracing for this function will be ignored)",
1359                                         procname);
1360         }
1361
1362         goto finish;
1363
1364 finish:
1365         _COREGL_TRACEPATH_FUNC_END();
1366         return ret;
1367 }
1368
1369 const char *
1370 tracepath_eglQueryString(EGLDisplay dpy, EGLint name)
1371 {
1372         const char *ret = NULL;
1373
1374         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %s)", dpy, _get_value(name));
1375         ret = _orig_tracepath_eglQueryString(dpy, name);
1376         goto finish;
1377
1378 finish:
1379         _COREGL_TRACEPATH_FUNC_END("ret[%s]", ret);
1380         return ret;
1381 }
1382
1383 EGLImageKHR
1384 tracepath_eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target,
1385                                                          EGLClientBuffer buffer, const EGLint *attrib_list)
1386 {
1387         void *ret = NULL;
1388
1389         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %s, %p, %p)", dpy, ctx, _get_value(target), buffer, attrib_list);
1390         ret = _orig_tracepath_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
1391         goto finish;
1392
1393 finish:
1394         _COREGL_TRACEPATH_FUNC_END("image[%p]", ret);
1395         return ret;
1396 }
1397
1398 EGLBoolean
1399 tracepath_eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
1400 {
1401         EGLBoolean ret = EGL_FALSE;
1402
1403         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", dpy, image);
1404         ret = _orig_tracepath_eglDestroyImageKHR(dpy, image);
1405         goto finish;
1406
1407 finish:
1408         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1409         return ret;
1410 }
1411
1412 void *
1413 tracepath_eglMapImageSEC(EGLDisplay dpy, EGLImageKHR image, EGLint device_type,
1414                                                  EGLint access_option)
1415 {
1416         void *ret = NULL;
1417
1418         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d, %d)", dpy, image, device_type, access_option);
1419         ret = _orig_tracepath_eglMapImageSEC(dpy, image, device_type, access_option);
1420         goto finish;
1421
1422 finish:
1423         _COREGL_TRACEPATH_FUNC_END();
1424         return ret;
1425 }
1426
1427 EGLBoolean
1428 tracepath_eglUnmapImageSEC(EGLDisplay dpy, EGLImageKHR image,
1429                                                    EGLint device_type)
1430 {
1431         EGLBoolean ret = EGL_FALSE;
1432
1433         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d)", dpy, image, device_type);
1434         ret = _orig_tracepath_eglUnmapImageSEC(dpy, image, device_type);
1435         goto finish;
1436
1437 finish:
1438         _COREGL_TRACEPATH_FUNC_END();
1439         return ret;
1440 }
1441
1442 EGLBoolean
1443 tracepath_eglGetImageAttribSEC(EGLDisplay dpy, EGLImageKHR image,
1444                                                            EGLint attribute, EGLint *value)
1445 {
1446         EGLBoolean ret = EGL_FALSE;
1447
1448         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %s, %p)", dpy, image, _get_value(attribute), value);
1449         ret = _orig_tracepath_eglGetImageAttribSEC(dpy, image, attribute, value);
1450         goto finish;
1451
1452 finish:
1453         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1454         return ret;
1455 }
1456
1457 EGLBoolean
1458 tracepath_eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface,
1459                                                         const EGLint *attrib_list)
1460 {
1461         EGLBoolean ret = EGL_FALSE;
1462
1463         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p)", display, surface, attrib_list);
1464         ret = _orig_tracepath_eglLockSurfaceKHR(display, surface, attrib_list);
1465         goto finish;
1466
1467 finish:
1468         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1469         return ret;
1470 }
1471
1472 EGLBoolean
1473 tracepath_eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface)
1474 {
1475         EGLBoolean ret = EGL_FALSE;
1476
1477         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", display, surface);
1478         ret = _orig_tracepath_eglUnlockSurfaceKHR(display, surface);
1479         goto finish;
1480
1481 finish:
1482         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1483         return ret;
1484 }
1485
1486 EGLBoolean
1487 tracepath_eglBindWaylandDisplayWL(EGLDisplay dpy, void *display)
1488 {
1489         EGLBoolean ret = EGL_FALSE;
1490
1491         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", display, display);
1492         ret = _orig_tracepath_eglBindWaylandDisplayWL(dpy, display);
1493
1494         goto finish;
1495
1496 finish:
1497         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1498         return ret;
1499 }
1500
1501 EGLBoolean
1502 tracepath_eglUnbindWaylandDisplayWL(EGLDisplay dpy, void *display)
1503 {
1504         EGLBoolean ret = EGL_FALSE;
1505
1506         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", display, display);
1507         ret = _orig_tracepath_eglUnbindWaylandDisplayWL(dpy, display);
1508
1509         goto finish;
1510
1511 finish:
1512         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1513         return ret;
1514 }
1515
1516 EGLBoolean
1517 tracepath_eglQueryWaylandBufferWL(EGLDisplay dpy, void *buffer,
1518                                                                   EGLint attribute, EGLint *value)
1519 {
1520         EGLBoolean ret = EGL_FALSE;
1521
1522         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %s, %p)", dpy, buffer, _get_value(attribute), value);
1523         ret = _orig_tracepath_eglQueryWaylandBufferWL(dpy, buffer, attribute, value);
1524
1525         goto finish;
1526
1527 finish:
1528         _COREGL_TRACEPATH_FUNC_END("ret[%d], value[%d]", ret, *value);
1529         return ret;
1530 }
1531
1532 EGLBoolean
1533 tracepath_eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface,
1534                                                                 EGLint *rects, EGLint n_rects)
1535 {
1536         EGLBoolean ret = EGL_FALSE;
1537
1538         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %d)", dpy, surface, rects, n_rects);
1539         ret = _orig_tracepath_eglSetDamageRegionKHR(dpy, surface, rects, n_rects);
1540
1541         goto finish;
1542
1543 finish:
1544         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1545         return ret;
1546 }
1547
1548 EGLBoolean
1549 tracepath_eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface,
1550                                                                           EGLint *rects, EGLint n_rects)
1551 {
1552         EGLBoolean ret = EGL_FALSE;
1553
1554         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %d)", dpy, surface, rects, n_rects);
1555         ret = _orig_tracepath_eglSwapBuffersWithDamageKHR(dpy, surface, rects, n_rects);
1556
1557         goto finish;
1558
1559 finish:
1560         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1561         return ret;
1562 }
1563
1564 EGLBoolean
1565 tracepath_eglFrontBufferSetSEC(EGLDisplay dpy, EGLSurface surface,
1566                                                            EGLBoolean set)
1567 {
1568         EGLBoolean ret = EGL_FALSE;
1569
1570         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d)", dpy, surface, set);
1571         ret = _orig_tracepath_eglFrontBufferSetSEC(dpy, surface, set);
1572
1573         goto finish;
1574
1575 finish:
1576         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1577         return ret;
1578 }
1579
1580 EGLSync
1581 tracepath_eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
1582 {
1583          EGLSync ret = EGL_NO_SYNC;
1584
1585         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %d, %p)", dpy, type, attrib_list);
1586         ret = _orig_tracepath_eglCreateSync(dpy, type, attrib_list);
1587         goto finish;
1588
1589 finish:
1590         _COREGL_TRACEPATH_FUNC_END("EGLSync[%p]", ret);
1591         return ret;
1592 }
1593
1594 EGLBoolean
1595 tracepath_eglDestroySync(EGLDisplay dpy, EGLSync sync)
1596 {
1597         EGLBoolean ret = EGL_FALSE;
1598
1599         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", dpy, sync);
1600         ret = _orig_tracepath_eglDestroySync(dpy, sync);
1601         goto finish;
1602
1603 finish:
1604         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1605         return ret;
1606 }
1607
1608 EGLint
1609 tracepath_eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout)
1610 {
1611         EGLint ret = EGL_FALSE;
1612
1613         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d, %" PRId64 ")", dpy, sync, flags, timeout);
1614         ret = _orig_tracepath_eglClientWaitSync(dpy, sync, flags, timeout);
1615         goto finish;
1616
1617 finish:
1618         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1619         return ret;
1620 }
1621
1622 EGLBoolean
1623 tracepath_eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value)
1624 {
1625         EGLBoolean ret = EGL_FALSE;
1626
1627         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d, %p)", dpy, sync, attribute, value);
1628         ret = _orig_tracepath_eglGetSyncAttrib(dpy, sync, attribute, value);
1629         goto finish;
1630
1631 finish:
1632         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1633         return ret;
1634 }
1635
1636 EGLImage
1637 tracepath_eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list)
1638 {
1639         EGLImage ret = EGL_NO_IMAGE;
1640
1641         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d, %p, %p)", dpy, ctx, target, buffer, attrib_list);
1642         ret = _orig_tracepath_eglCreateImage(dpy, ctx, target, buffer, attrib_list);
1643         goto finish;
1644
1645 finish:
1646         _COREGL_TRACEPATH_FUNC_END("ret[%p]", ret);
1647         return ret;
1648 }
1649
1650 EGLBoolean
1651 tracepath_eglDestroyImage(EGLDisplay dpy, EGLImage image)
1652 {
1653         EGLBoolean ret = EGL_FALSE;
1654
1655         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p)", dpy, image);
1656         ret = _orig_tracepath_eglDestroyImage(dpy, image);
1657         goto finish;
1658
1659 finish:
1660         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1661         return ret;
1662 }
1663
1664 EGLDisplay
1665 tracepath_eglGetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list)
1666 {
1667         EGLDisplay ret = EGL_NO_DISPLAY;
1668
1669         _COREGL_TRACEPATH_FUNC_BEGIN("(%d, %p, %p)", platform, native_display, attrib_list);
1670         ret = _orig_tracepath_eglGetPlatformDisplay(platform, native_display, attrib_list);
1671         goto finish;
1672
1673 finish:
1674         _COREGL_TRACEPATH_FUNC_END("ret[%p]", ret);
1675         return ret;
1676 }
1677
1678 EGLSurface
1679 tracepath_eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list)
1680 {
1681         EGLSurface ret = EGL_NO_SURFACE;
1682
1683         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %p)", dpy, config, native_window, attrib_list);
1684         ret = _orig_tracepath_eglCreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
1685         goto finish;
1686
1687 finish:
1688         _COREGL_TRACEPATH_FUNC_END("ret[%p]", ret);
1689         return ret;
1690 }
1691
1692 EGLSurface
1693 tracepath_eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list)
1694 {
1695         EGLSurface ret = EGL_NO_SURFACE;
1696
1697         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %p, %p)", dpy, config, native_pixmap, attrib_list);
1698         ret = _orig_tracepath_eglCreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
1699         goto finish;
1700
1701 finish:
1702         _COREGL_TRACEPATH_FUNC_END("ret[%p]", ret);
1703         return ret;
1704 }
1705
1706 EGLBoolean
1707 tracepath_eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
1708 {
1709         EGLBoolean ret = EGL_FALSE;
1710
1711         _COREGL_TRACEPATH_FUNC_BEGIN("(%p, %p, %d)", dpy, sync, flags);
1712         ret = _orig_tracepath_eglWaitSync(dpy, sync, flags);
1713         goto finish;
1714
1715 finish:
1716         _COREGL_TRACEPATH_FUNC_END("ret[%d]", ret);
1717         return ret;
1718 }