1
2 /*
3 * Copyright (C) Texas Instruments - http://www.ti.com/
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21 /* =============================================================================
22 * Texas Instruments OMAP(TM) Platform Software
23 * (c) Copyright Texas Instruments, Incorporated. All Rights Reserved.
24 *
25 * Use of this software is controlled by the terms and conditions found
26 * in the license agreement under which this software has been supplied.
27 * =========================================================================== */
28 /**
29 * @file OMX_TI_Debug.h
30 *
31 * This file implements the TI-specific OMX Debug interface
32 *
33 * @path $(CSLPATH)\inc
34 *
35 * @rev 0.1
36 */
37 /* -------------------------------------------------------------------------- */
38 /* =============================================================================
39 *!
40 *! Revision History
41 *! ================================================================
42 *!
43 *! 10-Mar-2009 lm: Revisions appear in reverse chronological order;
44 *! that is, newest first. The date format is dd-Mon-yyyy.
45 * =========================================================================== */
46
47 #ifndef OMX_TI_DEBUG__H
48 #define OMX_TI_DEBUG__H
49
50 #include <ctype.h>
51 #include <utils/Log.h>
52 /*
53 The OMX TI Debug interface allows debug messages to be classified by
54 domain and importance. There are no preset classifications required, but
55 rather these are arbitrary. Nonetheless, all modules using this interface
56 must adhere to these domain and level conventions.
57
58 While it would make sense that errors should be printed at the highest
59 level, we separated errors into their own domain, as even error printing
60 could have additional details that are not always desirable to print.
61
62 In order to facilitate using the debug interface, a set of macros are
63 defined for the common domains and levels.
64
65 Features of the TI Debug interface:
66
67 - debug messages are maskable: only messages for domains marked, and that
68 have levels at least of the mask's level will be printed
69 - there are two output files supported. Error domain output is going to
70 the error file, whereas other outputs usually go into the other output
71 file. This also allows only printing error messages.
72 - colors can be specified for each domain - through this file or the
73 macros
74 - line number information can be added (via a compile time option)
75
76 Compile time flags:
77
78 __OMX_DEBUG__ - enable OMX Debug print calls
79 __OMX_DBG_COLOR__ - enable color output
80 __OMX_DBG_FN__ - print function
81 __OMX_DBG_FILE__ - print file
82 __OMX_DBG_LINE__ - print line number
83 __OMX_DBG_LEVEL__ - print level
84 __OMX_DBG_DOMAIN__ - print domain
85 __OMX_DBG_4ISERROR__ - print level 4 messages into the error file
86
87 __OMX_DBG_ANDROID__ - always outputs to Android log. Otherwise, Android
88 log is only used if output is stderr or stdout.
89
90 Output format is:
91 file:function():line domain<level> message
92
93 */
94
95 /* You can change this file here to globally set the debug configurations
96
97 */
98 #define __OMX_DEBUG__
99 #undef __OMX_DBG_COLOR__
100 #undef __OMX_DBG_FILE__
101 #define __OMX_DBG_FN__
102 #define __OMX_DBG_LINE__
103 #undef __OMX_DBG_DOMAIN__
104 #undef __OMX_DBG_LEVEL__
105 #undef __OMX_DBG_4ISERROR__
106 #undef __OMX_DBG_ANDROID__
107
108 /*
109 * OMX Debug levels specify the importance of the debug print
110 *
111 * 0 - very verbose -- any details, such as system return values, etc.
112 * 1 - quite verbose -- details
113 * 2 - verbose -- main details
114 * 3 - normal -- what an average user would want to see
115 * 4 - quiet -- only important messages -- this would not be
116 * normally used by OMX components except for error
117 * messages as they don't output anything normally.
118 * This could be used by applications and tests.
119 * 5 - very quiet -- crucial/error messages - goes to error file
120 */
121
122 /* this is used as a bitmask currently, so must be 2^n-1 */
123 #define OMX_DBG_MAX_LEVEL 0x0F
124
125 /*
126 * OMX Debug domains specify the system that the messages relate to
127 */
128 #define OMX_DBG_DOM_ERROR 0x1ul /* an error */
129 #define OMX_DBG_DOM_PRINT 0x10ul /* generic prints */
130 #define OMX_DBG_DOM_SYSTEM 0x100ul /* generic OS systems: memory, etc. */
131 #define OMX_DBG_DOM_STATE 0x1000ul /* state transitions */
132 #define OMX_DBG_DOM_BUFFER 0x10000ul /* buffer transfer between */
133 #define OMX_DBG_DOM_DSP 0x100000ul /* DSP communication/transfer */
134 #define OMX_DBG_DOM_COMM 0x1000000ul /* communication */
135 #define OMX_DBG_DOM_MGR 0x10000000ul /* communication with managers */
136
137 #define OMX_DBG_BASEMASK 0x33333333ul /* all domains at normal verbosity */
138
139 /*
140 * Generic DEBUG Settings
141 */
142 struct OMX_TI_Debug
143 {
144 FILE *out; /* standard output file */
145 FILE *err; /* error output file - used for the error domain
146 and crucial messages */
147 FILE *out_opened; /* opened output file */
148 FILE *err_opened; /* opened error file */
149 OMX_U32 mask; /* debug mask */
150 };
151
152 /*
153 * :TRICKY: do { } while (0) makes this behave like any other C function call
154 * even though it contains several statements
155 */
156
157 /* This macro sets the debug mask in the debug structure based on a mask
158 string */
159 #define OMX_DBG_SET_MASK(dbg, mask_str) \
160 do { \
161 if (mask_str) { \
162 sscanf((mask_str), "%lx", &(dbg).mask); \
163 if (strlen(mask_str) < 8) { \
164 (dbg).mask &= ~0ul >> (32 - 4 * strlen(mask_str)); \
165 (dbg).mask |= OMX_DBG_BASEMASK << (4 * strlen(mask_str)); \
166 } \
167 } else { \
168 (dbg).mask = OMX_DBG_BASEMASK; \
169 } \
170 } while (0)
171
172 /* This macro initializes the debug structure. Default configuration is
173 stdout/stderr output and base mask. */
174 #define OMX_DBG_INIT_BASE(dbg) \
175 do { \
176 (dbg).err = stderr; \
177 (dbg).out = stdout; \
178 (dbg).out_opened = (dbg).err_opened = NULL; \
179 (dbg).mask = OMX_DBG_BASEMASK; \
180 } while (0)
181
182 /* This macro initializes the debug structure. Default configuration is
183 stdout/stderr output and base mask. If the OMX_DBG_CONFIG environment
184 variable is defined, the file given by this variable is opened and each line
185 is compared to the tag string followed by _OUT, _ERR or _LEVEL to specify
186 the output and error file names, or the debug level. If the debug level
187 string is less than 8 hexadecimal digits, the remaining domain mask levels
188 are set to the base mask (3). */
189 #define OMX_DBG_INITALL(dbg, tag_str, file) \
190 do { \
191 (dbg).err = stderr; \
192 (dbg).out = stdout; \
193 (dbg).out_opened = (dbg).err_opened = NULL; \
194 (dbg).mask = OMX_DBG_BASEMASK; \
195 char *config_file = getenv("OMX_DBG_CONFIG"); \
196 FILE *config = (config_file && *config_file) ? fopen(config_file, "rt") : NULL; \
197 if (config) { \
198 char line[80], *ptr, *end, out[75], err[75]; \
199 out[0] = err[0] = '\0'; \
200 while (fgets(line, sizeof(line), config)) { \
201 for (ptr = line; isspace(*ptr); ptr++); \
202 if (!strncmp(ptr, tag_str, strlen(tag_str))) { \
203 ptr += strlen(tag_str); \
204 end = ptr + strlen(ptr); \
205 while (end > ptr && isspace(end[-1])) *--end = '\0'; \
206 if (file && !strncmp(ptr, "_ERR", 4) && isspace(ptr[4])) { \
207 ptr += 4; \
208 while (isspace(*ptr)) ptr++; \
209 strcpy(err, ptr); \
210 } else if (file && !strncmp(ptr, "_OUT", 4) && isspace(ptr[4])) { \
211 ptr += 4; \
212 while (isspace(*ptr)) ptr++; \
213 strcpy(out, ptr); \
214 } else if (!strncmp(ptr, "_LEVEL", 6) && isspace(ptr[6])) { \
215 ptr += 6; \
216 while (isspace(*ptr)) ptr++; \
217 OMX_DBG_SET_MASK(dbg, ptr); \
218 } \
219 } \
220 } \
221 if (file) { \
222 if (!strcmp(out, "stdout")) {} \
223 else if (!strcmp(out, "stderr")) (dbg).out = stderr; \
224 else if (!strcmp(out, "null")) (dbg).out = NULL; \
225 else if (*out) (dbg).out_opened = (dbg).out = fopen(out, "w"); \
226 if (!strcmp(err, "stderr")) {} \
227 else if (!strcmp(err, "stdout")) (dbg).err = stdout; \
228 else if (!strcmp(err, "null")) (dbg).err = NULL; \
229 else if (!strcmp(err, out)) (dbg).err = (dbg).out; \
230 else if (*err) (dbg).err_opened = (dbg).err = fopen(err, "w"); \
231 } \
232 fclose(config); \
233 } \
234 } while (0)
235
236
237 #define OMX_DBG_INIT(dbg, tag_str) OMX_DBG_INITALL(dbg, tag_str, 1)
238 #define OMX_DBG_INIT_MASK(dbg, tag_str) OMX_DBG_INITALL(dbg, tag_str, 0)
239
240
241 /* Use this macro to copy a OMX_TI_Debug config received. */
242 #define OMX_DBG_SETCONFIG(dbg, pConfig) \
243 do { \
244 struct OMX_TI_Debug *pConfDbg = (struct OMX_TI_Debug *) pConfig; \
245 (dbg).mask = pConfDbg->mask; \
246 (dbg).out = pConfDbg->out; \
247 (dbg).err = pConfDbg->err; \
248 } while (0)
249
250 /* Use this macro to copy a OMX_TI_Debug config to be sent. */
251 #define OMX_DBG_GETCONFIG(dbg, pConfig) \
252 do { \
253 struct OMX_TI_Debug *pConfDbg = (struct OMX_TI_Debug *) pConfig; \
254 pConfDbg->mask = dbg.mask; \
255 pConfDbg->out = dbg.out; \
256 pConfDbg->err = dbg.err; \
257 pConfDbg->err_opened = pConfDbg->out_opened = NULL; \
258 } while (0)
259
260 /* Use this macro to close any opened file that was opened by OMX_DBG. */
261 #define OMX_DBG_CLOSE(dbg) \
262 do { \
263 if ((dbg).err_opened) { \
264 if ((dbg).err == (dbg).err_opened) (dbg).err = stderr; \
265 fclose((dbg).err_opened); \
266 } \
267 if ((dbg).out_opened) { \
268 if ((dbg).out == (dbg).out_opened) (dbg).out = stdout; \
269 if ((dbg).err == (dbg).out_opened) (dbg).err = stderr; \
270 fclose((dbg).out_opened); \
271 } \
272 (dbg).err_opened = (dbg).out_opened = NULL; \
273 } while (0)
274
275 #ifdef __OMX_DEBUG__
276
277 /*
278 * GENERIC OMX TI DEBUG STATEMENT
279 *
280 * file - output of the debug message
281 * level - level of the debug message
282 * domain - domain of the debug message
283 * mask - debug print mask, only messages for domains marked, and that have
284 * levels at least of the mask's level will be printed
285 * format, list - debug message
286 */
287
288 #ifdef ANDROID
289 #ifdef __OMX_DEBUG_ANDROID__
290 #define OMX_DBG_PRINT(file, domain, level, mask, format, list...) \
291 do {\
292 if ((file) && (OMX_U32) (level * domain) >= (OMX_U32) ((mask) & (domain * OMX_DBG_MAX_LEVEL))) \
293 ALOGD(OMX_DBG_FN_FMT OMX_DBG_LINE_FMT OMX_DBG_FMT \
294 format OMX_DBG_FN OMX_DBG_LINE, ##list); \
295 } while (0)
296 #else
297 #define OMX_DBG_PRINT(file, domain, level, mask, format, list...) \
298 do {\
299 if ((file) && (OMX_U32) (level * domain) >= (OMX_U32) ((mask) & (domain * OMX_DBG_MAX_LEVEL))) { \
300 if (file == stderr || file == stdout) { \
301 ALOGD(OMX_DBG_FN_FMT OMX_DBG_LINE_FMT OMX_DBG_FMT \
302 format OMX_DBG_FN OMX_DBG_LINE, ##list); \
303 } else { \
304 fprintf((file), \
305 OMX_DBG_FILE OMX_DBG_FN_FMT OMX_DBG_LINE_FMT OMX_DBG_FMT \
306 format OMX_DBG_FN OMX_DBG_LINE, ##list); \
307 } \
308 } \
309 } while (0)
310 #endif
311 #else
312 #define OMX_DBG_PRINT(file, domain, level, mask, format, list...) \
313 do {\
314 if ((file) && (OMX_U32) (level * domain) >= (OMX_U32) ((mask) & (domain * OMX_DBG_MAX_LEVEL))) \
315 fprintf((file), \
316 OMX_DBG_FILE OMX_DBG_FN_FMT OMX_DBG_LINE_FMT OMX_DBG_FMT \
317 format OMX_DBG_FN OMX_DBG_LINE, ##list); \
318 } while (0)
319 #endif
320
321 /* Alternate mask understanding implementation. Use this if we cannot specify a
322 level for each domain */
323 /*
324 #define OMX_DBG_PRINT(file, domain, level, mask, format, list...) \
325 do {\
326 if (file && (mask & domain) && level >= (mask & OMX_MASK_LEVEL)) \
327 fprintf(file, \
328 OMX_DBG_FILE OMX_DBG_FN_FMT OMX_DBG_LINE_FMT OMX_DBG_FMT \
329 format, OMX_DBG_FN OMX_DBG_LINE ##list); \
330 } while (0)
331 */
332
333 #else
334 /* empty definitions */
335 #define OMX_DBG_PRINT(file, domain, level, mask, format, list...)
336 #endif
337
338 /*
339 * OMX BAIL Shortcut macros
340 */
341 #define OMX_DBG_BAIL_IF_ERROR(_eError, dbg, cmd, format, list...) \
342 do { \
343 if (_eError) { \
344 cmd(dbg, format, ##list); \
345 OMX_CONF_BAIL_IF_ERROR(_eError); \
346 } \
347 } while (0)
348
349 #define OMX_DBG_SET_ERROR_BAIL(_eError, _eErrorValue, dbg, cmd, format, list...) \
350 do { \
351 cmd(dbg, format, ##list); \
352 OMX_CONF_SET_ERROR_BAIL(_eError, _eErrorValue); \
353 } while (0)
354
355 #define OMX_DBG_CHECK_CMD(dbg, _ptr1, _ptr2, _ptr3) \
356 do { \
357 if(!_ptr1) OMX_ERROR4(dbg, "NULL parameter (" #_ptr1 ").\n"); \
358 else if(!_ptr2) OMX_ERROR4(dbg, "NULL parameter (" #_ptr2 ").\n"); \
359 else if(!_ptr3) OMX_ERROR4(dbg, "NULL parameter (" #_ptr3 ").\n"); \
360 OMX_CONF_CHECK_CMD(_ptr1, _ptr2, _ptr3); \
361 } while (0)
362
363
364 /*
365 * GENERIC OMX TI DEBUG Shortcut macros
366 */
367
368 /* This variant uses a shortcut for the domain notation, but is not traceable
369 by source understanders. It also adds the color to the format string. */
370 #define OMXDBG_PRINT(file, domain, level, mask, format, list...) \
371 OMX_DBG_PRINT(file, OMX_DBG_DOM_##domain, level, mask, \
372 OMX_DBG_COL_##domain OMX_DBG_DOM_##domain##_STR OMX_DBG_LEVEL(level) format OMX_DBG_COL_WHITE, ##list)
373
374 /* Shortcuts */
375 #define OMX_ERROR0(dbg, format, list...) OMXDBG_PRINT((dbg).err, ERROR, 0, (dbg).mask, format, ##list)
376 #define OMX_ERROR1(dbg, format, list...) OMXDBG_PRINT((dbg).err, ERROR, 1, (dbg).mask, format, ##list)
377 #define OMX_ERROR2(dbg, format, list...) OMXDBG_PRINT((dbg).err, ERROR, 2, (dbg).mask, format, ##list)
378 #define OMX_ERROR3(dbg, format, list...) OMXDBG_PRINT((dbg).err, ERROR, 3, (dbg).mask, format, ##list)
379 #define OMX_ERROR4(dbg, format, list...) OMXDBG_PRINT((dbg).err, ERROR, 4, (dbg).mask, format, ##list)
380 #define OMX_ERROR5(dbg, format, list...) OMXDBG_PRINT((dbg).err, ERROR, 5, (dbg).mask, format, ##list)
381 #define OMX_TRACE0(dbg, format, list...) OMXDBG_PRINT((dbg).out, SYSTEM, 0, (dbg).mask, format, ##list)
382 #define OMX_TRACE1(dbg, format, list...) OMXDBG_PRINT((dbg).out, SYSTEM, 1, (dbg).mask, format, ##list)
383 #define OMX_TRACE2(dbg, format, list...) OMXDBG_PRINT((dbg).out, SYSTEM, 2, (dbg).mask, format, ##list)
384 #define OMX_TRACE3(dbg, format, list...) OMXDBG_PRINT((dbg).out, SYSTEM, 3, (dbg).mask, format, ##list)
385 #define OMX_TRACE4(dbg, format, list...) OMXDBG_PRINT((dbg).OMX_DBG_LEVEL4, SYSTEM, 4, (dbg).mask, format, ##list)
386 #define OMX_TRACE5(dbg, format, list...) OMXDBG_PRINT((dbg).err, SYSTEM, 5, (dbg).mask, format, ##list)
387 #define OMX_PRINT0(dbg, format, list...) OMXDBG_PRINT((dbg).out, PRINT, 0, (dbg).mask, format, ##list)
388 #define OMX_PRINT1(dbg, format, list...) OMXDBG_PRINT((dbg).out, PRINT, 1, (dbg).mask, format, ##list)
389 #define OMX_PRINT2(dbg, format, list...) OMXDBG_PRINT((dbg).out, PRINT, 2, (dbg).mask, format, ##list)
390 #define OMX_PRINT3(dbg, format, list...) OMXDBG_PRINT((dbg).out, PRINT, 3, (dbg).mask, format, ##list)
391 #define OMX_PRINT4(dbg, format, list...) OMXDBG_PRINT((dbg).OMX_DBG_LEVEL4, PRINT, 4, (dbg).mask, format, ##list)
392 #define OMX_PRINT5(dbg, format, list...) OMXDBG_PRINT((dbg).err, PRINT, 5, (dbg).mask, format, ##list)
393 #define OMX_PRBUFFER0(dbg, format, list...) OMXDBG_PRINT((dbg).out, BUFFER, 0, (dbg).mask, format, ##list)
394 #define OMX_PRBUFFER1(dbg, format, list...) OMXDBG_PRINT((dbg).out, BUFFER, 1, (dbg).mask, format, ##list)
395 #define OMX_PRBUFFER2(dbg, format, list...) OMXDBG_PRINT((dbg).out, BUFFER, 2, (dbg).mask, format, ##list)
396 #define OMX_PRBUFFER3(dbg, format, list...) OMXDBG_PRINT((dbg).out, BUFFER, 3, (dbg).mask, format, ##list)
397 #define OMX_PRBUFFER4(dbg, format, list...) OMXDBG_PRINT((dbg).OMX_DBG_LEVEL4, BUFFER, 4, (dbg).mask, format, ##list)
398 #define OMX_PRBUFFER5(dbg, format, list...) OMXDBG_PRINT((dbg).err, BUFFER, 5, (dbg).mask, format, ##list)
399 #define OMX_PRMGR0(dbg, format, list...) OMXDBG_PRINT((dbg).out, MGR, 0, (dbg).mask, format, ##list)
400 #define OMX_PRMGR1(dbg, format, list...) OMXDBG_PRINT((dbg).out, MGR, 1, (dbg).mask, format, ##list)
401 #define OMX_PRMGR2(dbg, format, list...) OMXDBG_PRINT((dbg).out, MGR, 2, (dbg).mask, format, ##list)
402 #define OMX_PRMGR3(dbg, format, list...) OMXDBG_PRINT((dbg).out, MGR, 3, (dbg).mask, format, ##list)
403 #define OMX_PRMGR4(dbg, format, list...) OMXDBG_PRINT((dbg).OMX_DBG_LEVEL4, MGR, 4, (dbg).mask, format, ##list)
404 #define OMX_PRMGR5(dbg, format, list...) OMXDBG_PRINT((dbg).err, MGR, 5, (dbg).mask, format, ##list)
405 #define OMX_PRDSP0(dbg, format, list...) OMXDBG_PRINT((dbg).out, DSP, 0, (dbg).mask, format, ##list)
406 #define OMX_PRDSP1(dbg, format, list...) OMXDBG_PRINT((dbg).out, DSP, 1, (dbg).mask, format, ##list)
407 #define OMX_PRDSP2(dbg, format, list...) OMXDBG_PRINT((dbg).out, DSP, 2, (dbg).mask, format, ##list)
408 #define OMX_PRDSP3(dbg, format, list...) OMXDBG_PRINT((dbg).out, DSP, 3, (dbg).mask, format, ##list)
409 #define OMX_PRDSP4(dbg, format, list...) OMXDBG_PRINT((dbg).OMX_DBG_LEVEL4, DSP, 4, (dbg).mask, format, ##list)
410 #define OMX_PRDSP5(dbg, format, list...) OMXDBG_PRINT((dbg).err, DSP, 5, (dbg).mask, format, ##list)
411 #define OMX_PRCOMM0(dbg, format, list...) OMXDBG_PRINT((dbg).out, COMM, 0, (dbg).mask, format, ##list)
412 #define OMX_PRCOMM1(dbg, format, list...) OMXDBG_PRINT((dbg).out, COMM, 1, (dbg).mask, format, ##list)
413 #define OMX_PRCOMM2(dbg, format, list...) OMXDBG_PRINT((dbg).out, COMM, 2, (dbg).mask, format, ##list)
414 #define OMX_PRCOMM3(dbg, format, list...) OMXDBG_PRINT((dbg).out, COMM, 3, (dbg).mask, format, ##list)
415 #define OMX_PRCOMM4(dbg, format, list...) OMXDBG_PRINT((dbg).OMX_DBG_LEVEL4, COMM, 4, (dbg).mask, format, ##list)
416 #define OMX_PRCOMM5(dbg, format, list...) OMXDBG_PRINT((dbg).err, COMM, 5, (dbg).mask, format, ##list)
417 #define OMX_PRSTATE0(dbg, format, list...) OMXDBG_PRINT((dbg).out, STATE, 0, (dbg).mask, format, ##list)
418 #define OMX_PRSTATE1(dbg, format, list...) OMXDBG_PRINT((dbg).out, STATE, 1, (dbg).mask, format, ##list)
419 #define OMX_PRSTATE2(dbg, format, list...) OMXDBG_PRINT((dbg).out, STATE, 2, (dbg).mask, format, ##list)
420 #define OMX_PRSTATE3(dbg, format, list...) OMXDBG_PRINT((dbg).out, STATE, 3, (dbg).mask, format, ##list)
421 #define OMX_PRSTATE4(dbg, format, list...) OMXDBG_PRINT((dbg).OMX_DBG_LEVEL4, STATE, 4, (dbg).mask, format, ##list)
422 #define OMX_PRSTATE5(dbg, format, list...) OMXDBG_PRINT((dbg).err, STATE, 5, (dbg).mask, format, ##list)
423
424 /*
425 * Compile Time Customizations
426 */
427
428 /*
429 * Context
430 */
431 #ifdef __OMX_DBG_FN__
432 #define OMX_DBG_FN_FMT "%s()"
433 #define OMX_DBG_FN , __FUNCTION__
434 #else
435 #define OMX_DBG_FN_FMT
436 #define OMX_DBG_FN
437 #endif
438
439 #ifdef __OMX_DBG_LINE__
440 #define OMX_DBG_LINE_FMT ":%d"
441 #define OMX_DBG_LINE , __LINE__
442 #else
443 #define OMX_DBG_LINE_FMT
444 #define OMX_DBG_LINE
445 #endif
446
447 #ifdef __OMX_DBG_FILE__
448 #ifdef __OMX_DBG_FN__
449 #define OMX_DBG_FILE __FILE__ ":"
450 #else
451 #define OMX_DBG_FILE __FILE__
452 #endif
453 #else
454 #define OMX_DBG_FILE
455 #endif
456
457 #if defined(__OMX_DBG_LEVEL__)
458 #define OMX_DBG_LEVEL(level) "<" #level "> "
459 #elif defined(__OMX_DBG_DOMAIN__)
460 #define OMX_DBG_LEVEL(level) " "
461 #else
462 #define OMX_DBG_LEVEL(level)
463 #endif
464
465 #ifdef __OMX_DBG_DOMAIN__
466 #define OMX_DBG_DOM_ERROR_STR "ERR"
467 #define OMX_DBG_DOM_BUFFER_STR "BUF"
468 #define OMX_DBG_DOM_COMM_STR "COM"
469 #define OMX_DBG_DOM_DSP_STR "DSP"
470 #define OMX_DBG_DOM_SYSTEM_STR "SYS"
471 #define OMX_DBG_DOM_MGR_STR "MGR"
472 #define OMX_DBG_DOM_STATE_STR "STA"
473 #define OMX_DBG_DOM_PRINT_STR "GEN"
474 #else
475 #define OMX_DBG_DOM_ERROR_STR
476 #define OMX_DBG_DOM_BUFFER_STR
477 #define OMX_DBG_DOM_COMM_STR
478 #define OMX_DBG_DOM_DSP_STR
479 #define OMX_DBG_DOM_SYSTEM_STR
480 #define OMX_DBG_DOM_MGR_STR
481 #define OMX_DBG_DOM_STATE_STR
482 #define OMX_DBG_DOM_PRINT_STR
483 #endif
484
485 #ifdef __OMX_DBG_4ISERROR__
486 #define OMX_DBG_LEVEL4 err
487 #else
488 #define OMX_DBG_LEVEL4 out
489 #endif
490
491 #if defined(__OMX_DBG_LINE__) || defined(__OMX_DBG_FN__) || defined(__OMX_DBG_FILE__)
492 #define OMX_DBG_FMT " "
493 #else
494 #define OMX_DBG_FMT
495 #endif
496
497 /*
498 * Color (ANSI escape sequences)
499 */
500 #ifdef __OMX_DBG_COLOR__
501 #define OMX_DBG_COL_RED "\x1b[1;31;40m"
502 #define OMX_DBG_COL_GREEN "\x1b[1;32;40m"
503 #define OMX_DBG_COL_YELLOW "\x1b[1;33;40m"
504 #define OMX_DBG_COL_BLUE "\x1b[1;34;40m"
505 #define OMX_DBG_COL_MAGENTA "\x1b[1;35;40m"
506 #define OMX_DBG_COL_CYAN "\x1b[1;36;40m"
507 #define OMX_DBG_COL_WHITE "\x1b[1;37;40m"
508 #else
509 #define OMX_DBG_COL_BLUE
510 #define OMX_DBG_COL_CYAN
511 #define OMX_DBG_COL_GREEN
512 #define OMX_DBG_COL_MAGENTA
513 #define OMX_DBG_COL_RED
514 #define OMX_DBG_COL_WHITE
515 #define OMX_DBG_COL_YELLOW
516 #endif
517
518 /*
519 * Domain colors - these can be predefined differently
520 */
521
522 #ifndef OMX_DBG_COL_ERROR
523 #define OMX_DBG_COL_ERROR OMX_DBG_COL_RED
524 #endif
525 #ifndef OMX_DBG_COL_SYSTEM
526 #define OMX_DBG_COL_SYSTEM OMX_DBG_COL_WHITE
527 #endif
528 #ifndef OMX_DBG_COL_PRINT
529 #define OMX_DBG_COL_PRINT OMX_DBG_COL_WHITE
530 #endif
531 #ifndef OMX_DBG_COL_BUFFER
532 #define OMX_DBG_COL_BUFFER OMX_DBG_COL_GREEN
533 #endif
534 #ifndef OMX_DBG_COL_MGR
535 #define OMX_DBG_COL_MGR OMX_DBG_COL_MAGENTA
536 #endif
537 #ifndef OMX_DBG_COL_DSP
538 #define OMX_DBG_COL_DSP OMX_DBG_COL_CYAN
539 #endif
540 #ifndef OMX_DBG_COL_COMM
541 #define OMX_DBG_COL_COMM OMX_DBG_COL_YELLOW
542 #endif
543 #ifndef OMX_DBG_COL_STATE
544 #define OMX_DBG_COL_STATE OMX_DBG_COL_BLUE
545 #endif
546
547 #ifdef OMX_MEMDEBUG
548 #define mem_array_size=500;
549
550 void *arr[mem_array_size];
551 int lines[mem_array_size];
552 int bytes[mem_array_size];
553 char file[mem_array_size][50];
554
555 #define newmalloc(x) mymalloc(__LINE__,__FILE__,x)
556 #define newfree(z) myfree(z,__LINE__,__FILE__)
557
558 void * mymalloc(int line, char *s, int size);
559 int myfree(void *dp, int line, char *s);
560
mymalloc(int line,char * s,int size)561 void * mymalloc(int line, char *s, int size)
562 {
563 void *p;
564 int e=0;
565 p = malloc(size);
566 if(p==NULL){
567 OMXDBG_PRINT(stderr, ERROR, 4, 0, "Memory not available\n");
568 /* ddexit(1); */
569 }
570 else{
571 while((lines[e]!=0)&& (e<(mem_array_size - 1)) ){
572 e++;
573 }
574 arr[e]=p;
575 lines[e]=line;
576 bytes[e]=size;
577 strcpy(file[e],s);
578 OMXDBG_PRINT(stderr, BUFFER, 2, 0,
579 "Allocating %d bytes on address %p, line %d file %s pos %d\n", size, p, line, s, e);
580 }
581 return p;
582 }
583
myfree(void * dp,int line,char * s)584 int myfree(void *dp, int line, char *s){
585 int q;
586 for(q=0;q<mem_array_size;q++){
587 if(arr[q]==dp){
588 OMXDBG_PRINT(stderr, PRINT, 2, 0, "Deleting %d bytes on address %p, line %d file %s\n",
589 bytes[q],dp, line, s);
590 free(dp);
591 dp = NULL;
592 lines[q]=0;
593 strcpy(file[q],"");
594 break;
595 }
596 }
597 if(mem_array_size==q){
598 OMXDBG_PRINT(stderr, PRINT, 2, 0, "\n\nPointer not found. Line:%d File%s!!\n\n",line, s);
599 }
600 }
601
602 #else
603
604 #define newmalloc(x) malloc(x)
605 #define newfree(z) free(z)
606
607 #endif
608
609
610 #endif
611