00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include <stdio.h>
00020 #include <stdlib.h>
00021 #include <pthread.h>
00022 #include <string.h>
00023 #include <math.h>
00024 #include <asterisk/indications.h>
00025 #include <asterisk/frame.h>
00026 #include <asterisk/options.h>
00027 #include <asterisk/channel.h>
00028 #include <asterisk/logger.h>
00029
00030 struct playtones_item {
00031 int freq1;
00032 int freq2;
00033 int duration;
00034 int modulate;
00035 };
00036
00037 struct playtones_def {
00038 int vol;
00039 int reppos;
00040 int nitems;
00041 int interruptible;
00042 struct playtones_item *items;
00043 };
00044
00045 struct playtones_state {
00046 int vol;
00047 int reppos;
00048 int nitems;
00049 struct playtones_item *items;
00050 int npos;
00051 int pos;
00052 int origwfmt;
00053 struct ast_frame f;
00054 short data[4000];
00055 };
00056
00057 static void playtones_release(struct ast_channel *chan, void *params)
00058 {
00059 struct playtones_state *ps = params;
00060 if (chan) {
00061 ast_set_write_format(chan, ps->origwfmt);
00062 }
00063 if (ps->items) free(ps->items);
00064 free(ps);
00065 }
00066
00067 static void * playtones_alloc(struct ast_channel *chan, void *params)
00068 {
00069 struct playtones_def *pd = params;
00070 struct playtones_state *ps = malloc(sizeof(struct playtones_state));
00071 if (!ps)
00072 return NULL;
00073 memset(ps, 0, sizeof(struct playtones_state));
00074 ps->origwfmt = chan->writeformat;
00075 if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) {
00076 ast_log(LOG_WARNING, "Unable to set '%s' to signed linear format (write)\n", chan->name);
00077 playtones_release(NULL, ps);
00078 ps = NULL;
00079 } else {
00080 ps->vol = pd->vol;
00081 ps->reppos = pd->reppos;
00082 ps->nitems = pd->nitems;
00083 ps->items = pd->items;
00084 }
00085
00086 chan->writeinterrupt = pd->interruptible;
00087 return ps;
00088 }
00089
00090 static int playtones_generator(struct ast_channel *chan, void *data, int len, int samples)
00091 {
00092 struct playtones_state *ps = data;
00093 struct playtones_item *pi;
00094 int x;
00095
00096
00097
00098 len = samples * 2;
00099 if (len > sizeof(ps->data) / 2 - 1) {
00100 ast_log(LOG_WARNING, "Can't generate that much data!\n");
00101 return -1;
00102 }
00103 memset(&ps->f, 0, sizeof(ps->f));
00104
00105 pi = &ps->items[ps->npos];
00106 for (x=0;x<len/2;x++) {
00107 if (pi->modulate)
00108
00109 ps->data[x] = ps->vol * 2 * (
00110 sin((pi->freq1 * 2.0 * M_PI / 8000.0) * (ps->pos + x)) *
00111 (0.9 * fabs(sin((pi->freq2 * 2.0 * M_PI / 8000.0) * (ps->pos + x))) + 0.1)
00112 );
00113 else
00114
00115 ps->data[x] = ps->vol * (
00116 sin((pi->freq1 * 2.0 * M_PI / 8000.0) * (ps->pos + x)) +
00117 sin((pi->freq2 * 2.0 * M_PI / 8000.0) * (ps->pos + x))
00118 );
00119 }
00120 ps->f.frametype = AST_FRAME_VOICE;
00121 ps->f.subclass = AST_FORMAT_SLINEAR;
00122 ps->f.datalen = len;
00123 ps->f.samples = samples;
00124 ps->f.offset = AST_FRIENDLY_OFFSET;
00125 ps->f.data = ps->data;
00126 ast_write(chan, &ps->f);
00127
00128 ps->pos += x;
00129 if (pi->duration && ps->pos >= pi->duration * 8) {
00130 ps->pos = 0;
00131 ps->npos++;
00132 if (ps->npos >= ps->nitems) {
00133 if (ps->reppos == -1)
00134 return -1;
00135 ps->npos = ps->reppos;
00136 }
00137 }
00138 return 0;
00139 }
00140
00141 static struct ast_generator playtones = {
00142 alloc: playtones_alloc,
00143 release: playtones_release,
00144 generate: playtones_generator,
00145 };
00146
00147 int ast_playtones_start(struct ast_channel *chan, int vol, const char *playlst, int interruptible)
00148 {
00149 char *s, *data = ast_strdupa(playlst);
00150 struct playtones_def d = { vol, -1, 0, 1, NULL};
00151 char *stringp=NULL;
00152 char *separator;
00153 if (!data)
00154 return -1;
00155 if (vol < 1)
00156 d.vol = 8192;
00157
00158 d.interruptible = interruptible;
00159
00160 stringp=data;
00161
00162
00163 if (strchr(stringp,'|'))
00164 separator = "|";
00165 else
00166 separator = ",";
00167 s = strsep(&stringp,separator);
00168 while(s && *s) {
00169 int freq1, freq2, time, modulate=0;
00170
00171 if (s[0]=='!')
00172 s++;
00173 else if (d.reppos == -1)
00174 d.reppos = d.nitems;
00175 if (sscanf(s, "%d+%d/%d", &freq1, &freq2, &time) == 3) {
00176
00177 } else if (sscanf(s, "%d+%d", &freq1, &freq2) == 2) {
00178
00179 time = 0;
00180 } else if (sscanf(s, "%d*%d/%d", &freq1, &freq2, &time) == 3) {
00181
00182 modulate = 1;
00183 } else if (sscanf(s, "%d*%d", &freq1, &freq2) == 2) {
00184
00185 time = 0;
00186 modulate = 1;
00187 } else if (sscanf(s, "%d/%d", &freq1, &time) == 2) {
00188
00189 freq2 = 0;
00190 } else if (sscanf(s, "%d", &freq1) == 1) {
00191
00192 freq2 = 0;
00193 time = 0;
00194 } else {
00195 ast_log(LOG_WARNING,"%s: tone component '%s' of '%s' is no good\n",chan->name,s,playlst);
00196 return -1;
00197 }
00198
00199 d.items = realloc(d.items,(d.nitems+1)*sizeof(struct playtones_item));
00200 if (d.items == NULL)
00201 return -1;
00202 d.items[d.nitems].freq1 = freq1;
00203 d.items[d.nitems].freq2 = freq2;
00204 d.items[d.nitems].duration = time;
00205 d.items[d.nitems].modulate = modulate;
00206 d.nitems++;
00207
00208 s = strsep(&stringp,separator);
00209 }
00210
00211 if (ast_activate_generator(chan, &playtones, &d)) {
00212 free(d.items);
00213 return -1;
00214 }
00215 return 0;
00216 }
00217
00218 void ast_playtones_stop(struct ast_channel *chan)
00219 {
00220 ast_deactivate_generator(chan);
00221 }
00222
00223
00224
00225 struct tone_zone *tone_zones;
00226 static struct tone_zone *current_tonezone;
00227
00228
00229
00230 ast_mutex_t tzlock = AST_MUTEX_INITIALIZER;
00231
00232
00233 int ast_set_indication_country(const char *country)
00234 {
00235 if (country) {
00236 struct tone_zone *z = ast_get_indication_zone(country);
00237 if (z) {
00238 if (option_verbose > 2)
00239 ast_verbose(VERBOSE_PREFIX_3 "Setting default indication country to '%s'\n",country);
00240 current_tonezone = z;
00241 return 0;
00242 }
00243 }
00244 return 1;
00245 }
00246
00247
00248 struct tone_zone *ast_get_indication_zone(const char *country)
00249 {
00250 struct tone_zone *tz;
00251 int alias_loop = 0;
00252
00253
00254 if (country == NULL && current_tonezone)
00255 return current_tonezone;
00256 if (country == NULL && tone_zones)
00257 return tone_zones;
00258 if (country == NULL)
00259 return 0;
00260
00261 if (ast_mutex_lock(&tzlock)) {
00262 ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00263 return 0;
00264 }
00265 do {
00266 for (tz=tone_zones; tz; tz=tz->next) {
00267 if (strcasecmp(country,tz->country)==0) {
00268
00269 if (tz->alias && tz->alias[0]) {
00270 country = tz->alias;
00271 break;
00272 }
00273 ast_mutex_unlock(&tzlock);
00274 return tz;
00275 }
00276 }
00277 } while (++alias_loop<20 && tz);
00278 ast_mutex_unlock(&tzlock);
00279 if (alias_loop==20)
00280 ast_log(LOG_NOTICE,"Alias loop for '%s' forcefull broken\n",country);
00281
00282 return 0;
00283 }
00284
00285
00286 struct tone_zone_sound *ast_get_indication_tone(const struct tone_zone *zone, const char *indication)
00287 {
00288 struct tone_zone_sound *ts;
00289
00290
00291 if (zone == NULL && current_tonezone)
00292 zone = current_tonezone;
00293 if (zone == NULL && tone_zones)
00294 zone = tone_zones;
00295 if (zone == NULL)
00296 return 0;
00297
00298 if (ast_mutex_lock(&tzlock)) {
00299 ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00300 return 0;
00301 }
00302 for (ts=zone->tones; ts; ts=ts->next) {
00303 if (strcasecmp(indication,ts->name)==0) {
00304
00305 ast_mutex_unlock(&tzlock);
00306 return ts;
00307 }
00308 }
00309
00310 ast_mutex_unlock(&tzlock);
00311 return 0;
00312 }
00313
00314
00315 static inline void free_zone(struct tone_zone* zone)
00316 {
00317 while (zone->tones) {
00318 struct tone_zone_sound *tmp = zone->tones->next;
00319 free((void*)zone->tones->name);
00320 free((void*)zone->tones->data);
00321 free(zone->tones);
00322 zone->tones = tmp;
00323 }
00324 if (zone->ringcadance)
00325 free((void*)zone->ringcadance);
00326 free(zone);
00327 }
00328
00329
00330
00331
00332 int ast_register_indication_country(struct tone_zone *zone)
00333 {
00334 struct tone_zone *tz,*pz;
00335
00336 if (ast_mutex_lock(&tzlock)) {
00337 ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00338 return -1;
00339 }
00340 for (pz=NULL,tz=tone_zones; tz; pz=tz,tz=tz->next) {
00341 if (strcasecmp(zone->country,tz->country)==0) {
00342
00343 zone->next = tz->next;
00344 if (pz)
00345 pz->next = zone;
00346 else
00347 tone_zones = zone;
00348
00349 if (tz == current_tonezone)
00350 current_tonezone = zone;
00351
00352 free_zone(tz);
00353 ast_mutex_unlock(&tzlock);
00354 return 0;
00355 }
00356 }
00357
00358 zone->next = NULL;
00359 if (pz)
00360 pz->next = zone;
00361 else
00362 tone_zones = zone;
00363 ast_mutex_unlock(&tzlock);
00364
00365 if (option_verbose > 2)
00366 ast_verbose(VERBOSE_PREFIX_3 "Registered indication country '%s'\n",zone->country);
00367 return 0;
00368 }
00369
00370
00371
00372 int ast_unregister_indication_country(const char *country)
00373 {
00374 struct tone_zone *tz, *pz = NULL, *tmp;
00375 int res = -1;
00376
00377 if (ast_mutex_lock(&tzlock)) {
00378 ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00379 return -1;
00380 }
00381 tz = tone_zones;
00382 while (tz) {
00383 if (country==NULL ||
00384 (strcasecmp(country, tz->country)==0 ||
00385 strcasecmp(country, tz->alias)==0)) {
00386
00387 tmp = tz->next;
00388 if (pz)
00389 pz->next = tmp;
00390 else
00391 tone_zones = tmp;
00392
00393 if (tz == current_tonezone) {
00394 ast_log(LOG_NOTICE,"Removed default indication country '%s'\n",tz->country);
00395 current_tonezone = NULL;
00396 }
00397 if (option_verbose > 2)
00398 ast_verbose(VERBOSE_PREFIX_3 "Unregistered indication country '%s'\n",tz->country);
00399 free_zone(tz);
00400 if (tone_zones == tz)
00401 tone_zones = tmp;
00402 tz = tmp;
00403 res = 0;
00404 }
00405 else {
00406
00407 pz = tz;
00408 tz = tz->next;
00409 }
00410 }
00411 ast_mutex_unlock(&tzlock);
00412 return res;
00413 }
00414
00415
00416
00417 int ast_register_indication(struct tone_zone *zone, const char *indication, const char *tonelist)
00418 {
00419 struct tone_zone_sound *ts,*ps;
00420
00421
00422 if (zone->alias[0])
00423 return -1;
00424
00425 if (ast_mutex_lock(&tzlock)) {
00426 ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00427 return -2;
00428 }
00429 for (ps=NULL,ts=zone->tones; ts; ps=ts,ts=ts->next) {
00430 if (strcasecmp(indication,ts->name)==0) {
00431
00432 free((void*)ts->name);
00433 free((void*)ts->data);
00434 break;
00435 }
00436 }
00437 if (!ts) {
00438
00439 ts = malloc(sizeof(struct tone_zone_sound));
00440 if (!ts) {
00441 ast_log(LOG_WARNING, "Out of memory\n");
00442 ast_mutex_unlock(&tzlock);
00443 return -2;
00444 }
00445 ts->next = NULL;
00446 }
00447 ts->name = strdup(indication);
00448 ts->data = strdup(tonelist);
00449 if (ts->name==NULL || ts->data==NULL) {
00450 ast_log(LOG_WARNING, "Out of memory\n");
00451 ast_mutex_unlock(&tzlock);
00452 return -2;
00453 }
00454 if (ps)
00455 ps->next = ts;
00456 else
00457 zone->tones = ts;
00458 ast_mutex_unlock(&tzlock);
00459 return 0;
00460 }
00461
00462
00463 int ast_unregister_indication(struct tone_zone *zone, const char *indication)
00464 {
00465 struct tone_zone_sound *ts,*ps = NULL, *tmp;
00466 int res = -1;
00467
00468
00469 if (zone->alias[0])
00470 return -1;
00471
00472 if (ast_mutex_lock(&tzlock)) {
00473 ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00474 return -1;
00475 }
00476 ts = zone->tones;
00477 while (ts) {
00478 if (strcasecmp(indication,ts->name)==0) {
00479
00480 tmp = ts->next;
00481 if (ps)
00482 ps->next = tmp;
00483 else
00484 zone->tones = tmp;
00485 free((void*)ts->name);
00486 free((void*)ts->data);
00487 free(ts);
00488 ts = tmp;
00489 res = 0;
00490 }
00491 else {
00492
00493 ps = ts;
00494 ts = ts->next;
00495 }
00496 }
00497
00498 ast_mutex_unlock(&tzlock);
00499 return res;
00500 }