|
13
|
1 |
// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
2 |
// All rights reserved.
|
|
|
3 |
// This component and the accompanying materials are made available
|
|
|
4 |
// under the terms of "Eclipse Public License v1.0"
|
|
|
5 |
// which accompanies this distribution, and is available
|
|
|
6 |
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
|
7 |
//
|
|
|
8 |
// Initial Contributors:
|
|
|
9 |
// Nokia Corporation - initial contribution.
|
|
|
10 |
//
|
|
|
11 |
// Contributors:
|
|
|
12 |
//
|
|
|
13 |
// Description:
|
|
|
14 |
// Guest egl implementation debugging support
|
|
|
15 |
|
|
|
16 |
#include <e32debug.h>
|
|
|
17 |
#include "eglapi.h"
|
|
|
18 |
|
|
|
19 |
|
|
|
20 |
#ifdef _DEBUG
|
|
|
21 |
|
|
|
22 |
// These functions help with verbose debug logging of EGL Attibutes
|
|
|
23 |
|
|
|
24 |
// Try to get an attribute name string, and a description of the value - switch statements can be extended for later EGL versions
|
|
|
25 |
void TAttribUtils::TraceAttribNames(EGLint aAttrib, EGLint aValue, char** aAttrName, char** aValueName)
|
|
|
26 |
{
|
|
|
27 |
char* attrName = NULL;
|
|
|
28 |
char* valueName = NULL;
|
|
|
29 |
switch (aAttrib)
|
|
|
30 |
{
|
|
|
31 |
case EGL_BUFFER_SIZE: attrName = "EGL_BUFFER_SIZE"; break;
|
|
|
32 |
case EGL_ALPHA_SIZE: attrName = "EGL_ALPHA_SIZE"; break;
|
|
|
33 |
case EGL_BLUE_SIZE: attrName = "EGL_BLUE_SIZE"; break;
|
|
|
34 |
case EGL_GREEN_SIZE: attrName = "EGL_GREEN_SIZE"; break;
|
|
|
35 |
case EGL_RED_SIZE: attrName = "EGL_RED_SIZE"; break;
|
|
|
36 |
case EGL_DEPTH_SIZE: attrName = "EGL_DEPTH_SIZE"; break;
|
|
|
37 |
case EGL_STENCIL_SIZE: attrName = "EGL_STENCIL_SIZE"; break;
|
|
|
38 |
case EGL_CONFIG_CAVEAT: attrName = "EGL_CONFIG_CAVEAT";
|
|
|
39 |
switch (aValue)
|
|
|
40 |
{
|
|
|
41 |
// Config attribute values
|
|
|
42 |
case EGL_SLOW_CONFIG: valueName = "EGL_SLOW_CONFIG"; break;
|
|
|
43 |
case EGL_NON_CONFORMANT_CONFIG: valueName = "EGL_NON_CONFORMANT_CONFIG"; break;
|
|
|
44 |
}
|
|
|
45 |
break;
|
|
|
46 |
case EGL_CONFIG_ID: attrName = "EGL_CONFIG_ID"; break;
|
|
|
47 |
case EGL_LEVEL: attrName = "EGL_LEVEL"; break;
|
|
|
48 |
case EGL_MAX_PBUFFER_HEIGHT: attrName = "EGL_MAX_PBUFFER_HEIGHT"; break;
|
|
|
49 |
case EGL_MAX_PBUFFER_PIXELS: attrName = "EGL_MAX_PBUFFER_PIXELS"; break;
|
|
|
50 |
case EGL_MAX_PBUFFER_WIDTH: attrName = "EGL_MAX_PBUFFER_WIDTH"; break;
|
|
|
51 |
case EGL_NATIVE_RENDERABLE: attrName = "EGL_NATIVE_RENDERABLE"; break;
|
|
|
52 |
case EGL_NATIVE_VISUAL_ID: attrName = "EGL_NATIVE_VISUAL_ID"; break;
|
|
|
53 |
case EGL_NATIVE_VISUAL_TYPE: attrName = "EGL_NATIVE_VISUAL_TYPE"; break;
|
|
|
54 |
case EGL_PRESERVED_RESOURCES: attrName = "EGL_PRESERVED_RESOURCES"; break;
|
|
|
55 |
case EGL_SAMPLES: attrName = "EGL_SAMPLES"; break;
|
|
|
56 |
case EGL_SAMPLE_BUFFERS: attrName = "EGL_SAMPLE_BUFFERS"; break;
|
|
|
57 |
case EGL_SURFACE_TYPE: attrName = "EGL_SURFACE_TYPE";
|
|
|
58 |
switch(aValue & 7)
|
|
|
59 |
{
|
|
|
60 |
case 0: valueName = "* | EGL_NONE"; break;
|
|
|
61 |
case 1: valueName = "* | PBUFFER"; break; // EGL_PBUFFER_BIT
|
|
|
62 |
case 2: valueName = "* | PIXMAP"; break; // EGL_PIXMAP_BIT
|
|
|
63 |
case 3: valueName = "* | PIXMAP | PBUFFER"; break;
|
|
|
64 |
case 4: valueName = "* | WINDOW"; break; // EGL_WINDOW_BIT
|
|
|
65 |
case 5: valueName = "* | WINDOW | PBUFFER"; break;
|
|
|
66 |
case 6: valueName = "* | WINDOW | PIXMAP"; break;
|
|
|
67 |
case 7: valueName = "* | WINDOW | PIXMAP | PBUFFER"; break;
|
|
|
68 |
}
|
|
|
69 |
break;
|
|
|
70 |
case EGL_TRANSPARENT_TYPE: attrName = "EGL_TRANSPARENT_TYPE";
|
|
|
71 |
if (aValue == EGL_TRANSPARENT_RGB)
|
|
|
72 |
valueName = "EGL_TRANSPARENT_RGB";
|
|
|
73 |
break;
|
|
|
74 |
case EGL_TRANSPARENT_BLUE_VALUE: attrName = "EGL_TRANSPARENT_BLUE_VALUE"; break;
|
|
|
75 |
case EGL_TRANSPARENT_GREEN_VALUE: attrName = "EGL_TRANSPARENT_GREEN_VALUE"; break;
|
|
|
76 |
case EGL_TRANSPARENT_RED_VALUE: attrName = "EGL_TRANSPARENT_RED_VALUE"; break;
|
|
|
77 |
case EGL_BIND_TO_TEXTURE_RGB: attrName = "EGL_BIND_TO_TEXTURE_RGB"; break;
|
|
|
78 |
case EGL_BIND_TO_TEXTURE_RGBA: attrName = "EGL_BIND_TO_TEXTURE_RGBA"; break;
|
|
|
79 |
case EGL_MIN_SWAP_INTERVAL: attrName = "EGL_MIN_SWAP_INTERVAL"; break;
|
|
|
80 |
case EGL_MAX_SWAP_INTERVAL: attrName = "EGL_MAX_SWAP_INTERVAL"; break;
|
|
|
81 |
case EGL_LUMINANCE_SIZE: attrName = "EGL_LUMINANCE_SIZE"; break;
|
|
|
82 |
case EGL_ALPHA_MASK_SIZE: attrName = "EGL_ALPHA_MASK_SIZE"; break;
|
|
|
83 |
case EGL_COLOR_BUFFER_TYPE: attrName = "EGL_COLOR_BUFFER_TYPE";
|
|
|
84 |
switch (aValue)
|
|
|
85 |
{
|
|
|
86 |
// EGL_COLOR_BUFFER_TYPE values
|
|
|
87 |
case EGL_RGB_BUFFER: valueName = "EGL_RGB_BUFFER"; break;
|
|
|
88 |
case EGL_LUMINANCE_BUFFER: valueName = "EGL_LUMINANCE_BUFFER"; break;
|
|
|
89 |
}
|
|
|
90 |
break;
|
|
|
91 |
case EGL_RENDERABLE_TYPE: attrName = "EGL_RENDERABLE_TYPE";
|
|
|
92 |
switch(aValue)
|
|
|
93 |
{
|
|
|
94 |
case 0: valueName = "EGL_NONE"; break;
|
|
|
95 |
case 1: valueName = "GL-ES"; break;
|
|
|
96 |
case 2: valueName = "VG"; break;
|
|
|
97 |
case 3: valueName = "VG | GL-ES"; break;
|
|
|
98 |
case 4: valueName = "GL-ES2"; break;
|
|
|
99 |
case 5: valueName = "GL-ES2 | GL-ES"; break;
|
|
|
100 |
case 6: valueName = "GL-ES2 | VG"; break;
|
|
|
101 |
case 7: valueName = "GL-ES2 | VG | GL-ES"; break;
|
|
|
102 |
case 8: valueName = "GL"; break;
|
|
|
103 |
case 9: valueName = "GL | GL-ES"; break;
|
|
|
104 |
case 10: valueName = "GL | VG"; break;
|
|
|
105 |
case 11: valueName = "GL | VG | GL-ES"; break;
|
|
|
106 |
case 12: valueName = "GL | GL-ES2"; break;
|
|
|
107 |
case 13: valueName = "GL | GL-ES2 | GL-ES"; break;
|
|
|
108 |
case 14: valueName = "GL | GL-ES2 | VG"; break;
|
|
|
109 |
case 15: valueName = "GL | GL-ES2 | VG | GL-ES"; break;
|
|
|
110 |
}
|
|
|
111 |
break;
|
|
|
112 |
case EGL_MATCH_NATIVE_PIXMAP: attrName = "EGL_MATCH_NATIVE_PIXMAP"; break; // Pseudo-attribute (not queryable)
|
|
|
113 |
case EGL_CONFORMANT: attrName = "EGL_CONFORMANT"; break;
|
|
|
114 |
case EGL_HEIGHT: attrName = "EGL_HEIGHT"; break;
|
|
|
115 |
case EGL_WIDTH: attrName = "EGL_WIDTH"; break;
|
|
|
116 |
case EGL_LARGEST_PBUFFER: attrName = "EGL_LARGEST_PBUFFER"; break;
|
|
|
117 |
case EGL_TEXTURE_FORMAT: attrName = "EGL_TEXTURE_FORMAT";
|
|
|
118 |
switch (aValue)
|
|
|
119 |
{
|
|
|
120 |
// config attribute values, for EGL_TEXTURE_FORMAT
|
|
|
121 |
case EGL_NO_TEXTURE: valueName = "EGL_NO_TEXTURE"; break;
|
|
|
122 |
case EGL_TEXTURE_RGB: valueName = "EGL_TEXTURE_RGB"; break;
|
|
|
123 |
case EGL_TEXTURE_RGBA: valueName = "EGL_TEXTURE_RGBA"; break;
|
|
|
124 |
case EGL_TEXTURE_2D: valueName = "EGL_TEXTURE_2D"; break;
|
|
|
125 |
}
|
|
|
126 |
break;
|
|
|
127 |
case EGL_TEXTURE_TARGET: attrName = "EGL_TEXTURE_TARGET"; break;
|
|
|
128 |
case EGL_MIPMAP_TEXTURE: attrName = "EGL_MIPMAP_TEXTURE"; break;
|
|
|
129 |
case EGL_MIPMAP_LEVEL: attrName = "EGL_MIPMAP_LEVEL"; break;
|
|
|
130 |
case EGL_RENDER_BUFFER: attrName = "EGL_RENDER_BUFFER";
|
|
|
131 |
switch (aValue)
|
|
|
132 |
{
|
|
|
133 |
// EGL_RENDER_BUFFER values / BindTexImage / ReleaseTexImage buffer targets
|
|
|
134 |
case EGL_BACK_BUFFER: valueName = "EGL_BACK_BUFFER"; break;
|
|
|
135 |
case EGL_SINGLE_BUFFER: valueName = "EGL_SINGLE_BUFFER"; break;
|
|
|
136 |
}
|
|
|
137 |
break;
|
|
|
138 |
case EGL_VG_COLORSPACE: attrName = "EGL_VG_COLORSPACE";
|
|
|
139 |
switch (aValue)
|
|
|
140 |
{
|
|
|
141 |
// OpenVG color spaces
|
|
|
142 |
case EGL_VG_COLORSPACE_sRGB: valueName = "EGL_VG_COLORSPACE_sRGB"; break;
|
|
|
143 |
case EGL_VG_COLORSPACE_LINEAR: valueName = "EGL_VG_COLORSPACE_LINEAR"; break;
|
|
|
144 |
}
|
|
|
145 |
break;
|
|
|
146 |
case EGL_VG_ALPHA_FORMAT: attrName = "EGL_VG_ALPHA_FORMAT";
|
|
|
147 |
switch (aValue)
|
|
|
148 |
{
|
|
|
149 |
// OpenVG alpha formats
|
|
|
150 |
case EGL_VG_ALPHA_FORMAT_NONPRE: valueName = "EGL_VG_ALPHA_FORMAT_NONPRE"; break;
|
|
|
151 |
case EGL_VG_ALPHA_FORMAT_PRE: valueName = "EGL_VG_ALPHA_FORMAT_PRE"; break;
|
|
|
152 |
}
|
|
|
153 |
break;
|
|
|
154 |
case EGL_HORIZONTAL_RESOLUTION: attrName = "EGL_HORIZONTAL_RESOLUTION"; break;
|
|
|
155 |
case EGL_VERTICAL_RESOLUTION: attrName = "EGL_VERTICAL_RESOLUTION"; break;
|
|
|
156 |
case EGL_PIXEL_ASPECT_RATIO: attrName = "EGL_PIXEL_ASPECT_RATIO"; break;
|
|
|
157 |
case EGL_SWAP_BEHAVIOR: attrName = "EGL_SWAP_BEHAVIOR"; break;
|
|
|
158 |
case EGL_MULTISAMPLE_RESOLVE: attrName = "EGL_MULTISAMPLE_RESOLVE"; break;
|
|
|
159 |
default: // unknown value - maybe buggy data or a later EGL version. Debug prints include the hex anyway.
|
|
|
160 |
break;
|
|
|
161 |
}
|
|
|
162 |
|
|
|
163 |
if (aValue == EGL_NONE)
|
|
|
164 |
valueName = "EGL_NONE";
|
|
|
165 |
if (aAttrib == EGL_NONE)
|
|
|
166 |
attrName = "EGL_NONE";
|
|
|
167 |
|
|
|
168 |
*aAttrName = attrName;
|
|
|
169 |
*aValueName = valueName;
|
|
|
170 |
}
|
|
|
171 |
|
|
|
172 |
// verbose debug logging of EGL Attibute Lists
|
|
|
173 |
void TAttribUtils::TraceAttribList(const EGLint* aAttribList)
|
|
|
174 |
{
|
|
|
175 |
int length = 0;
|
|
|
176 |
if (aAttribList)
|
|
|
177 |
{
|
|
|
178 |
while (aAttribList[length] != EGL_NONE)
|
|
|
179 |
{
|
|
|
180 |
char* attrName = NULL;
|
|
|
181 |
char* valueName = NULL;
|
|
|
182 |
// try to get an attribute name string, and a description of the value
|
|
|
183 |
TraceAttribNames(aAttribList[length], aAttribList[length+1], &attrName, &valueName);
|
|
|
184 |
// print attribute & value as numbers, and also print a string name/description if one could be determined
|
|
|
185 |
if (attrName)
|
|
|
186 |
{
|
|
|
187 |
if (valueName)
|
|
|
188 |
{
|
|
|
189 |
EGL_TRACE(" TraceAttribList aAttribList[%d]=0x%x (\"%s\"), aAttribList[%d]=0x%x (\"%s\")",
|
|
|
190 |
length, aAttribList[length], attrName, length+1, aAttribList[length+1], valueName);
|
|
|
191 |
}
|
|
|
192 |
else
|
|
|
193 |
{
|
|
|
194 |
EGL_TRACE(" TraceAttribList aAttribList[%d]=0x%x (\"%s\"), aAttribList[%d]=0x%x (%d)",
|
|
|
195 |
length, aAttribList[length], attrName, length+1, aAttribList[length+1], aAttribList[length+1]);
|
|
|
196 |
}
|
|
|
197 |
}
|
|
|
198 |
else
|
|
|
199 |
{
|
|
|
200 |
EGL_TRACE(" TraceAttribList aAttribList[%d]=0x%x, aAttribList[%d]=0x%x (%d)",
|
|
|
201 |
length, aAttribList[length], length+1, aAttribList[length+1], aAttribList[length+1]);
|
|
|
202 |
}
|
|
|
203 |
length += 2;
|
|
|
204 |
}
|
|
|
205 |
++length;
|
|
|
206 |
}
|
|
|
207 |
}
|
|
|
208 |
|
|
|
209 |
// verbose debug logging of EGL Get Attibute fn
|
|
|
210 |
void TAttribUtils::TraceGetAttrib(char* aApiName, char* aObjType, EGLDisplay aDisplay, EGLint aObject, EGLint aAttribute, EGLint *aValue, EGLBoolean aResult)
|
|
|
211 |
{
|
|
|
212 |
char* attrName = NULL;
|
|
|
213 |
char* valueName = NULL;
|
|
|
214 |
if (aResult)
|
|
|
215 |
{
|
|
|
216 |
// try to get an attribute name string, and a description of the value
|
|
|
217 |
TraceAttribNames(aAttribute, *aValue, &attrName, &valueName);
|
|
|
218 |
// print attribute & value as numbers, and also print a string name/description if one could be determined
|
|
|
219 |
if (attrName)
|
|
|
220 |
{
|
|
|
221 |
if (valueName)
|
|
|
222 |
{
|
|
|
223 |
EGL_TRACE("%s succeeded: aDisplay=%d, %s=%d, aAttrib=0x%x (\"%s\"), aValue=0x%x (\"%s\")",
|
|
|
224 |
aApiName, aDisplay, aObjType, aObject, aAttribute, attrName, *aValue, valueName);
|
|
|
225 |
}
|
|
|
226 |
else
|
|
|
227 |
{
|
|
|
228 |
EGL_TRACE("%s succeeded: aDisplay=%d, %s=%d, aAttrib=0x%x (\"%s\"), aValue=0x%x (%d)",
|
|
|
229 |
aApiName, aDisplay, aObjType, aObject, aAttribute, attrName, *aValue, *aValue);
|
|
|
230 |
}
|
|
|
231 |
}
|
|
|
232 |
else
|
|
|
233 |
{
|
|
|
234 |
EGL_TRACE("%s succeeded: aDisplay=%d, %s=%d, aAttrib=0x%x, aValue=0x%x (%d)",
|
|
|
235 |
aApiName, aDisplay, aObjType, aObject, aAttribute, *aValue, *aValue);
|
|
|
236 |
}
|
|
|
237 |
}
|
|
|
238 |
else
|
|
|
239 |
{
|
|
|
240 |
// try to get an attribute name string
|
|
|
241 |
TraceAttribNames(aAttribute, 0, &attrName, &valueName);
|
|
|
242 |
if (attrName)
|
|
|
243 |
{
|
|
|
244 |
EGL_TRACE("%s failed: aDisplay=%d, %s=%d, attribute=0x%x (\"%s\")",
|
|
|
245 |
aApiName, aDisplay, aObjType, aObject, aAttribute, attrName);
|
|
|
246 |
}
|
|
|
247 |
else
|
|
|
248 |
{
|
|
|
249 |
EGL_TRACE("%s failed: aDisplay=%d, %s=%d, attribute=0x%x",
|
|
|
250 |
aApiName, aDisplay, aObjType, aObject, aAttribute);
|
|
|
251 |
}
|
|
|
252 |
}
|
|
|
253 |
}
|
|
|
254 |
|
|
|
255 |
|
|
|
256 |
// verbose debug logging of EGL Get Attibute fn
|
|
|
257 |
void TAttribUtils::TraceSetAttrib(char* aApiName, char* aObjType, EGLDisplay aDisplay, EGLint aObject, EGLint aAttribute, EGLint aValue)
|
|
|
258 |
{
|
|
|
259 |
char* attrName = NULL;
|
|
|
260 |
char* valueName = NULL;
|
|
|
261 |
// try to get an attribute name string, and a description of the value
|
|
|
262 |
TraceAttribNames(aAttribute, aValue, &attrName, &valueName);
|
|
|
263 |
// print attribute & value as numbers, and also print a string name/description if one could be determined
|
|
|
264 |
if (attrName)
|
|
|
265 |
{
|
|
|
266 |
if (valueName)
|
|
|
267 |
{
|
|
|
268 |
EGL_TRACE("%s: aDisplay=%d, %s=%d, aAttrib=0x%x (\"%s\"), aValue=0x%x (\"%s\")",
|
|
|
269 |
aApiName, aDisplay, aObjType, aObject, aAttribute, attrName, aValue, valueName);
|
|
|
270 |
}
|
|
|
271 |
else
|
|
|
272 |
{
|
|
|
273 |
EGL_TRACE("%s: aDisplay=%d, %s=%d, aAttrib=0x%x (\"%s\"), aValue=0x%x (%d)",
|
|
|
274 |
aApiName, aDisplay, aObjType, aObject, aAttribute, attrName, aValue, aValue);
|
|
|
275 |
}
|
|
|
276 |
}
|
|
|
277 |
else
|
|
|
278 |
{
|
|
|
279 |
EGL_TRACE("%s: aDisplay=%d, %s=%d, aAttrib=0x%x, aValue=0x%x (%d)",
|
|
|
280 |
aApiName, aDisplay, aObjType, aObject, aAttribute, aValue, aValue);
|
|
|
281 |
}
|
|
|
282 |
}
|
|
|
283 |
|
|
|
284 |
|
|
|
285 |
#endif
|
|
|
286 |
|