90
99
static int restart_monitor(void);
92
/* The private structures of the VPB channels are linked for
93
selecting outgoing channels */
101
/* The private structures of the VPB channels are
102
linked for selecting outgoing channels */
95
104
#define MODE_DIALTONE 1
96
105
#define MODE_IMMEDIATE 2
97
106
#define MODE_FXO 3
100
static VPB_TONE Dialtone = {440, 440, 440, 0, 0, 0, 5000, 0 };
101
static VPB_TONE Busytone = {440, 0, 0, 0, -100, -100, 500, 500};
102
static VPB_TONE Ringbacktone = {440, 0, 0, 0, -100, -100, 100, 100};
105
#define VPB_MAX_BRIDGES 128
106
static struct vpb_bridge_t {
108
struct ast_channel *c0, *c1, **rc;
109
struct ast_frame **fo;
114
} bridges[VPB_MAX_BRIDGES]; /* Bridges...*/
116
static ast_mutex_t bridge_lock = AST_MUTEX_INITIALIZER;
108
/* Pick a country or add your own! */
109
/* These are the tones that are played to the user */
112
static VPB_TONE Dialtone = {440, 440, 440, -10, -10, -10, 5000, 0 };
113
static VPB_TONE Busytone = {470, 0, 0, -10, -100, -100, 5000, 0 };
114
static VPB_TONE Ringbacktone = {400, 50, 440, -10, -10, -10, 1400, 800 };
119
static VPB_TONE Dialtone = {425, 0, 0, -16, -100, -100, 10000, 0};
120
static VPB_TONE Busytone = {425, 0, 0, -10, -100, -100, 500, 500};
121
static VPB_TONE Ringbacktone = {400, 425, 450, -20, -20, -20, 1000, 1000};
125
/* grunt tone defn's */
126
static VPB_DETECT toned_grunt = { 3, VPB_GRUNT, 1, 2000, 3000, 0, 0, -40, 0, 0, 0, 40, { { VPB_DELAY, 1000, 0, 0 }, { VPB_RISING, 0, 40, 0 }, { 0, 100, 0, 0 } } };
127
static VPB_DETECT toned_ungrunt = { 2, VPB_GRUNT, 1, 2000, 1, 0, 0, -40, 0, 0, 30, 40, { { 0, 0, 0, 0 } } };
129
/* Use loop drop detection */
130
static int UseLoopDrop=1;
132
/* To use or not to use Native bridging */
133
static int UseNativeBridge=1;
135
#define TIMER_PERIOD_RINGBACK 2000
136
#define TIMER_PERIOD_BUSY 700
138
#define VPB_EVENTS_ALL (VPB_MRING|VPB_MDIGIT|VPB_MDTMF|VPB_MTONEDETECT|VPB_MTIMEREXP|VPB_MPLAY_UNDERFLOW \
139
|VPB_MRECORD_OVERFLOW|VPB_MSTATION_OFFHOOK|VPB_MSTATION_ONHOOK \
140
|VPB_MRING_OFF|VPB_MDROP|VPB_MSTATION_FLASH)
141
#define VPB_EVENTS_NODROP (VPB_MRING|VPB_MDIGIT|VPB_MDTMF|VPB_MTONEDETECT|VPB_MTIMEREXP|VPB_MPLAY_UNDERFLOW \
142
|VPB_MRECORD_OVERFLOW|VPB_MSTATION_OFFHOOK|VPB_MSTATION_ONHOOK \
143
|VPB_MRING_OFF|VPB_MSTATION_FLASH)
144
#define VPB_EVENTS_NODTMF (VPB_MRING|VPB_MDIGIT|VPB_MTONEDETECT|VPB_MTIMEREXP|VPB_MPLAY_UNDERFLOW \
145
|VPB_MRECORD_OVERFLOW|VPB_MSTATION_OFFHOOK|VPB_MSTATION_ONHOOK \
146
|VPB_MRING_OFF|VPB_MDROP|VPB_MSTATION_FLASH)
147
#define VPB_EVENTS_STAT (VPB_MRING|VPB_MDIGIT|VPB_MDTMF|VPB_MTONEDETECT|VPB_MTIMEREXP|VPB_MPLAY_UNDERFLOW \
148
|VPB_MRECORD_OVERFLOW|VPB_MSTATION_OFFHOOK|VPB_MSTATION_ONHOOK \
149
|VPB_MRING_OFF|VPB_MSTATION_FLASH)
152
// Dialing parameters for Australia
153
//#define DIAL_WITH_CALL_PROGRESS
154
VPB_TONE_MAP DialToneMap[] = { { VPB_BUSY_AUST, VPB_CALL_DISCONNECT, 0 },
155
{ VPB_DIAL, VPB_CALL_DIALTONE, 0 },
156
{ VPB_RINGBACK_308, VPB_CALL_RINGBACK, 0 },
157
{ VPB_BUSY_AUST, VPB_CALL_BUSY, 0 },
158
{ VPB_GRUNT, VPB_CALL_GRUNT, 0 },
160
#define VPB_DIALTONE_WAIT 2000 /* Wait up to 2s for a dialtone */
161
#define VPB_RINGWAIT 4000 /* Wait up to 4s for ring tone after dialing */
162
#define VPB_CONNECTED_WAIT 4000 /* If no ring tone detected for 4s then consider call connected */
163
#define TIMER_PERIOD_NOANSWER 120000 /* Let it ring for 120s before deciding theres noone there */
165
#define MAX_BRIDGES_V4PCI 2
166
#define MAX_BRIDGES_V12PCI 128
169
#define VPB_STATE_ONHOOK 0
170
#define VPB_STATE_OFFHOOK 1
171
#define VPB_STATE_DIALLING 2
172
#define VPB_STATE_JOINED 3
173
#define VPB_STATE_GETDTMF 4
174
#define VPB_STATE_PLAYDIAL 5
175
#define VPB_STATE_PLAYBUSY 6
176
#define VPB_STATE_PLAYRING 7
181
struct ast_channel *c0, *c1, **rc;
182
struct ast_frame **fo;
189
static vpb_bridge_t * bridges;
190
static int max_bridges = MAX_BRIDGES_V4PCI;
192
AST_MUTEX_DEFINE_STATIC(bridge_lock);
195
vpb_model_unknown = 0,
118
200
static struct vpb_pvt {
120
struct ast_channel *owner; /* Channel we belong to, possibly NULL */
121
int mode; /* Is this in the */
122
int handle; /* Handle for vpb interface */
126
struct ast_frame f, fr;
127
char buf[VPB_MAX_BUF]; /* Static buffer for reading frames */
128
char obuf[VPB_MAX_BUF];
131
float txgain, rxgain; /* gain control for playing, recording */
133
int wantdtmf; /* Waiting for DTMF. */
134
int silencesupression;
135
char context[AST_MAX_EXTENSION];
137
char ext[AST_MAX_EXTENSION];
138
char language[MAX_LANGUAGE];
139
char callerid[AST_MAX_EXTENSION];
144
struct vpb_bridge_t *bridge;
145
void *timer; /* For call timeout. */
152
int stopreads; /* Stop reading...*/
153
pthread_t readthread; /* For monitoring read channel. One per owned channel. */
155
struct vpb_pvt *next; /* Next channel in list */
202
ast_mutex_t owner_lock; /* Protect blocks that expect ownership to remain the same */
203
struct ast_channel *owner; /* Channel who owns us, possibly NULL */
205
int golock; /* Got owner lock ? */
207
int mode; /* fxo/imediate/dialtone*/
208
int handle; /* Handle for vpb interface */
210
int state; /* used to keep port state (internal to driver) */
212
int group; /* Which group this port belongs to */
214
char dev[256]; /* Device name, eg vpb/1-1 */
215
vpb_model_t vpb_model; /* card model */
217
struct ast_frame f, fr; /* Asterisk frame interface */
218
char buf[VPB_MAX_BUF]; /* Static buffer for reading frames */
220
int dialtone; /* NOT USED */
221
float txgain, rxgain; /* Hardware gain control */
222
float txswgain, rxswgain; /* Software gain control */
224
int wantdtmf; /* Waiting for DTMF. */
225
char context[AST_MAX_EXTENSION]; /* The context for this channel */
227
char ext[AST_MAX_EXTENSION]; /* DTMF buffer for the ext[ens] */
228
char language[MAX_LANGUAGE]; /* language being used */
229
char callerid[AST_MAX_EXTENSION]; /* CallerId used for directly connected phone */
231
int brcallerpos; /* Brazilian CallerID detection */
233
int lastoutput; /* Holds the last Audio format output'ed */
234
int lastinput; /* Holds the last Audio format input'ed */
235
int last_ignore_dtmf;
237
void *busy_timer; /* Void pointer for busy vpb_timer */
238
int busy_timer_id; /* unique timer ID for busy timer */
240
void *ringback_timer; /* Void pointer for ringback vpb_timer */
241
int ringback_timer_id; /* unique timer ID for ringback timer */
243
double lastgrunt; /* time stamp (secs since epoc) of last grunt event */
245
ast_mutex_t lock; /* This one just protects bridge ptr below */
246
vpb_bridge_t *bridge;
248
int stopreads; /* Stop reading...*/
249
int read_state; /* Read state */
250
int chuck_count; /* a count of packets weve chucked away!*/
251
pthread_t readthread; /* For monitoring read channel. One per owned channel. */
253
ast_mutex_t record_lock; /* This one prevents reentering a record_buf block */
254
ast_mutex_t play_lock; /* This one prevents reentering a play_buf block */
255
int play_buf_time; /* How long the last play_buf took */
257
ast_mutex_t play_dtmf_lock;
260
struct vpb_pvt *next; /* Next channel in list */
156
262
} *iflist = NULL;
158
static char callerid[AST_MAX_EXTENSION];
264
static struct ast_channel *vpb_new(struct vpb_pvt *i, int state, char *context);
265
static void *do_chanreads(void *pvt);
267
// Can't get vpb_bridge() working on v4pci without either a horrible
268
// high pitched feedback noise or bad hiss noise depending on gain settings
269
// Get asterisk to do the bridging
270
#define BAD_V4PCI_BRIDGE
272
// This one enables a half duplex bridge which may be required to prevent high pitched
273
// feedback when getting asterisk to do the bridging and when using certain gain settings.
274
//#define HALF_DUPLEX_BRIDGE
276
/* This is the Native bridge code, which Asterisk will try before using its own bridging code */
160
277
static int vpb_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
162
struct vpb_pvt *p0 = (struct vpb_pvt *)c0->pvt->pvt;
163
struct vpb_pvt *p1 = (struct vpb_pvt *)c1->pvt->pvt;
164
int i, len = sizeof bridges/sizeof bridges[0], res;
166
/* Bridge channels, check if we can. I believe we always can, so find a slot.*/
168
ast_mutex_lock(&bridge_lock); {
169
for (i = 0; i < len; i++)
170
if (!bridges[i].inuse)
173
bridges[i].inuse = 1;
174
bridges[i].flags = flags;
179
ast_mutex_init(&bridges[i].lock);
180
pthread_cond_init(&bridges[i].cond, NULL);
182
} ast_mutex_unlock(&bridge_lock);
185
ast_log(LOG_WARNING, "Failed to bridge %s and %s!\n", c0->name, c1->name);
189
/* Set bridge pointers. You don't want to take these locks while holding bridge lock.*/
190
ast_mutex_lock(&p0->lock); {
191
p0->bridge = &bridges[i];
192
} ast_mutex_unlock(&p0->lock);
194
ast_mutex_lock(&p1->lock); {
195
p1->bridge = &bridges[i];
196
} ast_mutex_unlock(&p1->lock);
198
if (option_verbose > 4)
199
ast_verbose(VERBOSE_PREFIX_3
200
" Bridging call entered with [%s, %s]\n", c0->name, c1->name);
202
res = vpb_bridge(p0->handle, p1->handle, VPB_BRIDGE_ON, 0);
207
res = pthread_cond_wait(&bridges[i].cond, &bridges[i].lock); /* Wait for condition signal. */
210
done: /* Out of wait. */
212
vpb_bridge(p0->handle, p1->handle, VPB_BRIDGE_OFF, 0);
215
ast_mutex_lock(&bridge_lock); {
216
bridges[i].inuse = 0;
217
ast_mutex_destroy(&bridges[i].lock);
218
pthread_cond_destroy(&bridges[i].cond);
219
} ast_mutex_unlock(&bridge_lock);
221
ast_mutex_lock(&p0->lock); {
223
} ast_mutex_unlock(&p0->lock);
225
ast_mutex_lock(&p1->lock); {
227
} ast_mutex_unlock(&p1->lock);
230
if (option_verbose > 4)
231
ast_verbose(VERBOSE_PREFIX_3
232
" Bridging call done with [%s, %s] => %d\n", c0->name, c1->name, res);
234
if (res != 0 && res != VPB_OK) /* Don't assume VPB_OK is zero! */
279
struct vpb_pvt *p0 = (struct vpb_pvt *)c0->pvt->pvt;
280
struct vpb_pvt *p1 = (struct vpb_pvt *)c1->pvt->pvt;
283
#ifdef BAD_V4PCI_BRIDGE
284
if(p0->vpb_model==vpb_model_v4pci)
287
if ( UseNativeBridge != 1){
292
ast_mutex_lock(&p0->lock);
293
ast_mutex_lock(&p1->lock);
296
/* Bridge channels, check if we can. I believe we always can, so find a slot.*/
298
ast_mutex_lock(&bridge_lock); {
299
for (i = 0; i < max_bridges; i++)
300
if (!bridges[i].inuse)
302
if (i < max_bridges) {
303
bridges[i].inuse = 1;
304
bridges[i].endbridge = 0;
305
bridges[i].flags = flags;
311
} ast_mutex_unlock(&bridge_lock);
313
if (i == max_bridges) {
314
ast_log(LOG_WARNING, "Failed to bridge %s and %s!\n", c0->name, c1->name);
315
ast_mutex_unlock(&p0->lock);
316
ast_mutex_unlock(&p1->lock);
319
/* Set bridge pointers. You don't want to take these locks while holding bridge lock.*/
320
ast_mutex_lock(&p0->lock); {
321
p0->bridge = &bridges[i];
322
} ast_mutex_unlock(&p0->lock);
324
ast_mutex_lock(&p1->lock); {
325
p1->bridge = &bridges[i];
326
} ast_mutex_unlock(&p1->lock);
328
if (option_verbose>1)
329
ast_verbose(VERBOSE_PREFIX_2 "Bridging call entered with [%s, %s]\n", c0->name, c1->name);
332
#ifdef HALF_DUPLEX_BRIDGE
334
if (option_verbose>1)
335
ast_verbose(VERBOSE_PREFIX_2 "Starting half-duplex bridge [%s, %s]\n", c0->name, c1->name);
339
memset(p0->buf, 0, sizeof p0->buf);
340
memset(p1->buf, 0, sizeof p1->buf);
342
vpb_record_buf_start(p0->handle, VPB_ALAW);
343
vpb_record_buf_start(p1->handle, VPB_ALAW);
345
vpb_play_buf_start(p0->handle, VPB_ALAW);
346
vpb_play_buf_start(p1->handle, VPB_ALAW);
348
while( !bridges[i].endbridge ) {
349
struct vpb_pvt *from, *to;
357
vpb_record_buf_sync(from->handle, from->buf, VPB_SAMPLES);
358
vpb_play_buf_sync(to->handle, from->buf, VPB_SAMPLES);
361
vpb_record_buf_finish(p0->handle);
362
vpb_record_buf_finish(p1->handle);
364
vpb_play_buf_finish(p0->handle);
365
vpb_play_buf_finish(p1->handle);
367
if (option_verbose>1)
368
ast_verbose(VERBOSE_PREFIX_2 "Finished half-duplex bridge [%s, %s]\n", c0->name, c1->name);
374
res = vpb_bridge(p0->handle, p1->handle, VPB_BRIDGE_ON, i+1 /* resource 1 & 2 only for V4PCI*/ );
376
//pthread_cond_wait(&bridges[i].cond, &bridges[i].lock); /* Wait for condition signal. */
377
while( !bridges[i].endbridge ) {};
378
vpb_bridge(p0->handle, p1->handle, VPB_BRIDGE_OFF, i+1 /* resource 1 & 2 only for V4PCI*/ );
383
ast_mutex_lock(&bridge_lock); {
384
bridges[i].inuse = 0;
385
} ast_mutex_unlock(&bridge_lock);
391
if (option_verbose>1)
392
ast_verbose(VERBOSE_PREFIX_2 "Bridging call done with [%s, %s] => %d\n", c0->name, c1->name, res);
395
ast_mutex_unlock(&p0->lock);
396
ast_mutex_unlock(&p1->lock);
398
return (res==VPB_OK)?0:-1;
401
static double get_time_in_ms()
404
gettimeofday(&tv, NULL);
405
return ((double)tv.tv_sec*1000)+((double)tv.tv_usec/1000);
408
// Caller ID can be located in different positions between the rings depending on your Telco
409
// Australian (Telstra) callerid starts 700ms after 1st ring and finishes 1.5s after first ring
410
// Use ANALYSE_CID to record rings and determine location of callerid
411
//#define ANALYSE_CID
412
#define RING_SKIP 600
413
#define CID_MSECS 1700
415
static void get_callerid(struct vpb_pvt *p)
417
short buf[CID_MSECS*8]; // 8kHz sampling rate
418
double cid_record_time;
421
if(strcasecmp(p->callerid, "on")) {
422
p->owner->callerid = strdup("unknown");
426
if( ast_mutex_trylock(&p->record_lock) == 0 ) {
428
char callerid[AST_MAX_EXTENSION] = "";
430
cid_record_time = get_time_in_ms();
431
if (option_verbose>3)
432
ast_verbose(VERBOSE_PREFIX_4 "CID record - start\n");
435
VPB_RECORD record_parms = { "", 8 * 1000 }; // record a couple of rings
436
vpb_record_set(p->handle,&record_parms);
437
ast_verbose(VERBOSE_PREFIX_4 "Recording debug CID sample to /tmp/cid.raw\n");
438
vpb_record_file_sync(p->handle,"/tmp/cid.raw",VPB_LINEAR);
439
rc = 1; // don't try to decode_cid
441
// Skip any trailing ringtone
442
vpb_sleep(RING_SKIP);
444
if (option_verbose>3)
445
ast_verbose(VERBOSE_PREFIX_4 "CID record - skipped %fms trailing ring\n",
446
get_time_in_ms() - cid_record_time);
447
cid_record_time = get_time_in_ms();
449
// Record bit between the rings which contains the callerid
450
vpb_record_buf_start(p->handle, VPB_LINEAR);
451
rc = vpb_record_buf_sync(p->handle, (char*)buf, sizeof(buf));
452
vpb_record_buf_finish(p->handle);
455
if (option_verbose>3)
456
ast_verbose(VERBOSE_PREFIX_4 "CID record - recorded %fms between rings\n",
457
get_time_in_ms() - cid_record_time);
459
ast_mutex_unlock(&p->record_lock);
462
ast_log(LOG_ERROR, "Failed to record caller id sample on %s\n", p->dev );
466
// This decodes FSK 1200baud type callerid
467
if ((rc=vpb_cid_decode(callerid, buf, CID_MSECS*8)) == VPB_OK ) {
469
strncpy(callerid,"undisclosed", sizeof(callerid) - 1); // blocked CID (eg caller used 1831)
471
ast_log(LOG_ERROR, "Failed to decode caller id on %s - %s\n", p->dev, vpb_strerror(rc) );
472
strncpy(callerid,"unknown", sizeof(callerid) - 1);
474
p->owner->callerid = strdup(callerid);
477
ast_log(LOG_ERROR, "Failed to set record mode for caller id on %s\n", p->dev );
480
// Terminate any tones we are presently playing
481
static void stoptone( int handle)
485
while(vpb_playtone_state(handle)!=VPB_OK){
486
vpb_tone_terminate(handle);
487
ret = vpb_get_event_ch_async(handle,&je);
488
if ((ret == VPB_OK)&&(je.type != VPB_DIALEND)){
489
if (option_verbose > 3){
490
ast_verbose(VERBOSE_PREFIX_4 "Stop tone collected a wrong event!![%d]\n",je.type);
492
// vpb_put_event(&je);
498
/* Safe vpb_playtone_async */
499
static int playtone( int handle, VPB_TONE *tone)
503
if (option_verbose > 3)
504
ast_verbose(VERBOSE_PREFIX_4 "[%02d]: Playing tone\n", handle);
505
ret = vpb_playtone_async(handle, tone);
240
509
static inline int monitor_handle_owned(struct vpb_pvt *p, VPB_EVENT *e)
242
struct ast_frame f = {AST_FRAME_CONTROL}; /* default is control, Clear rest. */
245
if (option_verbose > 4)
246
ast_verbose(VERBOSE_PREFIX_3 " %s handle_owned got event: [%d=>%d]\n",
247
p->dev, e->type, e->data);
252
if (p->mode == MODE_FXO)
253
f.subclass = AST_CONTROL_RING;
255
f.frametype = -1; /* ignore ring on station port. */
258
if (p->calling) { /* This means time to stop calling. */
259
f.subclass = AST_CONTROL_BUSY;
260
vpb_timer_close(p->timer);
262
f.frametype = -1; /* Ignore. */
265
if (p->owner->_state == AST_STATE_UP) {
266
f.frametype = AST_FRAME_DTMF;
267
f.subclass = e->data;
273
if (e->data == VPB_BUSY || e->data == VPB_BUSY_308)
274
f.subclass = AST_CONTROL_BUSY;
275
else if (e->data == VPB_GRUNT) {
276
p->lastgrunt = tcounter;
283
if (e->data == VPB_CALL_CONNECTED)
284
f.subclass = AST_CONTROL_ANSWER;
285
else if (e->data == VPB_CALL_NO_DIAL_TONE ||
286
e->data == VPB_CALL_NO_RING_BACK)
287
f.subclass = AST_CONTROL_CONGESTION;
288
else if (e->data == VPB_CALL_NO_ANSWER ||
289
e->data == VPB_CALL_BUSY)
290
f.subclass = AST_CONTROL_BUSY;
291
else if (e->data == VPB_CALL_DISCONNECTED)
292
f.subclass = AST_CONTROL_HANGUP;
295
case VPB_STATION_OFFHOOK:
296
f.subclass = AST_CONTROL_ANSWER;
299
case VPB_STATION_ONHOOK:
300
f.subclass = AST_CONTROL_HANGUP;
303
case VPB_STATION_FLASH:
304
f.subclass = AST_CONTROL_FLASH;
308
f.subclass = AST_CONTROL_ANSWER;
316
if (option_verbose > 4)
317
ast_verbose(VERBOSE_PREFIX_3 " handle_owned: putting frame: [%d=>%d], bridge=%p\n",
318
f.frametype, f.subclass, (void *)p->bridge);
320
ast_mutex_lock(&p->lock); {
321
if (p->bridge) { /* Check what happened, see if we need to report it. */
322
switch (f.frametype) {
324
if (!(p->bridge->c0 == p->owner &&
325
(p->bridge->flags & AST_BRIDGE_DTMF_CHANNEL_0) ) &&
326
!(p->bridge->c1 == p->owner &&
327
(p->bridge->flags & AST_BRIDGE_DTMF_CHANNEL_1) ))
328
/* Kill bridge, this is interesting. */
332
case AST_FRAME_CONTROL:
333
if (!(p->bridge->flags & AST_BRIDGE_IGNORE_SIGS))
335
if (f.subclass == AST_CONTROL_BUSY ||
336
f.subclass == AST_CONTROL_CONGESTION ||
337
f.subclass == AST_CONTROL_HANGUP ||
338
f.subclass == AST_CONTROL_FLASH)
348
*p->bridge->fo = ast_frisolate(&f);
350
*p->bridge->rc = p->owner;
352
ast_mutex_lock(&p->bridge->lock); {
353
pthread_cond_signal(&p->bridge->cond);
354
} ast_mutex_unlock(&p->bridge->lock);
357
} ast_mutex_unlock(&p->lock);
359
if (endbridge) return 0;
361
if (f.frametype >= 0 && f.frametype != AST_FRAME_NULL)
362
ast_queue_frame(p->owner, &f, 0);
511
struct ast_frame f = {AST_FRAME_CONTROL}; /* default is control, Clear rest. */
515
if (option_verbose > 3)
516
ast_verbose(VERBOSE_PREFIX_4 "%s: handle_owned: got event: [%d=>%d]\n",
517
p->dev, e->type, e->data);
522
if (p->mode == MODE_FXO) {
523
f.subclass = AST_CONTROL_RING;
525
f.frametype = -1; /* ignore ring on station port. */
533
if (e->data == p->busy_timer_id) {
534
playtone(p->handle,&Busytone);
535
p->state = VPB_STATE_PLAYBUSY;
536
vpb_timer_stop(p->busy_timer);
537
vpb_timer_start(p->busy_timer);
539
} else if (e->data == p->ringback_timer_id) {
540
playtone(p->handle, &Ringbacktone);
541
vpb_timer_stop(p->ringback_timer);
542
vpb_timer_start(p->ringback_timer);
545
f.frametype = -1; /* Ignore. */
550
if (p->owner->_state == AST_STATE_UP) {
551
f.frametype = AST_FRAME_DTMF;
552
f.subclass = e->data;
558
if (e->data == VPB_BUSY || e->data == VPB_BUSY_308 || e->data == VPB_BUSY_AUST ) {
559
if (option_verbose > 3)
560
ast_verbose(VERBOSE_PREFIX_4 "%s: handle_owned: got event: BUSY\n", p->dev);
561
if (p->owner->_state == AST_STATE_UP) {
562
f.subclass = AST_CONTROL_HANGUP;
565
f.subclass = AST_CONTROL_BUSY;
567
} else if (e->data == VPB_GRUNT) {
568
if( ( get_time_in_ms() - p->lastgrunt ) > gruntdetect_timeout ) {
569
// Nothing heard on line for a very long time
570
// Timeout connection
571
if (option_verbose > 2)
572
ast_verbose(VERBOSE_PREFIX_3 "grunt timeout\n");
573
ast_log(LOG_NOTICE,"%s: Line hangup due of lack of conversation\n",p->dev);
574
f.subclass = AST_CONTROL_HANGUP;
576
p->lastgrunt = get_time_in_ms();
584
#ifdef DIAL_WITH_CALL_PROGRESS
585
if (e->data == VPB_CALL_CONNECTED)
586
f.subclass = AST_CONTROL_ANSWER;
587
else if (e->data == VPB_CALL_NO_DIAL_TONE || e->data == VPB_CALL_NO_RING_BACK)
588
f.subclass = AST_CONTROL_CONGESTION;
589
else if (e->data == VPB_CALL_NO_ANSWER || e->data == VPB_CALL_BUSY)
590
f.subclass = AST_CONTROL_BUSY;
591
else if (e->data == VPB_CALL_DISCONNECTED)
592
f.subclass = AST_CONTROL_HANGUP;
594
ast_log(LOG_NOTICE,"%s: Got call progress callback but blind dialing \n", p->dev);
599
case VPB_STATION_OFFHOOK:
600
f.subclass = AST_CONTROL_ANSWER;
604
if ((p->mode == MODE_FXO)&&(UseLoopDrop)){ /* ignore loop drop on stations */
605
if (p->owner->_state == AST_STATE_UP)
606
f.subclass = AST_CONTROL_HANGUP;
611
case VPB_STATION_ONHOOK:
612
f.subclass = AST_CONTROL_HANGUP;
615
case VPB_STATION_FLASH:
616
f.subclass = AST_CONTROL_FLASH;
619
// Called when dialing has finished and ringing starts
620
// No indication that call has really been answered when using blind dialing
623
f.subclass = AST_CONTROL_ANSWER;
624
if (option_verbose > 1)
625
ast_verbose(VERBOSE_PREFIX_2 "%s: Dialend\n", p->dev);
631
case VPB_PLAY_UNDERFLOW:
633
vpb_reset_play_fifo_alarm(p->handle);
636
case VPB_RECORD_OVERFLOW:
638
vpb_reset_record_fifo_alarm(p->handle);
646
if (option_verbose > 3)
647
ast_verbose(VERBOSE_PREFIX_4 "%s: handle_owned: putting frame type[%d]subclass[%d], bridge=%p\n",
648
p->dev, f.frametype, f.subclass, (void *)p->bridge);
651
if (option_verbose > 3) ast_verbose("%s: LOCKING in handle_owned [%d]\n", p->dev,res);
652
res = ast_mutex_lock(&p->lock);
653
if (option_verbose > 3) ast_verbose("%s: LOCKING count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
656
if (p->bridge) { /* Check what happened, see if we need to report it. */
657
switch (f.frametype) {
659
if ( !(p->bridge->c0 == p->owner &&
660
(p->bridge->flags & AST_BRIDGE_DTMF_CHANNEL_0) ) &&
661
!(p->bridge->c1 == p->owner &&
662
(p->bridge->flags & AST_BRIDGE_DTMF_CHANNEL_1) ))
663
/* Kill bridge, this is interesting. */
667
case AST_FRAME_CONTROL:
668
if (!(p->bridge->flags & AST_BRIDGE_IGNORE_SIGS))
670
if (f.subclass == AST_CONTROL_BUSY ||
671
f.subclass == AST_CONTROL_CONGESTION ||
672
f.subclass == AST_CONTROL_HANGUP ||
673
f.subclass == AST_CONTROL_FLASH)
683
*p->bridge->fo = ast_frisolate(&f);
685
*p->bridge->rc = p->owner;
687
ast_mutex_lock(&p->bridge->lock); {
688
p->bridge->endbridge = 1;
689
pthread_cond_signal(&p->bridge->cond);
690
} ast_mutex_unlock(&p->bridge->lock);
696
res = ast_mutex_unlock(&p->lock);
698
if (option_verbose > 3) ast_verbose("%s: unLOCKING in handle_owned [%d]\n", p->dev,res);
703
// Trylock used here to avoid deadlock that can occur if we
704
// happen to be in here handling an event when hangup is called
705
// Problem is that hangup holds p->owner->lock
706
if ((f.frametype >= 0)&& (f.frametype != AST_FRAME_NULL)&&(p->owner)) {
707
if (ast_mutex_trylock(&p->owner->lock)==0) {
708
ast_queue_frame(p->owner, &f);
709
ast_mutex_unlock(&p->owner->lock);
711
ast_verbose("%s: handled_owned: Missed event %d/%d \n",
712
p->dev,f.frametype, f.subclass);
715
res = ast_mutex_unlock(&p->lock);
717
if (option_verbose > 3) ast_verbose("%s: unLOCKING in handle_owned [%d]\n", p->dev,res);
366
static struct ast_channel *vpb_new(struct vpb_pvt *i, int state, char *context);
368
723
static inline int monitor_handle_notowned(struct vpb_pvt *p, VPB_EVENT *e)
372
if (option_verbose > 4)
373
ast_verbose(VERBOSE_PREFIX_3 " %s: In not owned, mode=%d, [%d=>%d]\n",
374
p->dev, p->mode, e->type, e->data);
378
if (p->mode == MODE_FXO) /* FXO port ring, start * */
379
vpb_new(p, AST_STATE_RING, p->context);
381
case VPB_STATION_OFFHOOK:
382
if (p->mode == MODE_IMMEDIATE)
383
vpb_new(p,AST_STATE_RING, p->context);
385
vpb_playtone_async(p->handle, &Dialtone);
387
p->ext[0] = 0; /* Just to be sure & paranoid.*/
391
case VPB_STATION_ONHOOK: /*, clear ext */
392
while (vpb_playtone_state(p->handle) != 0){
393
vpb_tone_terminate(p->handle);
401
if (p->wantdtmf == 1) {
402
while (vpb_playtone_state(p->handle) != 0){
403
vpb_tone_terminate(p->handle);
412
if (ast_exists_extension(NULL, p->context, p->ext, 1, p->callerid))
413
vpb_new(p,AST_STATE_RING, p->context);
414
else if (!ast_canmatch_extension(NULL, p->context, p->ext, 1, p->callerid))
415
if (ast_exists_extension(NULL, "default", p->ext, 1, p->callerid))
416
vpb_new(p,AST_STATE_RING, "default");
417
else if (!ast_canmatch_extension(NULL, "default", p->ext, 1, p->callerid)) {
420
"%s can't match anything in %s or default\n",
422
vpb_playtone_async(p->handle, &Busytone);
432
if (option_verbose > 4)
433
ast_verbose(VERBOSE_PREFIX_3 " %s: Done not owned, mode=%d, [%d=>%d]\n",
434
p->dev, p->mode, e->type, e->data);
727
if (option_verbose > 3) {
728
char str[VPB_MAX_STR];
729
vpb_translate_event(e, str);
730
ast_verbose(VERBOSE_PREFIX_4 "%s: handle_notowned: mode=%d, event[%d][%s]=[%d]\n",
731
p->dev, p->mode, e->type,str, e->data);
736
if (p->mode == MODE_FXO) /* FXO port ring, start * */ {
737
vpb_new(p, AST_STATE_RING, p->context);
738
get_callerid(p); /* Australian Caller ID only between 1st and 2nd ring */
745
case VPB_STATION_OFFHOOK:
746
if (p->mode == MODE_IMMEDIATE)
747
vpb_new(p,AST_STATE_RING, p->context);
749
ast_verbose(VERBOSE_PREFIX_4 "%s: handle_notowned: playing dialtone\n",p->dev);
750
playtone(p->handle, &Dialtone);
752
p->ext[0] = 0; /* Just to be sure & paranoid.*/
753
p->state=VPB_STATE_PLAYDIAL;
758
if (p->mode == MODE_DIALTONE){
759
if (p->state == VPB_STATE_PLAYDIAL) {
760
playtone(p->handle, &Dialtone);
762
p->ext[0] = 0; // Just to be sure & paranoid.
764
/* These are not needed as they have timers to restart them
765
else if (p->state == VPB_STATE_PLAYBUSY) {
766
playtone(p->handle, &Busytone);
768
p->ext[0] = 0; // Just to be sure & paranoid.
770
else if (p->state == VPB_STATE_PLAYRING) {
771
playtone(p->handle, &Ringbacktone);
773
p->ext[0] = 0; // Just to be sure & paranoid.
777
ast_verbose(VERBOSE_PREFIX_4 "%s: handle_notowned: Got a DIALEND when not really expected\n",p->dev);
781
case VPB_STATION_ONHOOK: /* clear ext */
785
p->state=VPB_STATE_ONHOOK;
789
if (p->state == VPB_STATE_ONHOOK){
790
/* DTMF's being passed while on-hook maybe Caller ID */
793
if (p->wantdtmf == 1) {
797
p->state=VPB_STATE_GETDTMF;
799
strncat(p->ext, s, sizeof(p->ext) - strlen(p->ext) - 1);
800
if (ast_exists_extension(NULL, p->context, p->ext, 1, p->callerid)){
801
vpb_new(p,AST_STATE_RING, p->context);
802
} else if (!ast_canmatch_extension(NULL, p->context, p->ext, 1, p->callerid)){
803
if (ast_exists_extension(NULL, "default", p->ext, 1, p->callerid)) {
804
vpb_new(p,AST_STATE_RING, "default");
805
} else if (!ast_canmatch_extension(NULL, "default", p->ext, 1, p->callerid)) {
806
if (option_verbose > 3) {
807
ast_verbose(VERBOSE_PREFIX_4 "%s: handle_notowned: can't match anything in %s or default\n",
810
playtone(p->handle, &Busytone);
811
vpb_timer_stop(p->busy_timer);
812
vpb_timer_start(p->busy_timer);
813
p->state = VPB_STATE_PLAYBUSY;
823
if (option_verbose > 3)
824
ast_verbose(VERBOSE_PREFIX_4 "%s: handle_notowned: mode=%d, [%d=>%d]\n",
825
p->dev, p->mode, e->type, e->data);
439
830
static void *do_monitor(void *unused)
442
/* Monitor thread, doesn't die until explicitly killed. */
444
if (option_verbose > 4)
445
ast_verbose(VERBOSE_PREFIX_3 "Starting vpb monitor thread[%ld]\n",
447
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
451
char str[VPB_MAX_STR];
453
int res = vpb_get_event_sync(&e, VPB_WAIT_TIMEOUT);
459
ast_mutex_lock(&monlock),
460
ast_mutex_lock(&iflock); {
461
struct vpb_pvt *p = iflist; /* Find the pvt structure */
463
vpb_translate_event(&e, str);
465
if (e.type == VPB_NULL_EVENT)
466
goto done; /* Nothing to do, just a wakeup call.*/
467
while (p && p->handle != e.handle)
470
if (option_verbose > 2)
471
ast_verbose(VERBOSE_PREFIX_3 " Event [%d=>%s] on %s\n",
472
e.type, str, p ? p->dev : "null");
476
"Got event %s, no matching iface!\n", str);
481
/* Two scenarios: Are you owned or not. */
833
/* Monitor thread, doesn't die until explicitly killed. */
835
if (option_verbose > 1)
836
ast_verbose(VERBOSE_PREFIX_2 "Starting vpb monitor thread[%ld]\n",
839
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
844
char str[VPB_MAX_STR];
848
if (option_verbose > 3)
849
ast_verbose(VERBOSE_PREFIX_4 "Monitor waiting for event\n");
852
int res = vpb_get_event_sync(&e, VPB_WAIT_TIMEOUT);
853
if( (res==VPB_NO_EVENTS) || (res==VPB_TIME_OUT) ){
855
if (option_verbose > 3){
856
if (res == VPB_NO_EVENTS){
857
ast_verbose(VERBOSE_PREFIX_4 "No events....\n");
859
ast_verbose(VERBOSE_PREFIX_4 "No events, timed out....\n");
867
ast_log(LOG_ERROR,"Monitor get event error %s\n", vpb_strerror(res) );
868
ast_verbose("Monitor get event error %s\n", vpb_strerror(res) );
876
ast_mutex_lock(&monlock); {
877
vpb_translate_event(&e, str);
879
if (e.type == VPB_NULL_EVENT) {
880
if (option_verbose > 3)
881
ast_verbose(VERBOSE_PREFIX_4 "Monitor got null event\n");
882
goto done; /* Nothing to do, just a wakeup call.*/
885
str[(strlen(str)-1)]='\0';
888
ast_mutex_lock(&iflock); {
890
while (p && p->handle != e.handle)
892
} ast_mutex_unlock(&iflock);
894
if (p && (option_verbose > 3))
895
ast_verbose(VERBOSE_PREFIX_4 "%s: Event [%d=>%s] \n",
896
p ? p->dev : "null", e.type, str );
899
} ast_mutex_unlock(&monlock);
902
if (e.type != VPB_NULL_EVENT){
903
ast_log(LOG_WARNING, "Got event [%s][%d], no matching iface!\n", str,e.type);
904
if (option_verbose > 3){
905
ast_verbose(VERBOSE_PREFIX_4 "vpb/ERR: No interface for Event [%d=>%s] \n",e.type,str );
911
/* flush the event from the channel event Q */
912
vpb_get_event_ch_async(e.handle,&je);
913
if (option_verbose > 4){
914
vpb_translate_event(&je, str);
915
ast_verbose("%s: Flushing event [%d]=>%s\n",p->dev,je.type,str);
918
/* Check for ownership and locks */
919
if ((p->owner)&&(!p->golock)){
920
/* Need to get owner lock */
921
/* Safely grab both p->lock and p->owner->lock so that there
922
cannot be a race with something from the other side */
924
ast_mutex_lock(&p->lock);
925
while(ast_mutex_trylock(&p->owner->lock)) {
926
ast_mutex_unlock(&p->lock);
928
ast_mutex_lock(&p->lock);
936
/* Two scenarios: Are you owned or not. */
484
938
monitor_handle_owned(p, &e);
486
monitor_handle_notowned(p, &e);
489
} ast_mutex_unlock(&iflock);
490
ast_mutex_unlock(&monlock);
493
tcounter += VPB_WAIT_TIMEOUT; /* Ok, not quite but will suffice. */
940
monitor_handle_notowned(p, &e);
942
/* if ((!p->owner)&&(p->golock)){
943
ast_mutex_unlock(&p->owner->lock);
944
ast_mutex_unlock(&p->lock);
501
953
static int restart_monitor(void)
505
/* If we're supposed to be stopped -- stay stopped */
506
if (mthreadactive == -2)
508
ast_mutex_lock(&monlock); {
509
if (monitor_thread == pthread_self()) {
510
ast_log(LOG_WARNING, "Cannot kill myself\n");
514
if (mthreadactive != -1) {
515
/* Why do other drivers kill the thread? No need says I, simply awake thread with event. */
518
e.type = VPB_NULL_EVENT;
957
/* If we're supposed to be stopped -- stay stopped */
958
if (mthreadactive == -2)
961
if (option_verbose > 3)
962
ast_verbose(VERBOSE_PREFIX_4 "Restarting monitor\n");
964
ast_mutex_lock(&monlock); {
965
if (monitor_thread == pthread_self()) {
966
ast_log(LOG_WARNING, "Cannot kill myself\n");
968
if (option_verbose > 3)
969
ast_verbose(VERBOSE_PREFIX_4 "Monitor trying to kill monitor\n");
972
if (mthreadactive != -1) {
973
/* Why do other drivers kill the thread? No need says I, simply awake thread with event. */
976
e.type = VPB_NULL_EVENT;
979
if (option_verbose > 3)
980
ast_verbose(VERBOSE_PREFIX_4 "Trying to reawake monitor\n");
984
/* Start a new monitor */
985
int pid = ast_pthread_create(&monitor_thread, NULL, do_monitor, NULL);
986
if (option_verbose > 3)
987
ast_verbose(VERBOSE_PREFIX_4 "Created new monitor thread %d\n",pid);
989
ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
993
mthreadactive = 0; /* Started the thread!*/
996
} ast_mutex_unlock(&monlock);
998
if (option_verbose > 3)
999
ast_verbose(VERBOSE_PREFIX_4 "Monitor restarted\n");
1004
// Per board config that must be called after vpb_open()
1005
static void mkbrd(vpb_model_t model, int echo_cancel)
1008
if(model==vpb_model_v4pci)
1009
max_bridges = MAX_BRIDGES_V4PCI;
1010
bridges = (vpb_bridge_t *)malloc(max_bridges * sizeof(vpb_bridge_t) );
1012
ast_log(LOG_ERROR, "Failed to initialize bridges\n");
1014
memset(bridges,0,max_bridges * sizeof(vpb_bridge_t));
1015
for(int i = 0; i < max_bridges; i++ ) {
1016
ast_mutex_init(&bridges[i].lock);
1017
pthread_cond_init(&bridges[i].cond, NULL);
1022
if (model==vpb_model_v4pci) {
1023
vpb_echo_canc_disable();
1024
ast_log(LOG_NOTICE, "Voicetronix echo cancellation OFF\n");
1027
/* need to it port by port for OpenSwitch*/
1030
if (model==vpb_model_v4pci) {
1031
vpb_echo_canc_enable();
1032
ast_log(LOG_NOTICE, "Voicetronix echo cancellation ON\n");
1035
/* need to it port by port for OpenSwitch*/
1040
struct vpb_pvt *mkif(int board, int channel, int mode, float txgain, float rxgain,
1041
float txswgain, float rxswgain, int bal1, int bal2, int bal3,
1042
char * callerid, int echo_cancel, int group )
1044
struct vpb_pvt *tmp;
1047
tmp = (struct vpb_pvt *)calloc(1, sizeof *tmp);
1052
tmp->handle = vpb_open(board, channel);
1054
if (tmp->handle < 0) {
1055
ast_log(LOG_WARNING, "Unable to create channel vpb/%d-%d: %s\n",
1056
board, channel, strerror(errno));
523
/* Start a new monitor */
524
int pid = pthread_create(&monitor_thread, NULL, do_monitor, NULL);
526
ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
530
mthreadactive = 0; /* Started the thread!*/
533
if (option_verbose > 4)
534
ast_verbose(VERBOSE_PREFIX_3
535
"Starting vpb restast: thread[%d]\n",
540
} ast_mutex_unlock(&monlock);
545
struct vpb_pvt *mkif(int board, int channel, int mode, float txgain, float rxgain)
550
tmp = (struct vpb_pvt *)calloc(1, sizeof *tmp);
555
tmp->handle = vpb_open(board, channel);
557
if (tmp->handle < 0) {
558
ast_log(LOG_WARNING, "Unable to create channel vpb/%d-%d: %s\n",
559
board, channel, strerror(errno));
565
if (option_verbose > 4)
566
ast_verbose(VERBOSE_PREFIX_3 " vpb turned on echo cancel.\n");
567
vpb_echo_canc_enable();
568
vpb_echo_canc_force_adapt_on();
569
echocancel = 0; /* So we do not initialise twice! */
572
if (option_verbose > 4)
573
ast_verbose(VERBOSE_PREFIX_3 " vpb created channel: [%d:%d]\n",
576
sprintf(tmp->dev, "vpb/%d-%d", board, channel);
580
strcpy(tmp->language, language);
581
strcpy(tmp->context, context);
583
strcpy(tmp->callerid, callerid);
584
tmp->txgain = txgain;
586
tmp->rxgain = rxgain;
589
tmp->lastoutput = -1;
595
ast_mutex_init(&tmp->lock);
598
vpb_record_set_gain(tmp->handle, rxgain);
600
vpb_play_set_gain(tmp->handle, txgain);
1061
snprintf(tmp->dev, sizeof(tmp->dev), "vpb/%d-%d", board, channel);
1068
strncpy(tmp->language, language, sizeof(tmp->language) - 1);
1069
strncpy(tmp->context, context, sizeof(tmp->context) - 1);
1072
strncpy(tmp->callerid, callerid, sizeof(tmp->callerid) - 1);
1075
strncpy(tmp->callerid, "unknown", sizeof(tmp->callerid) - 1);
1078
/* check if codec balances have been set in the config file */
1080
if ((bal1>=0) && !(bal1 & 32)) bal1 |= 32;
1081
vpb_set_codec_reg(tmp->handle, 0x42, bal3);
1083
if(bal1>=0) vpb_set_codec_reg(tmp->handle, 0x32, bal1);
1084
if(bal2>=0) vpb_set_codec_reg(tmp->handle, 0x3a, bal2);
1086
tmp->txgain = txgain;
1087
vpb_play_set_hw_gain(tmp->handle, (txgain > MAX_VPB_GAIN) ? MAX_VPB_GAIN : txgain);
1089
tmp->rxgain = rxgain;
1090
vpb_record_set_hw_gain(tmp->handle, (rxgain > MAX_VPB_GAIN) ? MAX_VPB_GAIN : rxgain);
1092
tmp->txswgain = txswgain;
1093
vpb_play_set_gain(tmp->handle, (txswgain > MAX_VPB_GAIN) ? MAX_VPB_GAIN : txswgain);
1095
tmp->rxswgain = rxswgain;
1096
vpb_record_set_gain(tmp->handle, (rxswgain > MAX_VPB_GAIN) ? MAX_VPB_GAIN : rxswgain);
1098
tmp->vpb_model = vpb_model_unknown;
1099
if( vpb_get_model(buf) == VPB_OK ) {
1100
if(strcmp(buf,"V12PCI")==0)
1101
tmp->vpb_model = vpb_model_v12pci;
1102
else if(strcmp(buf,"VPB4")==0)
1103
tmp->vpb_model = vpb_model_v4pci;
1106
ast_mutex_init(&tmp->owner_lock);
1107
ast_mutex_init(&tmp->lock);
1108
ast_mutex_init(&tmp->record_lock);
1109
ast_mutex_init(&tmp->play_lock);
1110
ast_mutex_init(&tmp->play_dtmf_lock);
1112
/* set default read state */
1113
tmp->read_state = 0;
1117
tmp->busy_timer_id = vpb_timer_get_unique_timer_id();
1118
vpb_timer_open(&tmp->busy_timer, tmp->handle, tmp->busy_timer_id, TIMER_PERIOD_BUSY);
1120
tmp->ringback_timer_id = vpb_timer_get_unique_timer_id();
1121
vpb_timer_open(&tmp->ringback_timer, tmp->handle, tmp->ringback_timer_id, TIMER_PERIOD_RINGBACK);
1123
if (mode == MODE_FXO){
1124
vpb_set_event_mask(tmp->handle, VPB_EVENTS_ALL );
1127
vpb_set_event_mask(tmp->handle, VPB_EVENTS_STAT );
1130
if ((tmp->vpb_model == vpb_model_v12pci) && (echo_cancel)){
1131
vpb_hostecho_on(tmp->handle);
1134
/* define grunt tone */
1135
vpb_settonedet(tmp->handle,&toned_ungrunt);
1137
ast_log(LOG_NOTICE,"Voicetronix %s channel %s initialized (rxgain=%f txgain=%f) (%f/%f/0x%X/0x%X/0x%X)\n",
1138
(tmp->vpb_model==vpb_model_v4pci)?"V4PCI":
1139
(tmp->vpb_model==vpb_model_v12pci)?"V12PCI":"[Unknown model]",
1140
tmp->dev, tmp->rxswgain, tmp->txswgain, tmp->rxgain, tmp->txgain, bal1, bal2, bal3 );
606
1145
static int vpb_indicate(struct ast_channel *ast, int condition)
608
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
611
if (option_verbose > 4)
612
ast_verbose(VERBOSE_PREFIX_3 " vpb indicate on %s with %d\n",
616
case AST_CONTROL_BUSY:
617
case AST_CONTROL_CONGESTION:
618
while (vpb_playtone_state(p->handle) != 0){
619
res = vpb_tone_terminate(p->handle);
622
res = vpb_playtone_async(p->handle, &Busytone);
624
case AST_CONTROL_RINGING:
625
while (vpb_playtone_state(p->handle) != 0){
626
res = vpb_tone_terminate(p->handle);
629
res = vpb_playtone_async(p->handle, &Ringbacktone);
631
case AST_CONTROL_ANSWER:
632
case -1: /* -1 means stop playing? */
633
while (vpb_playtone_state(p->handle) != 0){
634
res = vpb_tone_terminate(p->handle);
639
case AST_CONTROL_HANGUP:
640
while (vpb_playtone_state(p->handle) != 0){
641
res = vpb_tone_terminate(p->handle);
644
res = vpb_playtone_async(p->handle, &Busytone);
1147
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
1151
if (option_verbose > 3)
1152
ast_verbose(VERBOSE_PREFIX_4 "%s: vpb_indicate [%d] state[%d]\n", p->dev, condition,ast->_state);
1154
if (ast->_state != AST_STATE_UP) {
1155
ast_verbose(VERBOSE_PREFIX_4 "%s: vpb_indicate Not in AST_STATE_UP\n", p->dev, condition,ast->_state);
1161
if (option_verbose > 3) ast_verbose("%s: LOCKING in indicate \n", p->dev);
1162
if (option_verbose > 3) ast_verbose("%s: LOCKING count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
1164
ast_mutex_lock(&p->lock);
1166
case AST_CONTROL_BUSY:
1167
case AST_CONTROL_CONGESTION:
1168
if (ast->_state == AST_STATE_UP) {
1169
playtone(p->handle, &Busytone);
1170
p->state = VPB_STATE_PLAYBUSY;
1171
vpb_timer_stop(p->busy_timer);
1172
vpb_timer_start(p->busy_timer);
1175
case AST_CONTROL_RINGING:
1176
if (ast->_state == AST_STATE_UP) {
1177
playtone(p->handle, &Ringbacktone);
1178
p->state = VPB_STATE_PLAYRING;
1179
if (option_verbose > 3)
1180
ast_verbose(VERBOSE_PREFIX_4 "%s: vpb indicate: setting ringback timer [%d]\n", p->dev,p->ringback_timer_id);
1182
vpb_timer_stop(p->ringback_timer);
1183
vpb_timer_start(p->ringback_timer);
1186
case AST_CONTROL_ANSWER:
1187
case -1: /* -1 means stop playing? */
1188
vpb_timer_stop(p->ringback_timer);
1189
vpb_timer_stop(p->busy_timer);
1190
stoptone(p->handle);
1192
case AST_CONTROL_HANGUP:
1193
if (ast->_state == AST_STATE_UP) {
1194
playtone(p->handle, &Busytone);
1195
p->state = VPB_STATE_PLAYBUSY;
1196
vpb_timer_stop(p->busy_timer);
1197
vpb_timer_start(p->busy_timer);
1205
tmp = ast_mutex_unlock(&p->lock);
1207
if (option_verbose > 3) ast_verbose("%s: unLOCKING in indicate [%d]\n", p->dev,tmp);
654
1212
static int vpb_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
656
1214
struct vpb_pvt *p = (struct vpb_pvt *)newchan->pvt->pvt;
659
"New owner for channel %s is %s\n", p->dev, newchan->name);
660
if (p->owner == oldchan)
1218
if (option_verbose > 3) ast_verbose("%s: LOCKING in fixup \n", p->dev);
1219
if (option_verbose > 3) ast_verbose("%s: LOCKING count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
1221
ast_mutex_lock(&p->lock);
1222
ast_log(LOG_DEBUG, "New owner for channel %s is %s\n", p->dev, newchan->name);
1224
if (p->owner == oldchan) {
661
1225
p->owner = newchan;
663
1228
if (newchan->_state == AST_STATE_RINGING)
664
1229
vpb_indicate(newchan, AST_CONTROL_RINGING);
1231
res= ast_mutex_unlock(&p->lock);
1233
if (option_verbose > 3) ast_verbose("%s: unLOCKING in fixup [%d]\n", p->dev,res);
669
1238
static int vpb_digit(struct ast_channel *ast, char digit)
676
return vpb_dial_sync(((struct vpb_pvt *)ast->pvt->pvt)->handle, s);
1240
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
1245
if (option_verbose > 3) ast_verbose("%s: LOCKING in digit \n", p->dev);
1246
if (option_verbose > 3) ast_verbose("%s: LOCKING count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
1248
ast_mutex_lock(&p->lock);
1254
if (option_verbose > 3)
1255
ast_verbose(VERBOSE_PREFIX_4 "%s: play digit[%s]\n", p->dev, s);
1257
ast_mutex_lock(&p->play_dtmf_lock);
1258
strncat(p->play_dtmf,s,sizeof(*p->play_dtmf));
1259
ast_mutex_unlock(&p->play_dtmf_lock);
1261
res = ast_mutex_unlock(&p->lock);
1263
if (option_verbose > 3) ast_verbose("%s: unLOCKING in digit [%d]\n", p->dev,res);
1268
/* Places a call out of a VPB channel */
680
1269
static int vpb_call(struct ast_channel *ast, char *dest, int timeout)
682
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
684
char *s = strrchr(dest, '/');
691
if (ast->_state != AST_STATE_DOWN && ast->_state != AST_STATE_RESERVED) {
692
ast_log(LOG_WARNING, "vpb_call on %s neither down nor reserved!\n",
696
if (p->mode != MODE_FXO) /* Station port, ring it. */
697
res = vpb_ring_station_async(p->handle, VPB_RING_STATION_ON,'1');
701
vpb_get_call(p->handle, &call);
703
call.dialtone_timeout = VPB_DIALTONE_WAIT;
704
call.answer_timeout = timeout;
705
call.ringback_timeout = VPB_RINGWAIT;
707
vpb_set_call(p->handle, &call);
709
if (option_verbose > 2)
710
ast_verbose(VERBOSE_PREFIX_3 " Calling %s on %s \n",
713
vpb_sethook_sync(p->handle,VPB_OFFHOOK);
715
res = vpb_dial_async(p->handle, s);
718
ast_log(LOG_DEBUG, "Call on %s to %s failed: %s\n",
719
ast->name, dest, vpb_strerror(res));
725
if (option_verbose > 2)
726
ast_verbose(VERBOSE_PREFIX_3
727
" VPB Calling %s [t=%d] on %s returned %d\n",
728
dest, timeout, ast->name, res);
732
vpb_timer_open(&p->timer, p->handle, 0, 100*timeout);
733
vpb_timer_start(p->timer);
736
ast_setstate(ast, AST_STATE_RINGING);
737
ast_queue_control(ast,AST_CONTROL_RINGING, 0);
1271
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
1273
char *s = strrchr(dest, '/');
1274
char dialstring[254] = "";
1278
if (option_verbose > 3) ast_verbose("%s: LOCKING in call \n", p->dev);
1279
if (option_verbose > 3) ast_verbose("%s: LOCKING count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
1281
ast_mutex_lock(&p->lock);
1287
strncpy(dialstring, s, sizeof(dialstring) - 1);
1288
for (i=0; dialstring[i] != '\0' ; i++) {
1289
if ((dialstring[i] == 'w') || (dialstring[i] == 'W'))
1290
dialstring[i] = ',';
1291
else if ((dialstring[i] == 'f') || (dialstring[i] == 'F'))
1292
dialstring[i] = '&';
1294
if (option_verbose > 3)
1295
ast_verbose(VERBOSE_PREFIX_4 "%s: starting call\n", p->dev);
1297
if (ast->_state != AST_STATE_DOWN && ast->_state != AST_STATE_RESERVED) {
1298
ast_log(LOG_WARNING, "vpb_call on %s neither down nor reserved!\n", ast->name);
1299
tmp = ast_mutex_unlock(&p->lock);
1301
if (option_verbose > 3) ast_verbose("%s: unLOCKING in call [%d]\n", p->dev,tmp);
1305
if (p->mode != MODE_FXO) /* Station port, ring it. */
1306
res = vpb_ring_station_async(p->handle, VPB_RING_STATION_ON,0);
1310
// Dial must timeout or it can leave channels unuseable
1312
timeout = TIMER_PERIOD_NOANSWER;
1314
timeout = timeout * 1000; //convert from secs to ms.
1316
// These timeouts are only used with call progress dialing
1317
call.dialtones = 1; // Number of dialtones to get outside line
1318
call.dialtone_timeout = VPB_DIALTONE_WAIT; // Wait this long for dialtone (ms)
1319
call.ringback_timeout = VPB_RINGWAIT; // Wait this long for ringing after dialing (ms)
1320
call.inter_ringback_timeout = VPB_CONNECTED_WAIT; // If ringing stops for this long consider it connected (ms)
1321
call.answer_timeout = timeout; // Time to wait for answer after ringing starts (ms)
1322
memcpy( &call.tone_map, DialToneMap, sizeof(DialToneMap) );
1323
vpb_set_call(p->handle, &call);
1325
if (option_verbose > 1)
1326
ast_verbose(VERBOSE_PREFIX_2 "%s: Calling %s on %s \n",p->dev, dialstring, ast->name);
1328
if (option_verbose > 2) {
1330
ast_verbose(VERBOSE_PREFIX_2 "%s: Dial parms for %s %d/%dms/%dms/%dms/%dms\n", p->dev
1331
, ast->name, call.dialtones, call.dialtone_timeout
1332
, call.ringback_timeout, call.inter_ringback_timeout
1333
, call.answer_timeout );
1334
for( j=0; !call.tone_map[j].terminate; j++ )
1335
ast_verbose(VERBOSE_PREFIX_2 "%s: Dial parms for %s tone %d->%d\n", p->dev,
1336
ast->name, call.tone_map[j].tone_id, call.tone_map[j].call_id);
1339
if (option_verbose > 4)
1340
ast_verbose("%s: Disabling Loop Drop detection\n",p->dev);
1341
vpb_disable_event(p->handle, VPB_MDROP);
1342
vpb_sethook_sync(p->handle,VPB_OFFHOOK);
1343
p->state=VPB_STATE_OFFHOOK;
1345
#ifndef DIAL_WITH_CALL_PROGRESS
1347
if (option_verbose > 4)
1348
ast_verbose("%s: Disabling Loop Drop detection\n",p->dev);
1349
vpb_enable_event(p->handle, VPB_MDROP);
1350
res = vpb_dial_async(p->handle, dialstring);
1352
if (option_verbose > 4)
1353
ast_verbose("%s: Disabling Loop Drop detection\n",p->dev);
1354
vpb_enable_event(p->handle, VPB_MDROP);
1355
res = vpb_call_async(p->handle, dialstring);
1358
if (res != VPB_OK) {
1359
ast_log(LOG_DEBUG, "Call on %s to %s failed: %s\n", ast->name, s, vpb_strerror(res));
1365
if (option_verbose > 2)
1366
ast_verbose(VERBOSE_PREFIX_3 "%s: VPB Calling %s [t=%d] on %s returned %d\n",p->dev , s, timeout, ast->name, res);
1368
ast_setstate(ast, AST_STATE_RINGING);
1369
ast_queue_control(ast,AST_CONTROL_RINGING);
1372
if (!p->readthread){
1373
ast_pthread_create(&p->readthread, NULL, do_chanreads, (void *)p);
1376
tmp = ast_mutex_unlock(&p->lock);
1378
if (option_verbose > 3) ast_verbose("%s: unLOCKING in call [%d]\n", p->dev,tmp);
743
1383
static int vpb_hangup(struct ast_channel *ast)
747
if (option_verbose > 2)
748
ast_verbose(VERBOSE_PREFIX_3 " hangup on vpb (%s)\n", ast->name);
750
if (!ast->pvt || !ast->pvt->pvt) {
751
ast_log(LOG_WARNING, "channel (%s) not connected?\n", ast->name);
1385
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
1387
char str[VPB_MAX_STR];
1391
if (option_verbose > 3) ast_verbose("%s: LOCKING in hangup \n", p->dev);
1392
if (option_verbose > 3) ast_verbose("%s: LOCKING in hangup count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
1393
if (option_verbose > 3) ast_verbose("%s: LOCKING pthread_self(%d)\n", p->dev,pthread_self());
1394
ast_mutex_lock(&p->lock);
1396
if (option_verbose > 1)
1397
ast_verbose(VERBOSE_PREFIX_2 "%s: Hangup requested\n", ast->name);
1399
if (!ast->pvt || !ast->pvt->pvt) {
1400
ast_log(LOG_WARNING, "%s: channel not connected?\n", ast->name);
1401
res = ast_mutex_unlock(&p->lock);
1403
if (option_verbose > 3) ast_verbose("%s: unLOCKING in hangup [%d]\n", p->dev,res);
1412
if( p->readthread ){
1413
pthread_join(p->readthread, NULL);
1414
if(option_verbose>3)
1415
ast_verbose( VERBOSE_PREFIX_4 "%s: stopped record thread on %s\n",ast->name,p->dev);
1419
if (p->lastoutput != -1) {
1420
if(option_verbose>1)
1421
ast_verbose( VERBOSE_PREFIX_2 "%s: Ending play mode on %s\n",ast->name,p->dev);
1422
vpb_play_terminate(p->handle);
1423
ast_mutex_lock(&p->play_lock); {
1424
vpb_play_buf_finish(p->handle);
1425
} ast_mutex_unlock(&p->play_lock);
1428
if(option_verbose>3)
1429
ast_verbose( VERBOSE_PREFIX_4 "%s: Setting state down\n",ast->name);
1430
ast_setstate(ast,AST_STATE_DOWN);
1434
if (option_verbose > 3) ast_verbose("%s: LOCKING in hangup \n", p->dev);
1435
if (option_verbose > 3) ast_verbose("%s: LOCKING in hangup count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
1436
if (option_verbose > 3) ast_verbose("%s: LOCKING pthread_self(%d)\n", p->dev,pthread_self());
1438
ast_mutex_lock(&p->lock);
1440
if (p->mode != MODE_FXO) {
1442
vpb_ring_station_async(p->handle, VPB_RING_STATION_OFF,0);
1443
if(p->state!=VPB_STATE_ONHOOK){
1444
/* This is causing a "dial end" "play tone" loop
1445
playtone(p->handle, &Busytone);
1446
p->state = VPB_STATE_PLAYBUSY;
1447
if(option_verbose>4)
1448
ast_verbose( VERBOSE_PREFIX_4 "%s: Station offhook[%d], playing busy tone\n",
1449
ast->name,p->state);
1453
stoptone(p->handle);
1456
stoptone(p->handle); // Terminates any dialing
1457
vpb_sethook_sync(p->handle, VPB_ONHOOK);
1458
p->state=VPB_STATE_ONHOOK;
1460
while (VPB_OK==vpb_get_event_ch_async(p->handle,&je)){
1461
if(option_verbose>3) {
1462
vpb_translate_event(&je, str);
1463
ast_verbose( VERBOSE_PREFIX_4 "%s: Flushing event [%d]=>%s\n",ast->name,je.type,str);
1470
p->last_ignore_dtmf = 1;
1477
ast_mutex_lock(&usecnt_lock); {
1479
} ast_mutex_unlock(&usecnt_lock);
1480
ast_update_use_count();
1482
if (option_verbose > 1)
1483
ast_verbose(VERBOSE_PREFIX_2 "%s: Hangup complete\n", ast->name);
1487
if (option_verbose > 3) ast_verbose("%s: LOCKING in hangup count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
1489
res = ast_mutex_unlock(&p->lock);
1491
if (option_verbose > 3) ast_verbose("%s: unLOCKING in hangup [%d]\n", p->dev,res);
1492
if (option_verbose > 3) ast_verbose("%s: LOCKING in hangup count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
755
p = (struct vpb_pvt *)ast->pvt->pvt;
757
vpb_play_terminate(p->handle);
758
vpb_record_terminate(p->handle);
760
if (p->mode != MODE_FXO) { /* station port. */
761
vpb_ring_station_async(p->handle, VPB_RING_STATION_OFF,'1');
762
vpb_playtone_async(p->handle, &Busytone);
765
vpb_sethook_sync(p->handle, VPB_ONHOOK);
767
ast_setstate(ast,AST_STATE_DOWN);
769
ast_mutex_lock(&p->lock); {
770
p->lastinput = p->lastoutput = -1;
775
ast->pvt->pvt = NULL;
776
} ast_mutex_unlock(&p->lock);
778
ast_mutex_lock(&usecnt_lock); {
780
} ast_mutex_unlock(&usecnt_lock);
781
ast_update_use_count();
783
/* Stop thread doing reads. */
785
pthread_join(p->readthread, NULL);
787
if (option_verbose > 2)
788
ast_verbose(VERBOSE_PREFIX_3 " Hungup on %s complete\n", ast->name);
794
1497
static int vpb_answer(struct ast_channel *ast)
796
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
798
if (p->mode == MODE_FXO)
799
vpb_sethook_sync(p->handle, VPB_OFFHOOK);
802
ast_log(LOG_DEBUG, "vpb answer on %s\n", ast->name);
804
ast_setstate(ast, AST_STATE_UP);
1499
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
1504
if (option_verbose > 3) ast_verbose("%s: LOCKING in answer \n", p->dev);
1505
if (option_verbose > 3) ast_verbose("%s: LOCKING count[%d] owner[%d] \n", p->dev, p->lock.__m_count,p->lock.__m_owner);
1507
ast_mutex_lock(&p->lock);
1509
if (option_verbose > 3)
1510
ast_verbose(VERBOSE_PREFIX_4 "%s: Answering channel\n",p->dev);
1512
if (p->mode == MODE_FXO){
1513
if (option_verbose > 3)
1514
ast_verbose("%s: Disabling Loop Drop detection\n",p->dev);
1515
vpb_disable_event(p->handle, VPB_MDROP);
1518
if (ast->_state != AST_STATE_UP) {
1519
if (p->mode == MODE_FXO){
1520
vpb_sethook_sync(p->handle, VPB_OFFHOOK);
1521
p->state=VPB_STATE_OFFHOOK;
1523
ret = vpb_get_event_ch_async(p->handle,&je);
1524
if ((ret == VPB_OK)&&((je.type != VPB_DROP)&&(je.type != VPB_RING))){
1525
if (option_verbose > 3){
1526
ast_verbose(VERBOSE_PREFIX_4 "%s: Answer collected a wrong event!!\n",p->dev);
1532
ast_setstate(ast, AST_STATE_UP);
1534
if(option_verbose>1)
1535
ast_verbose( VERBOSE_PREFIX_2 "%s: Answered call from %s on %s [%s]\n", p->dev,
1536
p->owner->callerid, ast->name,(p->mode == MODE_FXO)?"FXO":"FXS");
1539
if( !p->readthread ){
1540
// res = ast_mutex_unlock(&p->lock);
1541
// ast_verbose("%s: unLOCKING in answer [%d]\n", p->dev,res);
1542
ast_pthread_create(&p->readthread, NULL, do_chanreads, (void *)p);
1544
if(option_verbose>3)
1545
ast_verbose(VERBOSE_PREFIX_4 "%s: Record thread already running!!\n",p->dev);
1548
if(option_verbose>3) {
1549
ast_verbose(VERBOSE_PREFIX_4 "%s: Answered state is up\n",p->dev);
1551
// res = ast_mutex_unlock(&p->lock);
1552
// ast_verbose("%s: unLOCKING in answer [%d]\n", p->dev,res);
1555
if (p->mode == MODE_FXO){
1556
if (option_verbose > 3)
1557
ast_verbose("%s: Re-enabling Loop Drop detection\n",p->dev);
1558
vpb_enable_event(p->handle,VPB_MDROP);
1560
res = ast_mutex_unlock(&p->lock);
1562
if(option_verbose>3) ast_verbose("%s: unLOCKING in answer [%d]\n", p->dev,res);
809
1567
static struct ast_frame *vpb_read(struct ast_channel *ast)
811
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
812
static struct ast_frame f = {AST_FRAME_NULL};
815
ast_log(LOG_NOTICE, "vpb_read should never be called (chan=%s)!\n", p->dev);
1569
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
1570
static struct ast_frame f = {AST_FRAME_NULL};
1573
ast_log(LOG_NOTICE, "%s: vpb_read: should never be called!\n", p->dev);
1574
ast_verbose("%s: vpb_read: should never be called!\n", p->dev);
820
1579
static inline int ast2vpbformat(int ast_format)
824
case AST_FORMAT_ALAW:
826
case AST_FORMAT_SLINEAR:
828
case AST_FORMAT_ULAW:
830
case AST_FORMAT_ADPCM:
1581
switch(ast_format) {
1582
case AST_FORMAT_ALAW:
1584
case AST_FORMAT_SLINEAR:
1586
case AST_FORMAT_ULAW:
1588
case AST_FORMAT_ADPCM:
1589
return VPB_OKIADPCM;
1595
static inline char * ast2vpbformatname(int ast_format)
1597
switch(ast_format) {
1598
case AST_FORMAT_ALAW:
1599
return "AST_FORMAT_ALAW:VPB_ALAW";
1600
case AST_FORMAT_SLINEAR:
1601
return "AST_FORMAT_SLINEAR:VPB_LINEAR";
1602
case AST_FORMAT_ULAW:
1603
return "AST_FORMAT_ULAW:VPB_MULAW";
1604
case AST_FORMAT_ADPCM:
1605
return "AST_FORMAT_ADPCM:VPB_OKIADPCM";
838
1611
static inline int astformatbits(int ast_format)
842
case AST_FORMAT_ALAW:
843
case AST_FORMAT_ULAW:
845
case AST_FORMAT_SLINEAR:
847
case AST_FORMAT_ADPCM:
1613
switch(ast_format) {
1614
case AST_FORMAT_ALAW:
1615
case AST_FORMAT_ULAW:
1617
case AST_FORMAT_SLINEAR:
1619
case AST_FORMAT_ADPCM:
1626
int a_gain_vector(float g, short *v, int n)
1630
for ( i = 0; i<n; i++) {
1641
/* Writes a frame of voice data to a VPB channel */
854
1642
static int vpb_write(struct ast_channel *ast, struct ast_frame *frame)
856
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
857
int res = 0, fmt = 0;
859
if (frame->frametype != AST_FRAME_VOICE) {
860
ast_log(LOG_WARNING, "Don't know how to handle from type %d\n",
863
} else if (ast->_state != AST_STATE_UP) {
864
if (option_verbose > 4)
865
ast_log(LOG_WARNING, "Writing frame type [%d,%d] on chan %s not up\n",
866
frame->frametype, frame->subclass, ast->name);
872
fmt = ast2vpbformat(frame->subclass);
874
if (option_verbose > 4)
875
ast_verbose(VERBOSE_PREFIX_3
876
" Write chan %s: got frame type = %d\n",
877
p->dev, frame->subclass);
880
ast_log(LOG_WARNING, "vpb_write Cannot handle frames of %d format!\n",
886
if (p->lastoutput != fmt) {
887
vpb_play_buf_start(p->handle, fmt);
891
memcpy(p->obuf, frame->data,
892
(frame->datalen > (int)sizeof p->obuf) ? sizeof p->obuf : frame->datalen);
893
res = vpb_play_buf_sync(p->handle, p->obuf, frame->datalen);
1644
struct vpb_pvt *p = (struct vpb_pvt *)ast->pvt->pvt;
1645
int res = 0, fmt = 0;
1646
struct timeval play_buf_time_start,play_buf_time_finish;
1647
// ast_mutex_lock(&p->lock);
1648
if(option_verbose>5)
1649
ast_verbose("%s: vpb_write: Writing to channel\n", p->dev);
1651
if (frame->frametype != AST_FRAME_VOICE) {
1652
if(option_verbose>3)
1653
ast_verbose("%s: vpb_write: Don't know how to handle from type %d\n", ast->name, frame->frametype);
1654
// ast_mutex_unlock(&p->lock);
1656
} else if (ast->_state != AST_STATE_UP) {
1657
if(option_verbose>3)
1658
ast_verbose("%s: vpb_write: Attempt to Write frame type[%d]subclass[%d] on not up chan\n",ast->name, frame->frametype, frame->subclass);
1660
// ast_mutex_unlock(&p->lock);
1663
ast_log(LOG_DEBUG, "%s: vpb_write: Checked frame type..\n", p->dev);
1665
fmt = ast2vpbformat(frame->subclass);
1667
ast_log(LOG_WARNING, "%s: vpb_write: Cannot handle frames of %d format!\n",ast->name, frame->subclass);
1670
ast_log(LOG_DEBUG, "%s: vpb_write: Checked frame format..\n", p->dev);
1672
ast_mutex_lock(&p->play_lock);
1674
ast_log(LOG_DEBUG, "%s: vpb_write: Got play lock..\n", p->dev);
1676
/* Check if we have set up the play_buf */
1677
if (p->lastoutput == -1) {
1678
vpb_play_buf_start(p->handle, fmt);
1679
if(option_verbose>1) {
1680
ast_verbose("%s: vpb_write: Starting play mode (codec=%d)[%s]\n",p->dev,fmt,ast2vpbformatname(frame->subclass));
1682
} else if (p->lastoutput != fmt) {
1683
vpb_play_buf_finish(p->handle);
1684
vpb_play_buf_start(p->handle, fmt);
1685
if(option_verbose>1)
1686
ast_verbose("%s: vpb_write: Changed play format (%d=>%d)\n",p->dev,p->lastoutput,fmt);
1688
p->lastoutput = fmt;
1692
// Apply extra gain !
1693
if( p->txswgain > MAX_VPB_GAIN )
1694
a_gain_vector(p->txswgain - MAX_VPB_GAIN , (short*)frame->data, frame->datalen/sizeof(short));
1696
ast_log(LOG_DEBUG, "%s: vpb_write: Applied gain..\n", p->dev);
1698
// gettimeofday(&tv, NULL);
1699
// return ((double)tv.tv_sec*1000)+((double)tv.tv_usec/1000);
1701
if ((p->read_state == 1)&&(p->play_buf_time<5)){
1702
gettimeofday(&play_buf_time_start,NULL);
1703
res = vpb_play_buf_sync(p->handle, (char*)frame->data, frame->datalen);
1704
if( (res == VPB_OK) && (option_verbose > 5) ) {
1705
short * data = (short*)frame->data;
1706
ast_verbose("%s: vpb_write: Wrote chan (codec=%d) %d %d\n", p->dev, fmt, data[0],data[1]);
1708
gettimeofday(&play_buf_time_finish,NULL);
1709
if (play_buf_time_finish.tv_sec == play_buf_time_start.tv_sec){
1710
p->play_buf_time=(int)((play_buf_time_finish.tv_usec-play_buf_time_start.tv_usec)/1000);
1711
// ast_log(LOG_DEBUG, "%s: vpb_write: Timing start(%d) finish(%d)\n", p->dev,play_buf_time_start.tv_usec,play_buf_time_finish.tv_usec);
1714
p->play_buf_time=(int)((play_buf_time_finish.tv_sec - play_buf_time_start.tv_sec)*100)+(int)((play_buf_time_finish.tv_usec-play_buf_time_start.tv_usec)/1000);
1716
// ast_log(LOG_DEBUG, "%s: vpb_write: Wrote data [%d](%d=>%s) to play_buf in [%d]ms..\n", p->dev,frame->datalen,fmt,ast2vpbformatname(frame->subclass),p->play_buf_time);
1720
ast_log(LOG_DEBUG, "%s: vpb_write: Tossed data away, tooooo much data!![%d]\n", p->dev,p->chuck_count);
1724
ast_mutex_unlock(&p->play_lock);
1725
// ast_mutex_unlock(&p->lock);
1726
if(option_verbose>5)
1727
ast_verbose("%s: vpb_write: Done Writing to channel\n", p->dev);
900
1731
/* Read monitor thread function. */
901
1732
static void *do_chanreads(void *pvt)
903
struct vpb_pvt *p = (struct vpb_pvt *)pvt;
904
struct ast_frame *fr = &p->fr;
905
char *readbuf = ((char *)p->buf) + AST_FRIENDLY_OFFSET;
908
fr->frametype = AST_FRAME_VOICE;
912
memset(p->buf, 0, sizeof p->buf);
914
while (!p->stopreads && p->owner) {
916
struct ast_channel *owner = p->owner;
917
int afmt = (owner) ? owner->pvt->rawreadformat : AST_FORMAT_ALAW;
918
int state = (owner) ? owner->_state : AST_STATE_DOWN;
921
fmt = ast2vpbformat(afmt);
928
readlen = VPB_SAMPLES * astformatbits(afmt) / 8;
930
if (p->lastinput != fmt) {
931
if (option_verbose > 2)
932
ast_verbose(" Read_channel ## %s: Setting record mode, bridge = %d\n",
933
p->dev, p->bridge ? 1 : 0);
934
vpb_record_buf_start(p->handle, fmt);
938
ast_mutex_lock(&p->lock); {
940
if (p->bridge->c0 == p->owner &&
941
(p->bridge->flags & AST_BRIDGE_REC_CHANNEL_0))
943
else if (p->bridge->c1 == p->owner &&
944
(p->bridge->flags & AST_BRIDGE_REC_CHANNEL_1))
950
} ast_mutex_unlock(&p->lock);
952
if (state == AST_STATE_UP && bridgerec) {
953
/* Read only if up and not bridged, or a bridge for which we can read. */
954
res = vpb_record_buf_sync(p->handle, readbuf, readlen);
961
fr->samples = VPB_SAMPLES;
963
fr->datalen = readlen;
964
fr->offset = AST_FRIENDLY_OFFSET;
966
ast_mutex_lock(&p->lock); {
967
if (p->owner) ast_queue_frame(p->owner, fr, 0);
968
} ast_mutex_unlock(&p->lock);
973
if (option_verbose > 4)
974
ast_verbose(" Read_channel %s (state=%d), res=%d, bridge=%d\n",
975
p->dev, state, res, bridgerec);
978
/* When stopreads seen, go away! */
979
vpb_record_buf_finish(p->handle);
981
if (option_verbose > 4)
982
ast_verbose(" Read_channel %s terminating, stopreads=%d, owner=%s\n",
983
p->dev, p->stopreads, p->owner? "yes" : "no");
1734
struct vpb_pvt *p = (struct vpb_pvt *)pvt;
1735
struct ast_frame *fr = &p->fr;
1736
char *readbuf = ((char *)p->buf) + AST_FRIENDLY_OFFSET;
1738
int afmt, readlen, res, fmt, trycnt=0;
1740
char * getdtmf_var = NULL;
1742
fr->frametype = AST_FRAME_VOICE;
1745
fr->delivery.tv_sec = 0;
1746
fr->delivery.tv_usec = 0;
1747
fr->samples = VPB_SAMPLES;
1748
fr->offset = AST_FRIENDLY_OFFSET;
1749
memset(p->buf, 0, sizeof p->buf);
1751
if (option_verbose > 2) {
1752
ast_verbose("%s: chanreads: starting thread\n", p->dev);
1754
ast_mutex_lock(&p->record_lock);
1758
while (!p->stopreads && p->owner) {
1760
if (option_verbose > 4)
1761
ast_verbose("%s: chanreads: Starting cycle ...\n", p->dev);
1762
if (option_verbose > 4)
1763
ast_verbose("%s: chanreads: Checking bridge \n", p->dev);
1765
if (p->bridge->c0 == p->owner && (p->bridge->flags & AST_BRIDGE_REC_CHANNEL_0))
1767
else if (p->bridge->c1 == p->owner && (p->bridge->flags & AST_BRIDGE_REC_CHANNEL_1))
1772
if (option_verbose > 4)
1773
ast_verbose("%s: chanreads: No native bridge.\n", p->dev);
1774
if (p->owner->bridge){
1775
if (option_verbose > 4){
1776
ast_verbose("%s: chanreads: Got Asterisk bridge with [%s].\n", p->dev,p->owner->bridge->name);
1785
// if ( (p->owner->_state != AST_STATE_UP) || !bridgerec) {
1786
if ( (p->owner->_state != AST_STATE_UP) ) {
1787
if (option_verbose > 4) {
1788
if (p->owner->_state != AST_STATE_UP)
1789
ast_verbose("%s: chanreads: Im not up[%d]\n", p->dev,p->owner->_state);
1791
ast_verbose("%s: chanreads: No bridgerec[%d]\n", p->dev,bridgerec);
1797
// Voicetronix DTMF detection can be triggered off ordinary speech
1798
// This leads to annoying beeps during the conversation
1799
// Avoid this problem by just setting VPB_GETDTMF when you want to listen for DTMF
1801
ignore_dtmf = 0; /* set this to 1 to turn this feature on */
1802
getdtmf_var = pbx_builtin_getvar_helper(p->owner,"VPB_GETDTMF");
1803
if( getdtmf_var && ( strcasecmp( getdtmf_var, "yes" ) == 0 ) )
1806
if( ignore_dtmf != p->last_ignore_dtmf ) {
1807
if(option_verbose>1)
1808
ast_verbose( VERBOSE_PREFIX_2 "%s:Now %s DTMF \n",
1809
p->dev, ignore_dtmf ? "ignoring" : "listening for");
1810
vpb_set_event_mask(p->handle, ignore_dtmf ? VPB_EVENTS_NODTMF : VPB_EVENTS_ALL );
1812
p->last_ignore_dtmf = ignore_dtmf;
1814
// Play DTMF digits here to avoid problem you get if playing a digit during
1815
// a record operation
1816
if (option_verbose > 5) {
1817
ast_verbose("%s: chanreads: Checking dtmf's \n", p->dev);
1819
ast_mutex_lock(&p->play_dtmf_lock);
1820
if( p->play_dtmf[0] ) {
1821
// Try to ignore DTMF event we get after playing digit
1822
// This DTMF is played by asterisk and leads to an annoying trailing beep on CISCO phones
1824
vpb_set_event_mask(p->handle, VPB_EVENTS_NODTMF );
1825
vpb_dial_sync(p->handle,p->play_dtmf);
1826
if(option_verbose>1)
1827
ast_verbose( VERBOSE_PREFIX_2 "%s: Played DTMF %s\n",p->dev,p->play_dtmf);
1828
p->play_dtmf[0] = '\0';
1829
ast_mutex_unlock(&p->play_dtmf_lock);
1830
vpb_sleep(700); // Long enough to miss echo and DTMF event
1832
vpb_set_event_mask(p->handle, VPB_EVENTS_ALL );
1835
ast_mutex_unlock(&p->play_dtmf_lock);
1837
// afmt = (p->owner) ? p->owner->pvt->rawreadformat : AST_FORMAT_SLINEAR;
1839
afmt = p->owner->pvt->rawreadformat;
1840
ast_log(LOG_DEBUG,"%s: Record using owner format [%s]\n", p->dev, ast2vpbformatname(afmt));
1843
afmt = AST_FORMAT_SLINEAR;
1844
ast_log(LOG_DEBUG,"%s: Record using default format [%s]\n", p->dev, ast2vpbformatname(afmt));
1846
fmt = ast2vpbformat(afmt);
1848
ast_log(LOG_WARNING,"%s: Record failure (unsupported format %d)\n", p->dev, afmt);
1851
readlen = VPB_SAMPLES * astformatbits(afmt) / 8;
1853
if (p->lastinput == -1) {
1854
vpb_record_buf_start(p->handle, fmt);
1855
vpb_reset_record_fifo_alarm(p->handle);
1856
if(option_verbose>1)
1857
ast_verbose( VERBOSE_PREFIX_2 "%s: Starting record mode (codec=%d)[%s]\n",p->dev,fmt,ast2vpbformatname(afmt));
1858
} else if (p->lastinput != fmt) {
1859
vpb_record_buf_finish(p->handle);
1860
vpb_record_buf_start(p->handle, fmt);
1861
if(option_verbose>1)
1862
ast_verbose( VERBOSE_PREFIX_2 "%s: Changed record format (%d=>%d)\n",p->dev,p->lastinput,fmt);
1866
/* Read only if up and not bridged, or a bridge for which we can read. */
1867
if (option_verbose > 5) {
1868
ast_verbose("%s: chanreads: getting buffer!\n", p->dev);
1870
if( (res = vpb_record_buf_sync(p->handle, readbuf, readlen) ) == VPB_OK ) {
1871
if (option_verbose > 5) {
1872
ast_verbose("%s: chanreads: got buffer!\n", p->dev);
1874
// Apply extra gain !
1875
if( p->rxswgain > MAX_VPB_GAIN )
1876
a_gain_vector(p->rxswgain - MAX_VPB_GAIN , (short*)readbuf, readlen/sizeof(short));
1877
if (option_verbose > 5) {
1878
ast_verbose("%s: chanreads: applied gain\n", p->dev);
1881
fr->subclass = afmt;
1883
fr->datalen = readlen;
1885
// Using trylock here to prevent deadlock when channel is hungup
1886
// (ast_hangup() immediately gets lock)
1887
if (p->owner && !p->stopreads ) {
1888
if (option_verbose > 5) {
1889
ast_verbose("%s: chanreads: queueing buffer on read frame q (state[%d])\n", p->dev,p->owner->_state);
1892
res = ast_mutex_trylock(&p->owner->lock);
1894
} while((res !=0)&&(trycnt<300));
1896
ast_queue_frame(p->owner, fr);
1897
ast_mutex_unlock(&p->owner->lock);
1899
if (option_verbose > 4)
1900
ast_verbose("%s: chanreads: Couldnt get lock after %d tries!\n", p->dev,trycnt);
1905
res = ast_mutex_trylock(&p->owner->lock);
1908
ast_queue_frame(p->owner, fr);
1909
ast_mutex_unlock(&p->owner->lock);
1912
if (option_verbose > 4) ast_verbose("%s: chanreads: try owner->lock gave me EINVAL[%d]\n", p->dev,res);
1913
else if (res == EBUSY )
1914
if (option_verbose > 4) ast_verbose("%s: chanreads: try owner->lock gave me EBUSY[%d]\n", p->dev,res);
1916
res = ast_mutex_trylock(&p->owner->lock);
1919
ast_queue_frame(p->owner, fr);
1920
ast_mutex_unlock(&p->owner->lock);
1924
if (option_verbose > 4) ast_verbose("%s: chanreads: try owner->lock gave me EINVAL[%d]\n", p->dev,res);
1925
else if (res == EBUSY )
1926
if (option_verbose > 4) ast_verbose("%s: chanreads: try owner->lock gave me EBUSY[%d]\n", p->dev,res);
1927
if (option_verbose > 4) ast_verbose("%s: chanreads: Couldnt get lock on owner[%s][%d][%d] channel to send frame!\n", p->dev,p->owner->name,(int)p->owner->lock.__m_owner,(int)p->owner->lock.__m_count);
1928
//assert(p->dev!=p->dev);
1932
if (option_verbose > 6) {
1933
short * data = (short*)readbuf;
1934
ast_verbose("%s: Read channel (codec=%d) %d %d\n", p->dev, fmt, data[0], data[1] );
1938
if (option_verbose > 4) {
1939
ast_verbose("%s: p->stopreads[%d] p->owner[%p]\n", p->dev, p->stopreads,(void *)p->owner);
1943
ast_log(LOG_WARNING,"%s: Record failure (%s)\n", p->dev, vpb_strerror(res));
1944
vpb_record_buf_finish(p->handle);
1945
vpb_record_buf_start(p->handle, fmt);
1947
if (option_verbose > 4)
1948
ast_verbose("%s: chanreads: Finished cycle...\n", p->dev);
1952
/* When stopreads seen, go away! */
1953
vpb_record_buf_finish(p->handle);
1955
ast_mutex_unlock(&p->record_lock);
1957
if (option_verbose > 1)
1958
ast_verbose(VERBOSE_PREFIX_2 "%s: Ending record mode (%d/%s)\n",
1959
p->dev, p->stopreads, p->owner? "yes" : "no");
988
static struct ast_channel *vpb_new(struct vpb_pvt *i, int state, char *context)
1963
static struct ast_channel *vpb_new(struct vpb_pvt *me, int state, char *context)
990
1965
struct ast_channel *tmp;
993
ast_log(LOG_WARNING, "Called vpb_new on owned channel (%s) ?!\n", i->dev);
1968
ast_log(LOG_WARNING, "Called vpb_new on owned channel (%s) ?!\n", me->dev);
1971
if (option_verbose > 3)
1972
ast_verbose("%s: New call for context [%s]\n",me->dev,context);
997
1974
tmp = ast_channel_alloc(1);
999
strncpy(tmp->name, i->dev, sizeof(tmp->name));
1976
strncpy(tmp->name, me->dev, sizeof(tmp->name) - 1);
1000
1977
tmp->type = type;
1979
// Linear is the preferred format. Although Voicetronix supports other formats
1980
// they are all converted to/from linear in the vpb code. Best for us to use
1981
// linear since we can then adjust volume in this modules.
1002
1982
tmp->nativeformats = prefformat;
1003
tmp->pvt->rawreadformat = AST_FORMAT_ALAW;
1004
tmp->pvt->rawwriteformat = AST_FORMAT_ALAW;
1983
tmp->pvt->rawreadformat = AST_FORMAT_SLINEAR;
1984
tmp->pvt->rawwriteformat = AST_FORMAT_SLINEAR;
1005
1985
ast_setstate(tmp, state);
1006
1986
if (state == AST_STATE_RING)
1007
1987
tmp->rings = 1;
1989
/* set call backs */
1009
1990
tmp->pvt->send_digit = vpb_digit;
1010
1991
tmp->pvt->call = vpb_call;
1011
1992
tmp->pvt->hangup = vpb_hangup;