1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program EGL Utilities 3 * ------------------------------------------ 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief EGL call wrapper for logging. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "egluCallLogWrapper.hpp" 25 #include "egluStrUtil.hpp" 26 #include "eglwLibrary.hpp" 27 #include "eglwEnums.hpp" 28 #include "deStringUtil.hpp" 29 #include "deInt32.h" 30 31 namespace eglu 32 { 33 34 using tcu::toHex; 35 using tcu::TestLog; 36 37 CallLogWrapper::CallLogWrapper (const eglw::Library& egl, TestLog& log) 38 : m_egl (egl) 39 , m_log (log) 40 , m_enableLog (false) 41 { 42 } 43 44 CallLogWrapper::~CallLogWrapper (void) 45 { 46 } 47 48 // Pointer formatter. 49 50 template <typename T> 51 class PointerFmt 52 { 53 public: 54 const T* arr; 55 deUint32 size; 56 57 PointerFmt (const T* arr_, deUint32 size_) : arr(arr_), size(size_) {} 58 }; 59 60 template <typename T> 61 std::ostream& operator<< (std::ostream& str, PointerFmt<T> fmt) 62 { 63 if (fmt.arr != DE_NULL) 64 { 65 str << "{ "; 66 for (deUint32 ndx = 0; ndx < fmt.size; ndx++) 67 { 68 if (ndx != 0) 69 str << ", "; 70 str << fmt.arr[ndx]; 71 } 72 str << " }"; 73 return str; 74 } 75 else 76 return str << "(null)"; 77 } 78 79 template <typename T> 80 inline PointerFmt<T> getPointerStr (const T* arr, deUint32 size) 81 { 82 return PointerFmt<T>(arr, size); 83 } 84 85 typedef const char* (*GetEnumNameFunc) (int value); 86 87 // Enum pointer formatter. 88 89 class EnumPointerFmt 90 { 91 public: 92 const int* value; 93 GetEnumNameFunc getName; 94 95 EnumPointerFmt (const int* value_, GetEnumNameFunc getName_) : value(value_), getName(getName_) {} 96 }; 97 98 inline std::ostream& operator<< (std::ostream& str, EnumPointerFmt fmt) 99 { 100 if (fmt.value) 101 return str << tcu::Format::Enum<int, 2>(fmt.getName, *fmt.value); 102 else 103 return str << "(null)"; 104 } 105 106 inline EnumPointerFmt getEnumPointerStr (const int* value, GetEnumNameFunc getName) 107 { 108 return EnumPointerFmt(value, getName); 109 } 110 111 // String formatter. 112 113 class StringFmt 114 { 115 public: 116 const char* str; 117 StringFmt (const char* str_) : str(str_) {} 118 }; 119 120 inline std::ostream& operator<< (std::ostream& str, StringFmt fmt) 121 { 122 return str << (fmt.str ? fmt.str : "NULL"); 123 } 124 125 inline StringFmt getStringStr (const char* value) { return StringFmt(value); } 126 127 // Config attrib pointer formatter 128 129 class ConfigAttribValuePointerFmt 130 { 131 public: 132 deUint32 attrib; 133 const int* value; 134 ConfigAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {} 135 }; 136 137 inline ConfigAttribValuePointerFmt getConfigAttribValuePointerStr (deUint32 attrib, const int* value) { return ConfigAttribValuePointerFmt(attrib, value); } 138 139 inline std::ostream& operator<< (std::ostream& str, const ConfigAttribValuePointerFmt& fmt) 140 { 141 if (fmt.value) 142 return str << getConfigAttribValueStr(fmt.attrib, *fmt.value); 143 else 144 return str << "NULL"; 145 } 146 147 // Context attrib pointer formatter 148 149 class ContextAttribValuePointerFmt 150 { 151 public: 152 deUint32 attrib; 153 const int* value; 154 ContextAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {} 155 }; 156 157 inline ContextAttribValuePointerFmt getContextAttribValuePointerStr (deUint32 attrib, const int* value) { return ContextAttribValuePointerFmt(attrib, value); } 158 159 inline std::ostream& operator<< (std::ostream& str, const ContextAttribValuePointerFmt& fmt) 160 { 161 if (fmt.value) 162 return str << getContextAttribValueStr(fmt.attrib, *fmt.value); 163 else 164 return str << "NULL"; 165 } 166 167 // Surface attrib pointer formatter 168 169 class SurfaceAttribValuePointerFmt 170 { 171 public: 172 deUint32 attrib; 173 const int* value; 174 SurfaceAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {} 175 }; 176 177 inline SurfaceAttribValuePointerFmt getSurfaceAttribValuePointerStr (deUint32 attrib, const int* value) { return SurfaceAttribValuePointerFmt(attrib, value); } 178 179 inline std::ostream& operator<< (std::ostream& str, const SurfaceAttribValuePointerFmt& fmt) 180 { 181 if (fmt.value) 182 return str << getSurfaceAttribValueStr(fmt.attrib, *fmt.value); 183 else 184 return str << "NULL"; 185 } 186 187 // EGLDisplay formatter 188 189 class EGLDisplayFmt 190 { 191 public: 192 eglw::EGLDisplay display; 193 EGLDisplayFmt (eglw::EGLDisplay display_) : display(display_) {} 194 }; 195 196 inline EGLDisplayFmt getEGLDisplayStr (eglw::EGLDisplay display) { return EGLDisplayFmt(display); } 197 198 inline std::ostream& operator<< (std::ostream& str, const EGLDisplayFmt& fmt) 199 { 200 if (fmt.display == EGL_NO_DISPLAY) 201 return str << "EGL_NO_DISPLAY"; 202 else 203 return str << toHex(fmt.display); 204 } 205 206 // EGLSurface formatter 207 208 class EGLSurfaceFmt 209 { 210 public: 211 eglw::EGLSurface surface; 212 EGLSurfaceFmt (eglw::EGLSurface surface_) : surface(surface_) {} 213 }; 214 215 inline EGLSurfaceFmt getEGLSurfaceStr (eglw::EGLSurface surface) { return EGLSurfaceFmt(surface); } 216 217 inline std::ostream& operator<< (std::ostream& str, const EGLSurfaceFmt& fmt) 218 { 219 if (fmt.surface == EGL_NO_SURFACE) 220 return str << "EGL_NO_SURFACE"; 221 else 222 return str << toHex(fmt.surface); 223 } 224 225 // EGLContext formatter 226 227 class EGLContextFmt 228 { 229 public: 230 eglw::EGLContext context; 231 EGLContextFmt (eglw::EGLContext context_) : context(context_) {} 232 }; 233 234 inline EGLContextFmt getEGLContextStr (eglw::EGLContext context) { return EGLContextFmt(context); } 235 236 inline std::ostream& operator<< (std::ostream& str, const EGLContextFmt& fmt) 237 { 238 if (fmt.context == EGL_NO_CONTEXT) 239 return str << "EGL_NO_CONTEXT"; 240 else 241 return str << toHex(fmt.context); 242 } 243 244 // API entry-point implementations are auto-generated 245 #include "egluCallLogWrapper.inl" 246 247 } // eglu 248
