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 "deStringUtil.hpp" 27 #include "deInt32.h" 28 29 namespace eglu 30 { 31 32 using tcu::toHex; 33 using tcu::TestLog; 34 35 CallLogWrapper::CallLogWrapper (TestLog& log) 36 : m_log (log) 37 , m_enableLog (false) 38 { 39 } 40 41 CallLogWrapper::~CallLogWrapper (void) 42 { 43 } 44 45 // Pointer formatter. 46 47 template <typename T> 48 class PointerFmt 49 { 50 public: 51 const T* arr; 52 deUint32 size; 53 54 PointerFmt (const T* arr_, deUint32 size_) : arr(arr_), size(size_) {} 55 }; 56 57 template <typename T> 58 std::ostream& operator<< (std::ostream& str, PointerFmt<T> fmt) 59 { 60 if (fmt.arr != DE_NULL) 61 { 62 str << "{ "; 63 for (deUint32 ndx = 0; ndx < fmt.size; ndx++) 64 { 65 if (ndx != 0) 66 str << ", "; 67 str << fmt.arr[ndx]; 68 } 69 str << " }"; 70 return str; 71 } 72 else 73 return str << "(null)"; 74 } 75 76 template <typename T> 77 inline PointerFmt<T> getPointerStr (const T* arr, deUint32 size) 78 { 79 return PointerFmt<T>(arr, size); 80 } 81 82 typedef const char* (*GetEnumNameFunc) (int value); 83 84 // Enum pointer formatter. 85 86 class EnumPointerFmt 87 { 88 public: 89 const int* value; 90 GetEnumNameFunc getName; 91 92 EnumPointerFmt (const int* value_, GetEnumNameFunc getName_) : value(value_), getName(getName_) {} 93 }; 94 95 inline std::ostream& operator<< (std::ostream& str, EnumPointerFmt fmt) 96 { 97 if (fmt.value) 98 return str << tcu::Format::Enum(fmt.getName, *fmt.value); 99 else 100 return str << "(null)"; 101 } 102 103 inline EnumPointerFmt getEnumPointerStr (const int* value, GetEnumNameFunc getName) 104 { 105 return EnumPointerFmt(value, getName); 106 } 107 108 // String formatter. 109 110 class StringFmt 111 { 112 public: 113 const char* str; 114 StringFmt (const char* str_) : str(str_) {} 115 }; 116 117 inline std::ostream& operator<< (std::ostream& str, StringFmt fmt) 118 { 119 return str << (fmt.str ? fmt.str : "NULL"); 120 } 121 122 inline StringFmt getStringStr (const char* value) { return StringFmt(value); } 123 124 // Config attrib pointer formatter 125 126 class ConfigAttribValuePointerFmt 127 { 128 public: 129 deUint32 attrib; 130 const int* value; 131 ConfigAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {} 132 }; 133 134 inline ConfigAttribValuePointerFmt getConfigAttribValuePointerStr (deUint32 attrib, const int* value) { return ConfigAttribValuePointerFmt(attrib, value); } 135 136 inline std::ostream& operator<< (std::ostream& str, const ConfigAttribValuePointerFmt& fmt) 137 { 138 if (fmt.value) 139 return str << getConfigAttribValueStr(fmt.attrib, *fmt.value); 140 else 141 return str << "NULL"; 142 } 143 144 // Context attrib pointer formatter 145 146 class ContextAttribValuePointerFmt 147 { 148 public: 149 deUint32 attrib; 150 const int* value; 151 ContextAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {} 152 }; 153 154 inline ContextAttribValuePointerFmt getContextAttribValuePointerStr (deUint32 attrib, const int* value) { return ContextAttribValuePointerFmt(attrib, value); } 155 156 inline std::ostream& operator<< (std::ostream& str, const ContextAttribValuePointerFmt& fmt) 157 { 158 if (fmt.value) 159 return str << getContextAttribValueStr(fmt.attrib, *fmt.value); 160 else 161 return str << "NULL"; 162 } 163 164 // Surface attrib pointer formatter 165 166 class SurfaceAttribValuePointerFmt 167 { 168 public: 169 deUint32 attrib; 170 const int* value; 171 SurfaceAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {} 172 }; 173 174 inline SurfaceAttribValuePointerFmt getSurfaceAttribValuePointerStr (deUint32 attrib, const int* value) { return SurfaceAttribValuePointerFmt(attrib, value); } 175 176 inline std::ostream& operator<< (std::ostream& str, const SurfaceAttribValuePointerFmt& fmt) 177 { 178 if (fmt.value) 179 return str << getSurfaceAttribValueStr(fmt.attrib, *fmt.value); 180 else 181 return str << "NULL"; 182 } 183 184 // EGLDisplay formatter 185 186 class EGLDisplayFmt 187 { 188 public: 189 EGLDisplay display; 190 EGLDisplayFmt (EGLDisplay display_) : display(display_) {} 191 }; 192 193 inline EGLDisplayFmt getEGLDisplayStr (EGLDisplay display) { return EGLDisplayFmt(display); } 194 195 inline std::ostream& operator<< (std::ostream& str, const EGLDisplayFmt& fmt) 196 { 197 if (fmt.display == EGL_NO_DISPLAY) 198 return str << "EGL_NO_DISPLAY"; 199 else 200 return str << toHex(fmt.display); 201 } 202 203 // EGLSurface formatter 204 205 class EGLSurfaceFmt 206 { 207 public: 208 EGLSurface display; 209 EGLSurfaceFmt (EGLSurface display_) : display(display_) {} 210 }; 211 212 inline EGLSurfaceFmt getEGLSurfaceStr (EGLSurface display) { return EGLSurfaceFmt(display); } 213 214 inline std::ostream& operator<< (std::ostream& str, const EGLSurfaceFmt& fmt) 215 { 216 if (fmt.display == EGL_NO_SURFACE) 217 return str << "EGL_NO_SURFACE"; 218 else 219 return str << toHex(fmt.display); 220 } 221 222 // EGLContext formatter 223 224 class EGLContextFmt 225 { 226 public: 227 EGLContext display; 228 EGLContextFmt (EGLContext display_) : display(display_) {} 229 }; 230 231 inline EGLContextFmt getEGLContextStr (EGLContext display) { return EGLContextFmt(display); } 232 233 inline std::ostream& operator<< (std::ostream& str, const EGLContextFmt& fmt) 234 { 235 if (fmt.display == EGL_NO_CONTEXT) 236 return str << "EGL_NO_CONTEXT"; 237 else 238 return str << toHex(fmt.display); 239 } 240 241 // API entry-point implementations are auto-generated 242 #include "egluCallLogWrapper.inl" 243 244 } // eglu 245
