projects / openwrt.git / blob
? search:


e6d531a53881b211b11ed679277cbf05af56f6a3
[openwrt.git] / package / pjsip / src / pjmedia / src / pjmedia-audiodev / tapi_dev.c
1 /******************************************************************************
2
3 Copyright (c) 2010
4 Lantiq Deutschland GmbH
5 Am Campeon 3; 85579 Neubiberg, Germany
6
7 For licensing information, see the file 'LICENSE' in the root folder of
8 this software module.
9
10 ******************************************************************************/
11 #include <pjmedia-audiodev/audiodev_imp.h>
12 #include <pjmedia/errno.h>
13 #include <pj/assert.h>
14 #include <pj/pool.h>
15 #include <pj/log.h>
16 #include <pj/os.h>
17
18 /* Linux includes */
19 #include <stdio.h>
20 #include <string.h>
21 #include <stdlib.h>
22 #include <ctype.h>
23 #include <sys/stat.h>
24 #include <fcntl.h>
25 #include <sys/types.h>
26 #include <sys/ioctl.h>
27 #include <sys/select.h>
28 #include <sys/time.h>
29 #include <unistd.h>
30 #include <poll.h>
31
32 #if PJMEDIA_AUDIO_DEV_HAS_TAPI_DEVICE
33 /* TAPI includes */
34 #include "drv_tapi_io.h"
35 #include "vmmc_io.h"
36
37 /* Maximum 2 devices */
38 #define TAPI_AUDIO_PORT_NUM (2)
39 #define TAPI_BASE_NAME "TAPI"
40 #define TAPI_LL_DEV_BASE_PATH "/dev/vmmc"
41 #define TAPI_LL_DEV_FIRMWARE_NAME "/lib/firmware/danube_firmware.bin"
42 #define TAPI_LL_BBD_NAME "/lib/firmware/danube_bbd_fxs.bin"
43
44 #define TAPI_LL_DEV_SELECT_TIMEOUT_MS (2000)
45 #define TAPI_LL_DEV_MAX_PACKET_SIZE (800)
46 #define TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE (12)
47 #define TAPI_LL_DEV_ENC_FRAME_LEN_MS (20)
48 #define TAPI_LL_DEV_ENC_SMPL_PER_SEC (8000)
49 #define TAPI_LL_DEV_ENC_BITS_PER_SMPLS (16)
50 #define TAPI_LL_DEV_ENC_SMPL_PER_FRAME (160)
51 #define TAPI_LL_DEV_ENC_BYTES_PER_FRAME (TAPI_LL_DEV_ENC_SMPL_PER_FRAME * (TAPI_LL_DEV_ENC_BITS_PER_SMPLS / 8))
52
53 #define THIS_FILE "tapi_dev.c"
54
55 #if 1
56 # define TRACE_(x) PJ_LOG(1,x)
57 #else
58 # define TRACE_(x)
59 #endif
60
61 pj_int32_t ch_fd[TAPI_AUDIO_PORT_NUM];
62
63 typedef struct
64 {
65 pj_int32_t dev_fd;
66 pj_int32_t ch_fd[TAPI_AUDIO_PORT_NUM];
67 pj_int8_t data2phone_map[TAPI_AUDIO_PORT_NUM];
68 } tapi_ctx;
69
70 struct tapi_aud_factory
71 {
72 pjmedia_aud_dev_factory base;
73 pj_pool_t *pool;
74 pj_pool_factory *pf;
75 pj_uint32_t dev_count;
76 pjmedia_aud_dev_info *dev_info;
77 tapi_ctx dev_ctx;
78 };
79
80 typedef struct tapi_aud_factory tapi_aud_factory_t;
81
82 struct tapi_aud_stream
83 {
84 pjmedia_aud_stream base;
85 pj_pool_t *pool;
86 pjmedia_aud_param param;
87 pjmedia_aud_rec_cb rec_cb;
88 pjmedia_aud_play_cb play_cb;
89 void *user_data;
90
91 pj_thread_desc thread_desc;
92 pj_thread_t *thread;
93 tapi_ctx *dev_ctx;
94 pj_uint8_t run_flag;
95 pj_timestamp timestamp;
96 };
97
98 typedef struct tapi_aud_stream tapi_aud_stream_t;
99
100 /* Factory prototypes */
101 static pj_status_t factory_init(pjmedia_aud_dev_factory *f);
102 static pj_status_t factory_destroy(pjmedia_aud_dev_factory *f);
103 static unsigned factory_get_dev_count(pjmedia_aud_dev_factory *f);
104 static pj_status_t factory_get_dev_info(pjmedia_aud_dev_factory *f,
105 unsigned index,
106 pjmedia_aud_dev_info *info);
107 static pj_status_t factory_default_param(pjmedia_aud_dev_factory *f,
108 unsigned index,
109 pjmedia_aud_param *param);
110 static pj_status_t factory_create_stream(pjmedia_aud_dev_factory *f,
111 const pjmedia_aud_param *param,
112 pjmedia_aud_rec_cb rec_cb,
113 pjmedia_aud_play_cb play_cb,
114 void *user_data,
115 pjmedia_aud_stream **p_aud_strm);
116
117 /* Stream prototypes */
118 static pj_status_t stream_get_param(pjmedia_aud_stream *strm,
119 pjmedia_aud_param *param);
120 static pj_status_t stream_get_cap(pjmedia_aud_stream *strm,
121 pjmedia_aud_dev_cap cap,
122 void *value);
123 static pj_status_t stream_set_cap(pjmedia_aud_stream *strm,
124 pjmedia_aud_dev_cap cap,
125 const void *value);
126 static pj_status_t stream_start(pjmedia_aud_stream *strm);
127 static pj_status_t stream_stop(pjmedia_aud_stream *strm);
128 static pj_status_t stream_destroy(pjmedia_aud_stream *strm);
129
130 static pjmedia_aud_dev_factory_op tapi_fact_op =
131 {
132 &factory_init,
133 &factory_destroy,
134 &factory_get_dev_count,
135 &factory_get_dev_info,
136 &factory_default_param,
137 &factory_create_stream
138 };
139
140 static pjmedia_aud_stream_op tapi_strm_op =
141 {
142 &stream_get_param,
143 &stream_get_cap,
144 &stream_set_cap,
145 &stream_start,
146 &stream_stop,
147 &stream_destroy
148 };
149
150 void (*tapi_digit_callback)(unsigned int port, unsigned char digit) = NULL;
151 void (*tapi_hook_callback)(unsigned int port, unsigned char event) = NULL;
152
153 static pj_int32_t
154 tapi_dev_open(char* dev_path, const pj_int32_t ch_num)
155 {
156 char devname[128] = {0};
157 pj_ansi_sprintf(devname,"%s%u%u", dev_path, 1, ch_num);
158 return open((const char*)devname, O_RDWR, 0644);
159 }
160
161 static pj_status_t
162 tapi_dev_binary_buffer_create(const char *pPath, pj_uint8_t **ppBuf, pj_uint32_t *pBufSz)
163 {
164 pj_status_t status = PJ_SUCCESS;
165 FILE *fd;
166 struct stat file_stat;
167
168 fd = fopen(pPath, "rb");
169 if (fd == NULL) {
170 TRACE_((THIS_FILE, "ERROR - binary file %s open failed!\n", pPath));
171 return PJ_EUNKNOWN;
172 }
173
174 if (stat(pPath, &file_stat) != 0) {
175 TRACE_((THIS_FILE, "ERROR - file %s statistics get failed!\n", pPath));
176 return PJ_EUNKNOWN;
177 }
178
179 *ppBuf = malloc(file_stat.st_size);
180 if (*ppBuf == NULL) {
181 TRACE_((THIS_FILE, "ERROR - binary file %s memory allocation failed!\n", pPath));
182 status = PJ_EUNKNOWN;
183 goto on_exit;
184 }
185
186 if (fread (*ppBuf, sizeof(pj_uint8_t), file_stat.st_size, fd) <= 0) {
187 TRACE_((THIS_FILE, "ERROR - file %s read failed!\n", pPath));
188 status = PJ_EUNKNOWN;
189 goto on_exit;
190 }
191
192 *pBufSz = file_stat.st_size;
193
194 on_exit:
195 if (fd != NULL)
196 fclose(fd);
197
198 if (*ppBuf != NULL && status != PJ_SUCCESS)
199 free(*ppBuf);
200
201 return status;
202 }
203
204 static void
205 tapi_dev_binary_buffer_delete(pj_uint8_t *pBuf)
206 {
207 if (pBuf != NULL)
208 free(pBuf);
209 }
210
211 static pj_status_t
212 tapi_dev_firmware_download(pj_int32_t fd, const char *pPath)
213 {
214 pj_status_t status = PJ_SUCCESS;
215 pj_uint8_t *pFirmware = NULL;
216 pj_uint32_t binSz = 0;
217 VMMC_IO_INIT vmmc_io_init;
218
219 status = tapi_dev_binary_buffer_create(pPath, &pFirmware, &binSz);
220 if (status != PJ_SUCCESS) {
221 TRACE_((THIS_FILE, "ERROR - binary buffer create failed!\n"));
222 return PJ_EUNKNOWN;
223 }
224
225 memset(&vmmc_io_init, 0, sizeof(VMMC_IO_INIT));
226 vmmc_io_init.pPRAMfw = pFirmware;
227 vmmc_io_init.pram_size = binSz;
228
229 status = ioctl(fd, FIO_FW_DOWNLOAD, &vmmc_io_init);
230 if (status != PJ_SUCCESS)
231 TRACE_((THIS_FILE, "ERROR - FIO_FW_DOWNLOAD ioctl failed!"));
232
233 tapi_dev_binary_buffer_delete(pFirmware);
234
235 return status;
236 }
237
238 static int
239 tapi_dev_bbd_download(int fd, const char *pPath)
240 {
241 int status = PJ_SUCCESS;
242 unsigned char *pFirmware = NULL;
243 unsigned int binSz = 0;
244 VMMC_DWLD_t bbd_data;
245
246
247 /* Create binary buffer */
248 status = tapi_dev_binary_buffer_create(pPath, &pFirmware, &binSz);
249 if (status != PJ_SUCCESS) {
250 TRACE_((THIS_FILE, "ERROR - binary buffer create failed!\n"));
251 return status;
252 }
253
254 /* Download Voice Firmware */
255 memset(&bbd_data, 0, sizeof(VMMC_DWLD_t));
256 bbd_data.buf = pFirmware;
257 bbd_data.size = binSz;
258
259 status = ioctl(fd, FIO_BBD_DOWNLOAD, &bbd_data);
260 if (status != PJ_SUCCESS) {
261 TRACE_((THIS_FILE, "ERROR - FIO_BBD_DOWNLOAD failed!\n"));
262 }
263
264 /* Delete binary buffer */
265 tapi_dev_binary_buffer_delete(pFirmware);
266
267 return status;
268 }
269
270 static pj_status_t tapi_dev_start(tapi_aud_factory_t *f)
271 {
272 pj_uint8_t c, hook_status;
273 pj_status_t status = PJ_SUCCESS;
274 IFX_TAPI_DEV_START_CFG_t tapistart;
275 IFX_TAPI_MAP_DATA_t datamap;
276 IFX_TAPI_ENC_CFG_t enc_cfg;
277 IFX_TAPI_LINE_VOLUME_t line_vol;
278 IFX_TAPI_CID_CFG_t cid_cnf;
279
280 /* Open device */
281 f->dev_ctx.dev_fd = tapi_dev_open(TAPI_LL_DEV_BASE_PATH, 0);
282
283 if (f->dev_ctx.dev_fd < 0) {
284 TRACE_((THIS_FILE, "ERROR - TAPI device open failed!"));
285 return PJ_EUNKNOWN;
286 }
287
288 for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
289 ch_fd[c] = f->dev_ctx.ch_fd[c] = tapi_dev_open(TAPI_LL_DEV_BASE_PATH, TAPI_AUDIO_PORT_NUM - c);
290
291 if (f->dev_ctx.dev_fd < 0) {
292 TRACE_((THIS_FILE, "ERROR - TAPI channel%d open failed!", c));
293 return PJ_EUNKNOWN;
294 }
295 f->dev_ctx.data2phone_map[c] = c & 0x1 ? 0 : 1;
296 }
297
298 status = tapi_dev_firmware_download(f->dev_ctx.dev_fd, TAPI_LL_DEV_FIRMWARE_NAME);
299 if (status != PJ_SUCCESS) {
300 TRACE_((THIS_FILE, "ERROR - Voice Firmware Download failed!"));
301 return PJ_EUNKNOWN;
302 }
303
304 /* Download coefficients */
305 /*
306 status = tapi_dev_bbd_download(f->dev_ctx.dev_fd, TAPI_LL_BBD_NAME);
307 if (status != PJ_SUCCESS) {
308 TRACE_((THIS_FILE, "ERROR - Voice Coefficients Download failed!"));
309 return PJ_EUNKNOWN;
310 }
311 */
312
313 memset(&tapistart, 0x0, sizeof(IFX_TAPI_DEV_START_CFG_t));
314 tapistart.nMode = IFX_TAPI_INIT_MODE_VOICE_CODER;
315
316 /* Start TAPI */
317 status = ioctl(f->dev_ctx.dev_fd, IFX_TAPI_DEV_START, &tapistart);
318 if (status != PJ_SUCCESS) {
319 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_DEV_START ioctl failed"));
320 return PJ_EUNKNOWN;
321 }
322
323
324 for (c = 0; c < TAPI_AUDIO_PORT_NUM; c++) {
325 /* Perform mapping */
326 memset(&datamap, 0x0, sizeof(IFX_TAPI_MAP_DATA_t));
327 datamap.nDstCh = f->dev_ctx.data2phone_map[c];
328 datamap.nChType = IFX_TAPI_MAP_TYPE_PHONE;
329
330 status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_MAP_DATA_ADD, &datamap);
331
332 if (status != PJ_SUCCESS) {
333 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_MAP_DATA_ADD ioctl failed"));
334 return PJ_EUNKNOWN;
335 }
336
337 /* Set Line feed */
338 status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_LINE_FEED_SET, IFX_TAPI_LINE_FEED_STANDBY);
339
340 if (status != PJ_SUCCESS) {
341 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed"));
342 return PJ_EUNKNOWN;
343 }
344
345 /* Configure encoder for linear stream */
346 memset(&enc_cfg, 0x0, sizeof(IFX_TAPI_ENC_CFG_t));
347
348 enc_cfg.nFrameLen = IFX_TAPI_COD_LENGTH_20;
349 enc_cfg.nEncType = IFX_TAPI_COD_TYPE_LIN16_8;
350
351 status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_ENC_CFG_SET, &enc_cfg);
352 if (status != PJ_SUCCESS) {
353 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_ENC_CFG_SET ioctl failed"));
354 return PJ_EUNKNOWN;
355 }
356
357 /* Suppress TAPI volume, otherwise PJSIP starts autogeneration!!! */
358 line_vol.nGainRx = -8;
359 line_vol.nGainTx = -8;
360
361 status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_PHONE_VOLUME_SET, &line_vol);
362 if (status != PJ_SUCCESS) {
363 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_PHONE_VOLUME_SET ioctl failed"));
364 return PJ_EUNKNOWN;
365 }
366
367 /* Configure Caller ID type */
368 /* One can choose from following (for now at compile time):
369 IFX_TAPI_CID_STD_TELCORDIA
370 IFX_TAPI_CID_STD_ETSI_FSK
371 IFX_TAPI_CID_STD_ETSI_DTMF
372 IFX_TAPI_CID_STD_SIN
373 IFX_TAPI_CID_STD_NTT
374 IFX_TAPI_CID_STD_KPN_DTMF
375 IFX_TAPI_CID_STD_KPN_DTMF_FSK
376 */
377 memset(&cid_cnf, 0, sizeof(cid_cnf));
378 cid_cnf.nStandard = IFX_TAPI_CID_STD_ETSI_FSK;
379 status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_CID_CFG_SET, &cid_cnf);
380 if (status != PJ_SUCCESS) {
381 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_CID_CFG_SET ioctl failed"));
382 return PJ_EUNKNOWN;
383 }
384
385 /* check hook status */
386 hook_status = 0;
387 status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_LINE_HOOK_STATUS_GET, &hook_status);
388 if (status != PJ_SUCCESS) {
389 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_HOOK_STATUS_GET ioctl failed!"));
390 return PJ_EUNKNOWN;
391 }
392
393 /* if off hook do initialization */
394 if (hook_status) {
395 status = ioctl(f->dev_ctx.ch_fd[c], IFX_TAPI_LINE_FEED_SET, IFX_TAPI_LINE_FEED_ACTIVE);
396 if (status != PJ_SUCCESS) {
397 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed!"));
398 return PJ_EUNKNOWN;
399 }
400 status = ioctl(c, IFX_TAPI_ENC_START, 0);
401 if (status != PJ_SUCCESS) {
402 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_ENC_START ioctl failed!"));
403 return PJ_EUNKNOWN;
404 }
405
406 status = ioctl(c, IFX_TAPI_DEC_START, 0);
407 if (status != PJ_SUCCESS) {
408 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_DEC_START ioctl failed!"));
409 return PJ_EUNKNOWN;
410 }
411 }
412 }
413
414 return status;
415 }
416
417 static pj_status_t
418 tapi_dev_stop(tapi_aud_factory_t *f)
419 {
420 pj_status_t status = PJ_SUCCESS;
421 pj_uint8_t c;
422
423 if (ioctl(f->dev_ctx.dev_fd, IFX_TAPI_DEV_STOP, 0) != PJ_SUCCESS) {
424 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_DEV_STOP ioctl failed"));
425 status = PJ_EUNKNOWN;
426 }
427
428 close(f->dev_ctx.dev_fd);
429 for (c = TAPI_AUDIO_PORT_NUM; c > 0; c--)
430 close(f->dev_ctx.ch_fd[TAPI_AUDIO_PORT_NUM-c]);
431
432 return status;
433 }
434
435 static pj_status_t
436 tapi_dev_codec_control(pj_int32_t fd, pj_uint8_t start)
437 {
438 if (ioctl(fd, start ? IFX_TAPI_ENC_START : IFX_TAPI_ENC_STOP, 0) != PJ_SUCCESS) {
439 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_ENC_%s ioctl failed!",
440 start ? "START" : "STOP"));
441 return PJ_EUNKNOWN;
442 }
443
444 if (ioctl(fd, start ? IFX_TAPI_DEC_START : IFX_TAPI_DEC_STOP, 0) != IFX_SUCCESS) {
445 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_DEC_%s ioctl failed!",
446 start ? "START" : "STOP"));
447 return PJ_EUNKNOWN;
448 }
449
450 return PJ_SUCCESS;
451 }
452
453 static pj_status_t tapi_dev_event_on_hook(tapi_ctx *dev_ctx, pj_uint32_t dev_idx)
454 {
455 PJ_LOG(1,(THIS_FILE, "TAPI: ONHOOK"));
456
457 if (ioctl(dev_ctx->ch_fd[dev_idx], IFX_TAPI_LINE_FEED_SET,
458 IFX_TAPI_LINE_FEED_STANDBY) != PJ_SUCCESS) {
459 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed!"));
460
461 return PJ_EUNKNOWN;
462 }
463
464 /* enc/dec stop */
465 if (tapi_dev_codec_control(dev_ctx->ch_fd[dev_idx], 0) != PJ_SUCCESS) {
466 TRACE_((THIS_FILE, "ERROR - codec start failed!"));
467
468 return PJ_EUNKNOWN;
469 }
470
471 return PJ_SUCCESS;
472 }
473
474 static pj_status_t tapi_dev_event_off_hook(tapi_ctx *dev_ctx, pj_uint32_t dev_idx)
475 {
476 PJ_LOG(1,(THIS_FILE, "TAPI: OFFHOOK"));
477
478 if (ioctl(dev_ctx->ch_fd[dev_idx], IFX_TAPI_LINE_FEED_SET,
479 IFX_TAPI_LINE_FEED_ACTIVE) != PJ_SUCCESS) {
480 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed!"));
481
482 return PJ_EUNKNOWN;
483 }
484
485 /* enc/dec stop */
486 if (tapi_dev_codec_control(dev_ctx->ch_fd[dev_idx], 1) != PJ_SUCCESS) {
487 TRACE_((THIS_FILE, "ERROR - codec start failed!"));
488
489 return PJ_EUNKNOWN;
490 }
491
492 return PJ_SUCCESS;
493 }
494
495 static pj_status_t
496 tapi_dev_event_digit(tapi_ctx *dev_ctx, pj_uint32_t dev_idx)
497 {
498 PJ_LOG(1,(THIS_FILE, "TAPI: OFFHOOK"));
499
500 if (ioctl(dev_ctx->ch_fd[dev_idx], IFX_TAPI_LINE_FEED_SET,
501 IFX_TAPI_LINE_FEED_ACTIVE) != PJ_SUCCESS) {
502 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_FEED_SET ioctl failed!"));
503 return PJ_EUNKNOWN;
504 }
505
506 /* enc/dec stop */
507 if (tapi_dev_codec_control(dev_ctx->ch_fd[dev_idx], 1) != PJ_SUCCESS) {
508 TRACE_((THIS_FILE, "ERROR - codec start failed!"));
509 return PJ_EUNKNOWN;
510 }
511
512 return PJ_SUCCESS;
513 }
514
515 static pj_status_t
516 tapi_dev_event_handler(tapi_aud_stream_t *stream)
517 {
518 IFX_TAPI_EVENT_t tapiEvent;
519 tapi_ctx *dev_ctx = stream->dev_ctx;
520 pj_status_t status = PJ_SUCCESS;
521 unsigned int i;
522
523 for (i = 0; i < TAPI_AUDIO_PORT_NUM; i++) {
524 memset (&tapiEvent, 0, sizeof(tapiEvent));
525 tapiEvent.ch = dev_ctx->data2phone_map[i];
526 status = ioctl(dev_ctx->dev_fd, IFX_TAPI_EVENT_GET, &tapiEvent);
527
528 if ((status == PJ_SUCCESS) && (tapiEvent.id != IFX_TAPI_EVENT_NONE)) {
529 switch(tapiEvent.id) {
530 case IFX_TAPI_EVENT_FXS_ONHOOK:
531 status = tapi_dev_event_on_hook(dev_ctx, i);
532 if(tapi_hook_callback)
533 tapi_hook_callback(i, 0);
534 break;
535 case IFX_TAPI_EVENT_FXS_OFFHOOK:
536 status = tapi_dev_event_off_hook(dev_ctx, i);
537 if(tapi_hook_callback)
538 tapi_hook_callback(i, 1);
539 break;
540 case IFX_TAPI_EVENT_DTMF_DIGIT:
541 if(tapi_digit_callback)
542 tapi_digit_callback(i, tapiEvent.data.dtmf.ascii);
543 break;
544 case IFX_TAPI_EVENT_COD_DEC_CHG:
545 case IFX_TAPI_EVENT_TONE_GEN_END:
546 case IFX_TAPI_EVENT_CID_TX_SEQ_END:
547 break;
548 default:
549 PJ_LOG(1,(THIS_FILE, "unknown tapi event %08X", tapiEvent.id));
550 break;
551 }
552 }
553 }
554
555 return status;
556 }
557
558 static pj_status_t
559 tapi_dev_data_handler(tapi_aud_stream_t *stream) {
560 pj_status_t status = PJ_SUCCESS;
561 tapi_ctx *dev_ctx = stream->dev_ctx;
562 pj_uint32_t dev_idx = stream->param.rec_id;
563 pj_uint8_t buf_rec[TAPI_LL_DEV_ENC_BYTES_PER_FRAME + TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE]={0};
564 pj_uint8_t buf_play[TAPI_LL_DEV_ENC_BYTES_PER_FRAME + TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE]={0};
565 pjmedia_frame frame_rec, frame_play;
566 pj_int32_t ret;
567
568 /* Get data from driver */
569 ret = read(dev_ctx->ch_fd[dev_idx], buf_rec, sizeof(buf_rec));
570 if (ret < 0) {
571 TRACE_((THIS_FILE, "ERROR - no data available from device!"));
572
573 return PJ_EUNKNOWN;
574 }
575
576 if (ret > 0) {
577 frame_rec.type = PJMEDIA_FRAME_TYPE_AUDIO;
578 frame_rec.buf = buf_rec + TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE;
579 frame_rec.size = ret - TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE;
580 frame_rec.timestamp.u64 = stream->timestamp.u64;
581
582 status = stream->rec_cb(stream->user_data, &frame_rec);
583 if (status != PJ_SUCCESS)
584 {
585 PJ_LOG(1, (THIS_FILE, "rec_cb() failed %d", status));
586 }
587
588 frame_play.type = PJMEDIA_FRAME_TYPE_AUDIO;
589 frame_play.buf = buf_play + TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE;
590 frame_play.size = TAPI_LL_DEV_ENC_BYTES_PER_FRAME;
591 frame_play.timestamp.u64 = stream->timestamp.u64;
592
593 status = (*stream->play_cb)(stream->user_data, &frame_play);
594 if (status != PJ_SUCCESS)
595 {
596 PJ_LOG(1, (THIS_FILE, "play_cb() failed %d", status));
597 }
598 else
599 {
600 memcpy(buf_play, buf_rec, TAPI_LL_DEV_RTP_HEADER_SIZE_BYTE);
601
602 ret = write(dev_ctx->ch_fd[dev_idx], buf_play, sizeof(buf_play));
603
604 if (ret < 0) {
605 PJ_LOG(1, (THIS_FILE, "ERROR - device data writing failed!"));
606 return PJ_EUNKNOWN;
607 }
608
609 if (ret == 0) {
610 PJ_LOG(1, (THIS_FILE, "ERROR - no data written to device!"));
611 return PJ_EUNKNOWN;
612 }
613 }
614
615 stream->timestamp.u64 += TAPI_LL_DEV_ENC_SMPL_PER_FRAME;
616 }
617
618 return PJ_SUCCESS;
619 }
620
621 static int
622 PJ_THREAD_FUNC tapi_dev_thread(void *arg) {
623 tapi_aud_stream_t *strm = (struct tapi_aud_stream*)arg;
624 tapi_ctx *dev_ctx = strm->dev_ctx;
625 pj_uint32_t sretval;
626 pj_uint32_t dev_idx;
627 struct pollfd fds[3];
628
629 PJ_LOG(1,(THIS_FILE, "TAPI: thread starting..."));
630
631 if (strm->param.rec_id != strm->param.play_id) {
632 PJ_LOG(1,(THIS_FILE, "TAPI: thread exit - incorrect play/rec IDs"));
633 return 0;
634 }
635
636 dev_idx = strm->param.rec_id;
637 strm->run_flag = 1;
638
639 fds[0].fd = dev_ctx->dev_fd;
640 fds[0].events = POLLIN;
641 fds[1].fd = dev_ctx->ch_fd[0];
642 fds[1].events = POLLIN;
643 fds[2].fd = dev_ctx->ch_fd[1];
644 fds[2].events = POLLIN;
645
646 while(1)
647 {
648 sretval = poll(fds, TAPI_AUDIO_PORT_NUM + 1, TAPI_LL_DEV_SELECT_TIMEOUT_MS);
649
650 if (!strm->run_flag)
651 break;
652 if (sretval <= 0)
653 continue;
654
655 if (fds[0].revents == POLLIN) {
656 if (tapi_dev_event_handler(strm) != PJ_SUCCESS) {
657 PJ_LOG(1,(THIS_FILE, "TAPI: event hanldler failed!"));
658 break;
659 }
660 }
661
662 if (fds[1].revents == POLLIN) {
663 if (tapi_dev_data_handler(strm) != PJ_SUCCESS) {
664 PJ_LOG(1,(THIS_FILE, "TAPI: data hanldler failed!"));
665 break;
666 }
667 }
668
669 if (fds[2].revents == POLLIN) {
670 if (tapi_dev_data_handler(strm) != PJ_SUCCESS) {
671 PJ_LOG(1,(THIS_FILE, "TAPI: data hanldler failed!"));
672 break;
673 }
674 }
675 }
676 PJ_LOG(1,(THIS_FILE, "TAPI: thread stopping..."));
677
678 return 0;
679 }
680
681 /****************************************************************************
682 Factory operations
683 ****************************************************************************/
684
685 pjmedia_aud_dev_factory*
686 pjmedia_tapi_factory(pj_pool_factory *pf) {
687 struct tapi_aud_factory *f;
688 pj_pool_t *pool;
689
690 TRACE_((THIS_FILE, "pjmedia_tapi_factory()"));
691
692 pool = pj_pool_create(pf, "tapi", 512, 512, NULL);
693 f = PJ_POOL_ZALLOC_T(pool, struct tapi_aud_factory);
694 f->pf = pf;
695 f->pool = pool;
696 f->base.op = &tapi_fact_op;
697
698 return &f->base;
699 }
700
701 static pj_status_t
702 factory_init(pjmedia_aud_dev_factory *f)
703 {
704 struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
705 pj_uint8_t c;
706
707 TRACE_((THIS_FILE, "factory_init()"));
708
709 af->dev_count = 1;
710 af->dev_info = (pjmedia_aud_dev_info*)
711 pj_pool_calloc(af->pool, af->dev_count, sizeof(pjmedia_aud_dev_info));
712 pj_ansi_sprintf(af->dev_info[0].name,"%s_%02d", TAPI_BASE_NAME, c);
713 af->dev_info[0].input_count = af->dev_info[0].output_count = TAPI_AUDIO_PORT_NUM;
714 af->dev_info[0].default_samples_per_sec = TAPI_LL_DEV_ENC_SMPL_PER_SEC;
715 pj_ansi_strcpy(af->dev_info[0].driver, "/dev/vmmc");
716 af->dev_info[0].caps = PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING |
717 PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY |
718 PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY;
719 af->dev_info[0].routes = PJMEDIA_AUD_DEV_ROUTE_DEFAULT ;
720 if (tapi_dev_start(af) != PJ_SUCCESS) {
721 TRACE_((THIS_FILE, "ERROR - TAPI device init failed!"));
722 return PJ_EUNKNOWN;
723 }
724
725 return PJ_SUCCESS;
726 }
727
728 static pj_status_t
729 factory_destroy(pjmedia_aud_dev_factory *f)
730 {
731 struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
732 pj_pool_t *pool;
733 pj_status_t status = PJ_SUCCESS;
734
735 TRACE_((THIS_FILE, "factory_destroy()"));
736
737 if (tapi_dev_stop(f) != PJ_SUCCESS) {
738 TRACE_((THIS_FILE, "ERROR - TAPI device stop failed!"));
739 status = PJ_EUNKNOWN;
740 }
741 pool = af->pool;
742 af->pool = NULL;
743 pj_pool_release(pool);
744
745 return status;
746 }
747
748 static unsigned
749 factory_get_dev_count(pjmedia_aud_dev_factory *f)
750 {
751 struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
752 TRACE_((THIS_FILE, "factory_get_dev_count()"));
753
754 return af->dev_count;
755 }
756
757 static pj_status_t
758 factory_get_dev_info(pjmedia_aud_dev_factory *f, unsigned index, pjmedia_aud_dev_info *info)
759 {
760 struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
761
762 TRACE_((THIS_FILE, "factory_get_dev_info()"));
763 PJ_ASSERT_RETURN(index < af->dev_count, PJMEDIA_EAUD_INVDEV);
764
765 pj_memcpy(info, &af->dev_info[index], sizeof(*info));
766
767 return PJ_SUCCESS;
768 }
769
770 static pj_status_t
771 factory_default_param(pjmedia_aud_dev_factory *f, unsigned index, pjmedia_aud_param *param)
772 {
773 struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
774 struct pjmedia_aud_dev_info *di = &af->dev_info[index];
775
776 TRACE_((THIS_FILE, "factory_default_param."));
777 PJ_ASSERT_RETURN(index < af->dev_count, PJMEDIA_EAUD_INVDEV);
778
779 pj_bzero(param, sizeof(*param));
780 if (di->input_count && di->output_count) {
781 param->dir = PJMEDIA_DIR_CAPTURE_PLAYBACK;
782 param->rec_id = index;
783 param->play_id = index;
784 } else if (di->input_count) {
785 param->dir = PJMEDIA_DIR_CAPTURE;
786 param->rec_id = index;
787 param->play_id = PJMEDIA_AUD_INVALID_DEV;
788 } else if (di->output_count) {
789 param->dir = PJMEDIA_DIR_PLAYBACK;
790 param->play_id = index;
791 param->rec_id = PJMEDIA_AUD_INVALID_DEV;
792 } else {
793 return PJMEDIA_EAUD_INVDEV;
794 }
795
796 param->clock_rate = TAPI_LL_DEV_ENC_SMPL_PER_SEC; //di->default_samples_per_sec;
797 param->channel_count = 1;
798 param->samples_per_frame = TAPI_LL_DEV_ENC_SMPL_PER_FRAME;
799 param->bits_per_sample = TAPI_LL_DEV_ENC_BITS_PER_SMPLS;
800 param->flags = PJMEDIA_AUD_DEV_CAP_OUTPUT_ROUTE | di->caps;
801 param->output_route = PJMEDIA_AUD_DEV_ROUTE_DEFAULT;
802
803 return PJ_SUCCESS;
804 }
805
806 static pj_status_t
807 factory_create_stream(pjmedia_aud_dev_factory *f, const pjmedia_aud_param *param,
808 pjmedia_aud_rec_cb rec_cb, pjmedia_aud_play_cb play_cb,
809 void *user_data, pjmedia_aud_stream **p_aud_strm)
810 {
811 struct tapi_aud_factory *af = (struct tapi_aud_factory*)f;
812 pj_pool_t *pool;
813 struct tapi_aud_stream *strm;
814 pj_status_t status;
815
816 TRACE_((THIS_FILE, "factory_create_stream()"));
817
818 /* Can only support 16bits per sample */
819 PJ_ASSERT_RETURN(param->bits_per_sample == TAPI_LL_DEV_ENC_BITS_PER_SMPLS, PJ_EINVAL);
820 printf("param->clock_rate = %d, samples_per_frame = %d\n", param->clock_rate, param->samples_per_frame);
821 PJ_ASSERT_RETURN(param->clock_rate == TAPI_LL_DEV_ENC_SMPL_PER_SEC, PJ_EINVAL);
822
823 PJ_ASSERT_RETURN(param->samples_per_frame == TAPI_LL_DEV_ENC_SMPL_PER_FRAME, PJ_EINVAL);
824
825 /* Can only support bidirectional stream */
826 PJ_ASSERT_RETURN(param->dir & PJMEDIA_DIR_CAPTURE_PLAYBACK, PJ_EINVAL);
827
828 /* Initialize our stream data */
829 pool = pj_pool_create(af->pf, "tapi-dev", 1000, 1000, NULL);
830 PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
831
832 strm = PJ_POOL_ZALLOC_T(pool, struct tapi_aud_stream);
833 strm->pool = pool;
834 strm->rec_cb = rec_cb;
835 strm->play_cb = play_cb;
836 strm->user_data = user_data;
837 pj_memcpy(&strm->param, param, sizeof(*param));
838
839 if ((strm->param.flags & PJMEDIA_AUD_DEV_CAP_EXT_FORMAT) == 0) {
840 strm->param.ext_fmt.id = PJMEDIA_FORMAT_L16;
841 }
842
843 strm->timestamp.u64 = 0;
844 strm->dev_ctx = &(af->dev_ctx);
845
846 /* Create and start the thread */
847 status = pj_thread_create(pool, "tapi", &tapi_dev_thread, strm, 0, 0,
848 &strm->thread);
849 if (status != PJ_SUCCESS) {
850 stream_destroy(&strm->base);
851 return status;
852 }
853
854 /* Done */
855 strm->base.op = &tapi_strm_op;
856 *p_aud_strm = &strm->base;
857
858 return PJ_SUCCESS;
859 }
860
861 static pj_status_t
862 stream_get_param(pjmedia_aud_stream *s, pjmedia_aud_param *pi)
863 {
864 struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
865
866 PJ_ASSERT_RETURN(strm && pi, PJ_EINVAL);
867 pj_memcpy(pi, &strm->param, sizeof(*pi));
868
869 if (stream_get_cap(s, PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING,
870 &pi->output_vol) == PJ_SUCCESS)
871 pi->flags |= PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING;
872
873 if (stream_get_cap(s, PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY,
874 &pi->output_latency_ms) == PJ_SUCCESS)
875 pi->flags |= PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY;
876
877 if (stream_get_cap(s, PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY,
878 &pi->input_latency_ms) == PJ_SUCCESS)
879 pi->flags |= PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY;
880
881 return PJ_SUCCESS;
882 }
883
884 static pj_status_t
885 stream_get_cap(pjmedia_aud_stream *s, pjmedia_aud_dev_cap cap, void *pval)
886 {
887 // struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
888 return PJ_SUCCESS;
889 }
890
891 static pj_status_t
892 stream_set_cap(pjmedia_aud_stream *s, pjmedia_aud_dev_cap cap, const void *pval)
893 {
894 // struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
895 return PJ_SUCCESS;
896 }
897
898 static pj_status_t
899 stream_start(pjmedia_aud_stream *s)
900 {
901 struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
902 tapi_ctx *dev_ctx = strm->dev_ctx;
903 pj_uint32_t dev_idx;
904
905 TRACE_((THIS_FILE, "stream_start()"));
906
907 dev_idx = strm->param.rec_id;
908
909 return PJ_SUCCESS;
910 }
911
912 static pj_status_t
913 stream_stop(pjmedia_aud_stream *s)
914 {
915 struct tapi_aud_stream *strm = (struct tapi_aud_stream*)s;
916 tapi_ctx *dev_ctx = strm->dev_ctx;
917 pj_uint32_t dev_idx;
918
919 TRACE_((THIS_FILE, "stream_stop()"));
920 dev_idx = strm->param.rec_id;
921
922 if (tapi_dev_codec_control(dev_ctx->ch_fd[dev_idx], 0) != PJ_SUCCESS) {
923 TRACE_((THIS_FILE, "ERROR - codec start failed!"));
924 return PJ_EUNKNOWN;
925 }
926
927 return PJ_SUCCESS;
928 }
929
930 static pj_status_t
931 stream_destroy(pjmedia_aud_stream *s)
932 {
933 pj_status_t state = PJ_SUCCESS;
934 struct tapi_aud_stream *stream = (struct tapi_aud_stream*)s;
935 pj_pool_t *pool;
936
937 PJ_ASSERT_RETURN(stream != NULL, PJ_EINVAL);
938 TRACE_((THIS_FILE, "stream_destroy()"));
939
940 stream_stop(stream);
941 stream->run_flag = 0;
942
943 if (stream->thread)
944 {
945 pj_thread_join(stream->thread);
946 pj_thread_destroy(stream->thread);
947 stream->thread = NULL;
948 }
949
950 pool = stream->pool;
951 pj_bzero(stream, sizeof(stream));
952 pj_pool_release(pool);
953
954 return state;
955 }
956
957 pj_status_t
958 tapi_hook_status(pj_uint32_t port, pj_uint32_t *status)
959 {
960 if (ioctl(ch_fd[port], IFX_TAPI_LINE_HOOK_STATUS_GET, status)
961 != PJ_SUCCESS) {
962 TRACE_((THIS_FILE, "ERROR - IFX_TAPI_LINE_HOOK_STATUS_GET ioctl failed!"));
963 return PJ_EUNKNOWN;
964 }
965
966 return PJ_SUCCESS;
967 }
968
969 pj_status_t
970 tapi_ring(pj_uint32_t port, pj_uint32_t state, char *caller_number) {
971 PJ_ASSERT_RETURN(port < TAPI_AUDIO_PORT_NUM, PJ_EINVAL);
972
973 if (state) {
974 if (caller_number) {
975 IFX_TAPI_CID_MSG_t cid_msg;
976 IFX_TAPI_CID_MSG_ELEMENT_t cid_msg_el[1];
977 memset(&cid_msg, 0, sizeof(cid_msg));
978 memset(&cid_msg_el, 0, sizeof(cid_msg_el));
979
980 cid_msg_el[0].string.elementType = IFX_TAPI_CID_ST_CLI;
981 cid_msg_el[0].string.len = strlen(caller_number);
982 strncpy(cid_msg_el[0].string.element, caller_number, sizeof(cid_msg_el[0].string.element));
983
984 cid_msg.txMode = IFX_TAPI_CID_HM_ONHOOK;
985 cid_msg.messageType = IFX_TAPI_CID_MT_CSUP;
986 cid_msg.nMsgElements = 1;
987 cid_msg.message = cid_msg_el;
988 ioctl(ch_fd[port], IFX_TAPI_CID_TX_SEQ_START, &cid_msg);
989 } else {
990 ioctl(ch_fd[port], IFX_TAPI_RING_START, 0);
991 }
992 } else {
993 ioctl(ch_fd[port], IFX_TAPI_RING_STOP, 0);
994 }
995
996 return PJ_SUCCESS;
997 }
998
999 pj_status_t
1000 tapi_dial_tone(pj_uint32_t port) {
1001 PJ_ASSERT_RETURN(port < TAPI_AUDIO_PORT_NUM, PJ_EINVAL);
1002
1003 ioctl(ch_fd[port], IFX_TAPI_TONE_DIALTONE_PLAY, 0);
1004
1005 return PJ_SUCCESS;
1006 }
1007
1008 pj_status_t
1009 tapi_no_tone(pj_uint32_t port) {
1010 PJ_ASSERT_RETURN(port < TAPI_AUDIO_PORT_NUM, PJ_EINVAL);
1011
1012 ioctl(ch_fd[port], IFX_TAPI_TONE_LOCAL_PLAY, 0);
1013
1014 return PJ_SUCCESS;
1015 }
1016
1017 #endif
Personal OpenWRT clone
This page took 0.095848 seconds and 3 git commands to generate.