Merge remote-tracking branch 'origin/tizen' into new_text
[platform/core/uifw/dali-core.git] / dali / integration-api / debug.cpp
1 /*
2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 // CLASS HEADER
19 #include <dali/integration-api/debug.h>
20
21 // EXTERNAL INCLUDES
22 #include <stdio.h>
23 #include <stdarg.h>
24 #include <string.h>
25 #include <sstream>
26 #include <iomanip>
27
28 // INTERNAL INCLUDES
29 #include <dali/public-api/common/constants.h>
30 #include <dali/public-api/math/matrix3.h>
31 #include <dali/public-api/math/matrix.h>
32 #include <dali/public-api/math/vector3.h>
33 #include <dali/public-api/math/vector4.h>
34 #include <dali/public-api/math/quaternion.h>
35 #include <dali/internal/event/common/thread-local-storage.h>
36
37 namespace Dali
38 {
39
40 namespace // unnamed namespace
41 {
42
43 /**
44  * Generic function to print out any 2-Dimensional array
45  * @param[in] data pointer to the source data stored as float[rows][cols]
46  * @param[in] rows number of rows in 2D array
47  * @param[in] cols number of columns in 2D array
48  * @param[in] precision - the precision to write the float data.
49  * @param[in] indent - the indent level to use.
50  * @return string - the text representation of the 2D array
51  */
52 std::string Array2DToString(const float *data, unsigned int rows, unsigned int cols, size_t precision, size_t indent)
53 {
54   std::ostringstream oss;
55
56   std::ios_base::fmtflags mask = oss.flags();
57   mask &= ~std::ios_base::scientific;
58   mask |=  std::ios_base::fixed;
59
60   for(unsigned int rowIdx = 0; rowIdx < rows; rowIdx++)
61   {
62     oss  << std::setw(indent) << std::setfill(' ') << ' ' << "[ ";
63     oss  << std::setfill(' ') << std::setprecision(precision) << std::right << std::setiosflags(mask);
64
65     for(unsigned int colIdx = 0; colIdx < cols; colIdx++)
66     {
67       oss << std::setw(precision + 6) << (*data++) << ' ';
68     }
69
70     oss << ']' << std::endl;
71   }
72
73   return oss.str();
74 }
75
76 }
77
78 namespace Integration
79 {
80
81 namespace Log
82 {
83
84 __thread LogFunction gthreadLocalLogFunction = NULL;
85
86 /* Forward declarations */
87 std::string FormatToString(const char *format, ...);
88 std::string ArgListToString(const char *format, va_list args);
89
90 void LogMessage(DebugPriority priority, const char* format, ...)
91 {
92   if ( !gthreadLocalLogFunction )
93   {
94     return;
95   }
96
97   va_list arg;
98   va_start(arg, format);
99   std::string message = ArgListToString(format, arg);
100   va_end(arg);
101
102   gthreadLocalLogFunction(priority,message);
103 }
104
105 void InstallLogFunction(const LogFunction& logFunction)
106 {
107   // TLS stores a pointer to an object.
108   // It needs to be allocated on the heap, because TLS will destroy it when the thread exits.
109
110   gthreadLocalLogFunction = logFunction;
111 }
112
113 void UninstallLogFunction()
114 {
115   gthreadLocalLogFunction = NULL;
116 }
117
118 #ifdef DEBUG_ENABLED
119
120 /*Change false to true if trace is needed but don't commit to codeline*/
121 Filter* Filter::gRender     = Filter::New(Debug::Concise, false, "LOG_RENDER");
122 Filter* Filter::gResource   = Filter::New(Debug::Concise, false, "LOG_RESOURCE");
123 Filter* Filter::gGLResource = Filter::New(Debug::Concise, false, "LOG_GL_RESOURCE");
124 Filter* Filter::gObject     = NULL;
125 Filter* Filter::gImage      = Filter::New(Debug::Concise, false, "LOG_IMAGE");
126 Filter* Filter::gModel      = Filter::New(Debug::Concise, false, "LOG_MODEL");
127 Filter* Filter::gNode       = NULL;
128 Filter* Filter::gElement    = NULL;
129 Filter* Filter::gActor      = Filter::New(Debug::Concise, false, "LOG_ACTOR");
130 Filter* Filter::gShader     = Filter::New(Debug::Concise, false, "LOG_SHADER");
131 Filter* Filter::gDynamics   = Filter::New(Debug::Concise, false, "LOG_DYNAMICS");
132
133 Filter::FilterList* Filter::GetActiveFilters()
134 {
135   static Filter::FilterList* activeFilters = new FilterList;
136   return activeFilters;
137 }
138
139 Filter* Filter::New( LogLevel level, bool trace, const char * environmentVariableName )
140 {
141   char * environmentVariableValue = getenv( environmentVariableName );
142   if ( environmentVariableValue )
143   {
144     unsigned int envLevel(0);
145     char envTraceString(0);
146     sscanf( environmentVariableValue, "%u,%c", &envLevel, &envTraceString );
147
148     if ( envLevel > Verbose )
149     {
150       envLevel = Verbose;
151     }
152     level = LogLevel( envLevel );
153
154     // Just use 'f' and 't' as it's faster than doing full string comparisons
155     if ( envTraceString == 't' )
156     {
157       trace = true;
158     }
159     else if ( envTraceString == 'f' )
160     {
161       trace = false;
162     }
163   }
164
165   Filter* filter = new Filter(level, trace);
166   filter->mNesting++;
167   GetActiveFilters()->push_back(filter);
168   return filter;
169 }
170
171 /**
172  * Enable trace on all filters.
173  */
174 void Filter::EnableGlobalTrace()
175 {
176   for(FilterIter iter = GetActiveFilters()->begin(); iter != GetActiveFilters()->end(); iter++)
177   {
178     (*iter)->EnableTrace();
179   }
180 }
181
182 /**
183  * Disable trace on all filters.
184  */
185 void Filter::DisableGlobalTrace()
186 {
187   for(FilterIter iter = GetActiveFilters()->begin(); iter != GetActiveFilters()->end(); iter++)
188   {
189     (*iter)->DisableTrace();
190   }
191 }
192
193
194 void Filter::Log(LogLevel level, const char* format, ...)
195 {
196   if(level <= mLoggingLevel)
197   {
198     va_list arg;
199     va_start(arg, format);
200
201     char *buffer = NULL;
202     int numChars = asprintf(&buffer, "%-*c %s", mNesting, ':', format);
203     if(numChars >= 0) // No error
204     {
205       std::string message = ArgListToString(buffer, arg);
206       LogMessage(DebugInfo, message.c_str());
207       free(buffer);
208     }
209     va_end(arg);
210   }
211 }
212
213
214 TraceObj::TraceObj(Filter* filter, const char*format, ...) : mFilter(filter)
215 {
216   if(mFilter && mFilter->IsTraceEnabled())
217   {
218     va_list arg;
219     va_start(arg, format);
220     mMessage = ArgListToString(format, arg);
221     va_end(arg);
222
223     LogMessage(DebugInfo, "Entr%-*c %s\n", mFilter->mNesting, ':', mMessage.c_str());
224     ++mFilter->mNesting;
225   }
226 }
227
228 TraceObj::~TraceObj()
229 {
230   if(mFilter && mFilter->IsTraceEnabled())
231   {
232     if (mFilter->mNesting)
233     {
234       --mFilter->mNesting;
235     }
236     LogMessage(DebugInfo, "Exit%-*c %s\n", mFilter->mNesting, ':', mMessage.c_str());
237   }
238 }
239
240 #endif // DEBUG_ENABLED
241
242
243 std::string ArgListToString(const char *format, va_list args)
244 {
245   std::string str; // empty string
246   if(format != NULL)
247   {
248     char* buffer = NULL;
249     int err = vasprintf(&buffer, format, args);
250     if(err >= 0) // No error
251     {
252       str = buffer;
253       free(buffer);
254     }
255   }
256   return str;
257 }
258
259 std::string FormatToString(const char *format, ...)
260 {
261   va_list arg;
262   va_start(arg, format);
263   std::string s = ArgListToString(format, arg);
264   va_end(arg);
265   return s;
266 }
267
268 std::string ColorToString(const Vector4& color)
269 {
270   std::ostringstream oss;
271   oss << "<R:" << color.r << " G:" << color.g << " B:" << color.b << " A:" << color.a << ">";
272   return oss.str();
273 }
274
275 std::string Vector4ToString(const Vector4& v, size_t precision, size_t indent)
276 {
277   std::ostringstream oss;
278   oss << std::setw(indent+3) << std::setfill(' ') << std::setprecision(precision) << std::right;
279   oss << "<X:" << std::setw(precision+4) << v.x
280       << " Y:" << std::setw(precision+4) << v.y
281       << " Z:" << std::setw(precision+4) << v.z
282       << " W:" << std::setw(precision+4) << v.w << ">";
283   return oss.str();
284 }
285
286 std::string Vector3ToString(const Vector3& v, size_t precision, size_t indent)
287 {
288   std::ostringstream oss;
289   oss << std::setw(indent+3) << std::setfill(' ') << std::setprecision(precision) << std::right << std::setiosflags(std::ios_base::fixed);
290   oss << "<X:" << std::setw(precision+4) << v.x
291       << " Y:" << std::setw(precision+4) << v.y
292       << " Z:" << std::setw(precision+4) << v.z << ">";
293   return oss.str();
294 }
295
296 std::string QuaternionToString(const Quaternion& q, size_t precision, size_t indent)
297 {
298   std::ostringstream oss;
299
300   Vector3 axis;
301   float angle;
302   q.ToAxisAngle(axis, angle);
303
304   oss << std::setw(indent+3) << std::setfill(' ') << std::setprecision(precision) << std::right;
305   oss << "<A:" << std::setw(precision+4) << angle * 180.0 / Math::PI << ", " << Vector3ToString(axis, precision, 0) << ">";
306
307   return oss.str();
308 }
309
310 std::string Matrix3ToString(const Matrix3& m, size_t precision, size_t indent)
311 {
312   return Array2DToString(m.AsFloat(), 3, 3, precision, indent);
313 }
314
315 std::string MatrixToString(const Matrix& m, size_t precision, size_t indent)
316 {
317   return Array2DToString(m.AsFloat(), 4, 4, precision, indent);
318 }
319
320 } // namespace Log
321
322 } // namespace Integration
323
324 } // namespace Dali