Mercurial > hg > audiostuff

comparison spandsp-0.0.3/spandsp-0.0.3/src/logging.c @ 5:f762bf195c4b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
import spandsp-0.0.3
author Peter Meerwald <pmeerw@cosy.sbg.ac.at>
date Fri, 25 Jun 2010 16:00:21 +0200
parents
children
comparison
equal deleted inserted replaced
4:26cd8f1ef0b1 5:f762bf195c4b
1 /*
2 * SpanDSP - a series of DSP components for telephony
3 *
4 * logging.c - error and debug logging.
5 *
6 * Written by Steve Underwood <steveu@coppice.org>
7 *
8 * Copyright (C) 2005 Steve Underwood
9 *
10 * All rights reserved.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2, as
14 * published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 * $Id: logging.c,v 1.22 2006/11/30 15:41:47 steveu Exp $
26 */
27
28 /*! \file */
29
30 #ifdef HAVE_CONFIG_H
31 #include <config.h>
32 #endif
33
34 #include <limits.h>
35 #include <stdio.h>
36 #include <stdarg.h>
37 #include <fcntl.h>
38 #include <stdlib.h>
39 #include <inttypes.h>
40 #include <string.h>
41 #include <errno.h>
42 #include <signal.h>
43 #include <sys/time.h>
44 #include <time.h>
45
46 #include "spandsp/telephony.h"
47 #include "spandsp/logging.h"
48
49 static void default_message_handler(int level, const char *text);
50
51 static message_handler_func_t __span_message = *default_message_handler;
52 static error_handler_func_t __span_error = NULL;
53
54 static const char *severities[] =
55 {
56 "NONE",
57 "ERROR",
58 "WARNING",
59 "PROTOCOL_ERROR",
60 "PROTOCOL_WARNING",
61 "FLOW",
62 "FLOW 2",
63 "FLOW 3",
64 "DEBUG 1",
65 "DEBUG 2",
66 "DEBUG 3"
67 };
68
69 static void default_message_handler(int level, const char *text)
70 {
71 fprintf(stderr, "%s", text);
72 }
73 /*- End of function --------------------------------------------------------*/
74
75 int span_log_test(logging_state_t *s, int level)
76 {
77 if (s && (s->level & SPAN_LOG_SEVERITY_MASK) >= (level & SPAN_LOG_SEVERITY_MASK))
78 return TRUE;
79 return FALSE;
80 }
81 /*- End of function --------------------------------------------------------*/
82
83 int span_log(logging_state_t *s, int level, const char *format, ...)
84 {
85 char msg[1024 + 1];
86 va_list arg_ptr;
87 int len;
88 struct tm *tim;
89 struct timeval nowx;
90 time_t now;
91
92 if (span_log_test(s, level))
93 {
94 va_start(arg_ptr, format);
95 len = 0;
96 if ((level & SPAN_LOG_SUPPRESS_LABELLING) == 0)
97 {
98 if ((s->level & SPAN_LOG_SHOW_DATE))
99 {
100 gettimeofday(&nowx, NULL);
101 now = nowx.tv_sec;
102 tim = gmtime(&now);
103 snprintf(msg + len,
104 1024 - len,
105 "%04d/%02d/%02d %02d:%02d:%02d.%03d ",
106 tim->tm_year + 1900,
107 tim->tm_mon + 1,
108 tim->tm_mday,
109 tim->tm_hour,
110 tim->tm_min,
111 tim->tm_sec,
112 (int) nowx.tv_usec/1000);
113 len += (int) strlen(msg + len);
114 }
115 /*endif*/
116 if ((s->level & SPAN_LOG_SHOW_SAMPLE_TIME))
117 {
118 now = s->elapsed_samples/s->samples_per_second;
119 tim = gmtime(&now);
120 snprintf(msg + len,
121 1024 - len,
122 "%02d:%02d:%02d.%03d ",
123 tim->tm_hour,
124 tim->tm_min,
125 tim->tm_sec,
126 (int) (s->elapsed_samples%s->samples_per_second)*1000/s->samples_per_second);
127 len += (int) strlen(msg + len);
128 }
129 /*endif*/
130 if ((s->level & SPAN_LOG_SHOW_SEVERITY) && (level & SPAN_LOG_SEVERITY_MASK) <= SPAN_LOG_DEBUG_3)
131 len += snprintf(msg + len, 1024 - len, "%s ", severities[level & SPAN_LOG_SEVERITY_MASK]);
132 /*endif*/
133 if ((s->level & SPAN_LOG_SHOW_PROTOCOL) && s->protocol)
134 len += snprintf(msg + len, 1024 - len, "%s ", s->protocol);
135 /*endif*/
136 if ((s->level & SPAN_LOG_SHOW_TAG) && s->tag)
137 len += snprintf(msg + len, 1024 - len, "%s ", s->tag);
138 /*endif*/
139 }
140 /*endif*/
141 len += vsnprintf(msg + len, 1024 - len, format, arg_ptr);
142 if (s->span_error && level == SPAN_LOG_ERROR)
143 s->span_error(msg);
144 else if (__span_error && level == SPAN_LOG_ERROR)
145 __span_error(msg);
146 else if (s->span_message)
147 s->span_message(level, msg);
148 else if (__span_message)
149 __span_message(level, msg);
150 /*endif*/
151 va_end(arg_ptr);
152 return 1;
153 }
154 /*endif*/
155 return 0;
156 }
157 /*- End of function --------------------------------------------------------*/
158
159 int span_log_buf(logging_state_t *s, int level, const char *tag, const uint8_t *buf, int len)
160 {
161 char msg[1024];
162 int i;
163 int msg_len;
164
165 if (span_log_test(s, level))
166 {
167 msg_len = 0;
168 if (tag)
169 msg_len += snprintf(msg + msg_len, 1024 - msg_len, "%s", tag);
170 for (i = 0; i < len && msg_len < 800; i++)
171 msg_len += snprintf(msg + msg_len, 1024 - msg_len, " %02x", buf[i]);
172 msg_len += snprintf(msg + msg_len, 1024 - msg_len, "\n");
173 return span_log(s, level, msg);
174 }
175 return 0;
176 }
177 /*- End of function --------------------------------------------------------*/
178
179 int span_log_init(logging_state_t *s, int level, const char *tag)
180 {
181 s->span_error = __span_error;
182 s->span_message = __span_message;
183 s->level = level;
184 s->tag = tag;
185 s->protocol = NULL;
186 s->samples_per_second = SAMPLE_RATE;
187 s->elapsed_samples = 0;
188
189 return 0;
190 }
191 /*- End of function --------------------------------------------------------*/
192
193 int span_log_set_level(logging_state_t *s, int level)
194 {
195 s->level = level;
196
197 return 0;
198 }
199 /*- End of function --------------------------------------------------------*/
200
201 int span_log_set_tag(logging_state_t *s, const char *tag)
202 {
203 s->tag = tag;
204
205 return 0;
206 }
207 /*- End of function --------------------------------------------------------*/
208
209 int span_log_set_protocol(logging_state_t *s, const char *protocol)
210 {
211 s->protocol = protocol;
212
213 return 0;
214 }
215 /*- End of function --------------------------------------------------------*/
216
217 int span_log_set_sample_rate(logging_state_t *s, int samples_per_second)
218 {
219 s->samples_per_second = samples_per_second;
220
221 return 0;
222 }
223 /*- End of function --------------------------------------------------------*/
224
225 int span_log_bump_samples(logging_state_t *s, int samples)
226 {
227 s->elapsed_samples += samples;
228
229 return 0;
230 }
231 /*- End of function --------------------------------------------------------*/
232
233 void span_log_set_message_handler(logging_state_t *s, message_handler_func_t func)
234 {
235 s->span_message = func;
236 }
237 /*- End of function --------------------------------------------------------*/
238
239 void span_log_set_error_handler(logging_state_t *s, error_handler_func_t func)
240 {
241 s->span_error = func;
242 }
243 /*- End of function --------------------------------------------------------*/
244
245 void span_set_message_handler(message_handler_func_t func)
246 {
247 __span_message = func;
248 }
249 /*- End of function --------------------------------------------------------*/
250
251 void span_set_error_handler(error_handler_func_t func)
252 {
253 __span_error = func;
254 }
255 /*- End of function --------------------------------------------------------*/
256 /*- End of file ------------------------------------------------------------*/

Repositories maintained by Peter Meerwald, pmeerw@pmeerw.net.