framework/egl/egluStrUtil.cpp

   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 String Utilities.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "egluStrUtil.hpp"
  25 #include "eglwEnums.hpp"
  26
  27 namespace eglu
  28 {
  29
  30 std::ostream& operator<< (std::ostream& str, const ConfigAttribValueFmt& attribFmt)
  31 {
  32         switch (attribFmt.attribute)
  33         {
  34                 case EGL_COLOR_BUFFER_TYPE:
  35                         return str << getColorBufferTypeStr(attribFmt.value);
  36
  37                 case EGL_CONFIG_CAVEAT:
  38                         return str << getConfigCaveatStr(attribFmt.value);
  39
  40                 case EGL_CONFORMANT:
  41                 case EGL_RENDERABLE_TYPE:
  42                         return str << getAPIBitsStr(attribFmt.value);
  43
  44                 case EGL_SURFACE_TYPE:
  45                         return str << getSurfaceBitsStr(attribFmt.value);
  46
  47                 case EGL_MATCH_NATIVE_PIXMAP:
  48                         if (attribFmt.value == EGL_NONE)
  49                                 return str << "EGL_NONE";
  50                         else
  51                                 return str << tcu::toHex(attribFmt.value);
  52
  53                 case EGL_TRANSPARENT_TYPE:
  54                         return str << getTransparentTypeStr(attribFmt.value);
  55
  56                 case EGL_BIND_TO_TEXTURE_RGB:
  57                 case EGL_BIND_TO_TEXTURE_RGBA:
  58                 case EGL_NATIVE_RENDERABLE:
  59                         return str << getBoolDontCareStr(attribFmt.value);
  60
  61                 case EGL_ALPHA_MASK_SIZE:
  62                 case EGL_ALPHA_SIZE:
  63                 case EGL_BLUE_SIZE:
  64                 case EGL_BUFFER_SIZE:
  65                 case EGL_CONFIG_ID:
  66                 case EGL_DEPTH_SIZE:
  67                 case EGL_GREEN_SIZE:
  68                 case EGL_LEVEL:
  69                 case EGL_LUMINANCE_SIZE:
  70                 case EGL_MAX_SWAP_INTERVAL:
  71                 case EGL_MIN_SWAP_INTERVAL:
  72                 case EGL_RED_SIZE:
  73                 case EGL_SAMPLE_BUFFERS:
  74                 case EGL_SAMPLES:
  75                 case EGL_STENCIL_SIZE:
  76                 case EGL_TRANSPARENT_RED_VALUE:
  77                 case EGL_TRANSPARENT_GREEN_VALUE:
  78                 case EGL_TRANSPARENT_BLUE_VALUE:
  79                         return str << (int)attribFmt.value;
  80
  81                 default:
  82                         return str << tcu::toHex(attribFmt.value);
  83         }
  84 }
  85
  86 std::ostream& operator<< (std::ostream& str, const ContextAttribValueFmt& attribFmt)
  87 {
  88         switch (attribFmt.attribute)
  89         {
  90                 case EGL_CONFIG_ID:
  91                 case EGL_CONTEXT_CLIENT_VERSION:
  92                         return str << (int)attribFmt.value;
  93
  94                 case EGL_CONTEXT_CLIENT_TYPE:
  95                         return str << getAPIStr(attribFmt.value);
  96
  97                 case EGL_RENDER_BUFFER:
  98                         return str << getRenderBufferStr(attribFmt.value);
  99
 100                 default:
 101                         return str << tcu::toHex(attribFmt.value);
 102         }
 103 }
 104
 105 std::ostream& operator<< (std::ostream& str, const SurfaceAttribValueFmt& attribFmt)
 106 {
 107         switch (attribFmt.attribute)
 108         {
 109                 case EGL_CONFIG_ID:
 110                 case EGL_WIDTH:
 111                 case EGL_HEIGHT:
 112                 case EGL_HORIZONTAL_RESOLUTION:
 113                 case EGL_VERTICAL_RESOLUTION:
 114                 case EGL_PIXEL_ASPECT_RATIO:
 115                         return str << (int)attribFmt.value;
 116
 117                 case EGL_LARGEST_PBUFFER:
 118                 case EGL_MIPMAP_TEXTURE:
 119                         return str << getBoolDontCareStr(attribFmt.value);
 120
 121                 case EGL_MULTISAMPLE_RESOLVE:
 122                         return str << getMultisampleResolveStr(attribFmt.value);
 123
 124                 case EGL_RENDER_BUFFER:
 125                         return str << getRenderBufferStr(attribFmt.value);
 126
 127                 case EGL_SWAP_BEHAVIOR:
 128                         return str << getSwapBehaviorStr(attribFmt.value);
 129
 130                 case EGL_TEXTURE_FORMAT:
 131                         return str << getTextureFormatStr(attribFmt.value);
 132
 133                 case EGL_TEXTURE_TARGET:
 134                         return str << getTextureTargetStr(attribFmt.value);
 135
 136                 case EGL_ALPHA_FORMAT:
 137                         return str << getAlphaFormatStr(attribFmt.value);
 138
 139                 case EGL_COLORSPACE:
 140                         return str << getColorspaceStr(attribFmt.value);
 141
 142                 default:
 143                         return str << tcu::toHex(attribFmt.value);
 144         }
 145 }
 146
 147 std::ostream& operator<< (std::ostream& str, const ConfigAttribListFmt& fmt)
 148 {
 149         int pos = 0;
 150
 151         str << "{ ";
 152
 153         for (;;)
 154         {
 155                 int attrib = fmt.attribs[pos];
 156
 157                 if (pos != 0)
 158                         str << ", ";
 159
 160                 if (attrib == EGL_NONE)
 161                 {
 162                         // Terminate.
 163                         str << "EGL_NONE";
 164                         break;
 165                 }
 166
 167                 const char*     attribName = getConfigAttribName(attrib);
 168
 169                 if (attribName)
 170                 {
 171                         // Valid attribute, print value.
 172                         str << attribName << ", " << getConfigAttribValueStr(attrib, fmt.attribs[pos+1]);
 173                         pos += 2;
 174                 }
 175                 else
 176                 {
 177                         // Invalid attribute. Terminate parsing.
 178                         str << tcu::toHex(attrib) << ", ???";
 179                         break;
 180                 }
 181         }
 182
 183         str << " }";
 184         return str;
 185 }
 186
 187 std::ostream& operator<< (std::ostream& str, const SurfaceAttribListFmt& fmt)
 188 {
 189         int pos = 0;
 190
 191         str << "{ ";
 192
 193         for (;;)
 194         {
 195                 int attrib = fmt.attribs[pos];
 196
 197                 if (pos != 0)
 198                         str << ", ";
 199
 200                 if (attrib == EGL_NONE)
 201                 {
 202                         // Terminate.
 203                         str << "EGL_NONE";
 204                         break;
 205                 }
 206
 207                 const char*     attribName = getSurfaceAttribName(attrib);
 208
 209                 if (attribName)
 210                 {
 211                         // Valid attribute, print value.
 212                         str << attribName << ", " << getSurfaceAttribValueStr(attrib, fmt.attribs[pos+1]);
 213                         pos += 2;
 214                 }
 215                 else
 216                 {
 217                         // Invalid attribute. Terminate parsing.
 218                         str << tcu::toHex(attrib) << ", ???";
 219                         break;
 220                 }
 221         }
 222
 223         str << " }";
 224         return str;
 225 }
 226
 227 std::ostream& operator<< (std::ostream& str, const ContextAttribListFmt& fmt)
 228 {
 229         int pos = 0;
 230
 231         str << "{ ";
 232
 233         for (;;)
 234         {
 235                 int attrib = fmt.attribs[pos];
 236
 237                 if (pos != 0)
 238                         str << ", ";
 239
 240                 if (attrib == EGL_NONE)
 241                 {
 242                         // Terminate.
 243                         str << "EGL_NONE";
 244                         break;
 245                 }
 246
 247                 const char*     attribName = getContextAttribName(attrib);
 248
 249                 if (attribName)
 250                 {
 251                         // Valid attribute, print value.
 252                         str << attribName << ", " << getContextAttribValueStr(attrib, fmt.attribs[pos+1]);
 253                         pos += 2;
 254                 }
 255                 else
 256                 {
 257                         // Invalid attribute. Terminate parsing.
 258                         str << tcu::toHex(attrib) << ", ???";
 259                         break;
 260                 }
 261         }
 262
 263         str << " }";
 264         return str;
 265 }
 266
 267 #include "egluStrUtil.inl"
 268
 269 } // eglu