plugins/LID/VPB/vpb.cpp

   1 /*
   2  * Voicetronix VPB Plugin LID for OPAL
   3  *
   4  * Copyright (C) 2006 Post Increment, All Rights Reserved
   5  *
   6  * The contents of this file are subject to the Mozilla Public License
   7  * Version 1.0 (the "License"); you may not use this file except in
   8  * compliance with the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS"
  12  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  13  * the License for the specific language governing rights and limitations
  14  * under the License.
  15  *
  16  * The Original Code is OPAL.
  17  *
  18  * The Initial Developer of the Original Code is Post Increment
  19  *
  20  * Contributor(s): ______________________________________.
  21  *
  22  * $Log$
  23  * Revision 1.2  2006/10/04 04:21:16  rjongbloed
  24  * Fixed VPB plug in build under linux
  25  *
  26  * Revision 1.1  2006/10/02 13:30:53  rjongbloed
  27  * Added LID plug ins
  28  *
  29  */
  30
  31 #define PLUGIN_DLL_EXPORTS
  32 #include <lids/lidplugin.h>
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <iostream>
  37 #include <fstream>
  38
  39 #include "vpbapi.h"
  40
  41 #if defined(_MSC_VER)
  42 #pragma comment(lib, "libvpb.lib")
  43 #endif
  44
  45
  46 static const struct {
  47   const char *   mediaFormat;
  48   unsigned short mode;
  49 } CodecInfo[] = {
  50   { "PCM-16",         VPB_LINEAR },
  51   { "G.711-uLaw-64k", VPB_MULAW },
  52   { "G.711-ALaw-64k", VPB_ALAW  },
  53 };
  54
  55
  56 class Context
  57 {
  58   protected:
  59     unsigned m_uiLineCount;
  60     enum { MaxLineCount = 12 };
  61
  62     struct LineState
  63     {
  64       PluginLID_Boolean Open(unsigned cardNumber, unsigned lineNumber)
  65       {
  66         /* +1 is used for driver 2.4.8*/
  67         handle = vpb_open(cardNumber, lineNumber);
  68         if (handle < 0)
  69           return FALSE;
  70         readFrameSize = writeFrameSize = 480;
  71         currentHookState = FALSE;
  72         vpb_sethook_sync(handle, VPB_ONHOOK);
  73         vpb_set_event_mask(handle, VPB_MRING | VPB_MTONEDETECT );
  74         return TRUE;
  75       }
  76
  77       PluginLID_Boolean SetLineOffHook(PluginLID_Boolean newState)
  78       {
  79         try {
  80           if (vpb_sethook_sync(handle, newState ? VPB_OFFHOOK : VPB_ONHOOK) < 0)
  81             return FALSE;
  82
  83           // clear DTMF buffer and event queue after changing hook state.
  84           vpb_flush_digits(handle);
  85
  86           VPB_EVENT event;
  87           while (vpb_get_event_ch_async(handle, &event) == VPB_OK)
  88           {
  89           }
  90         }
  91         catch (VpbException v) {
  92           std::cerr << "VPB\tSetLineOffHook " << v.code << ", s = " << v.s << ", api func = " << v.api_function << std::endl;
  93           return FALSE;
  94         }
  95
  96         currentHookState = newState;
  97         return TRUE;
  98       }
  99
 100       int               handle;
 101       PluginLID_Boolean currentHookState;
 102       const char *      readFormat;
 103       const char *      writeFormat;
 104       size_t            readFrameSize, writeFrameSize;
 105     } lineState[MaxLineCount];
 106
 107   public:
 108     PLUGIN_LID_CTOR()
 109     {
 110       m_uiLineCount = 0;
 111       memset(lineState, 0, sizeof(lineState));
 112     }
 113
 114     PLUGIN_LID_DTOR()
 115     {
 116       Close();
 117     }
 118
 119
 120     PLUGIN_FUNCTION_ARG3(GetDeviceName,unsigned,index, char *,name, unsigned,size)
 121     {
 122       if (name == NULL || size < 2)
 123         return PluginLID_InvalidParameter;
 124
 125       try {
 126         int iHandle = vpb_open(index, 1 /* 0 for driver 3.01*/);
 127         if (iHandle >= 0) {
 128           int lineCount = vpb_get_ports_per_card(/*getCardNumber()*/);
 129           vpb_close(iHandle);
 130           if (lineCount > 0) {
 131             snprintf(name, size, "%u", index);
 132             return PluginLID_NoError;
 133           }
 134         }
 135       }
 136       catch (VpbException v) {
 137         std::cerr << "VPB\tOpalVpbDevice::GetLineCount Error code = "  << v.code << ", s = " << v.s << " api func = " << v.api_function << std::endl;
 138       }
 139       return PluginLID_NoMoreNames;
 140     }
 141
 142
 143     PLUGIN_FUNCTION_ARG1(Open,const char *,device)
 144     {
 145       Close();
 146
 147       int cardNumber = atoi(device);
 148       int iHandle = vpb_open(cardNumber, /* 0 for driver 3.01*/1);
 149       /* get the number of ports for this card */
 150       m_uiLineCount = vpb_get_ports_per_card(/*cardNumber*/);
 151       vpb_close(iHandle);
 152
 153       if (m_uiLineCount == 0)
 154         return PluginLID_NoSuchDevice;
 155
 156       try {
 157         for(unsigned uiLineCount = 0; uiLineCount < m_uiLineCount; uiLineCount++)
 158           lineState[uiLineCount].Open(cardNumber, uiLineCount);
 159       }
 160       catch (VpbException v) {
 161         std::cerr << "VPB\tOpalVpbDevice::Open Error code = "  << v.code << ", s = " << v.s << " api func = " << v.api_function << std::endl;
 162         m_uiLineCount = 0;
 163         return PluginLID_DeviceOpenFailed;
 164       }
 165
 166       return PluginLID_NoError;
 167     }
 168
 169
 170     PLUGIN_FUNCTION_ARG0(Close)
 171     {
 172       if (m_uiLineCount == 0)
 173         return PluginLID_NoError;
 174
 175       try {
 176         for(unsigned uiLineCount = 0; uiLineCount < m_uiLineCount; uiLineCount++) {
 177           SetLineOffHook(uiLineCount, FALSE);
 178           vpb_close(lineState[uiLineCount].handle);
 179         }
 180       }
 181       catch (VpbException v) {
 182         std::cerr << "VPB\tOpalVpbDevice::Close Error code = " << v.code << ", s = " << v.s << ", api func = " << v.api_function << std::endl;
 183       }
 184
 185       m_uiLineCount = 0;
 186       return PluginLID_NoError;
 187     }
 188
 189
 190     PLUGIN_FUNCTION_ARG1(GetLineCount, unsigned *,count)
 191     {
 192       if (count == NULL)
 193         return PluginLID_InvalidParameter;
 194
 195       if (m_uiLineCount == 0)
 196         return PluginLID_DeviceNotOpen;
 197
 198       *count = m_uiLineCount;
 199       return PluginLID_NoError;
 200     }
 201
 202
 203     PLUGIN_FUNCTION_ARG2(IsLineTerminal, unsigned,line, PluginLID_Boolean *,isTerminal)
 204     {
 205       if (isTerminal == NULL)
 206         return PluginLID_InvalidParameter;
 207
 208       if (m_uiLineCount == 0)
 209         return PluginLID_DeviceNotOpen;
 210
 211       if (line >= m_uiLineCount)
 212         return PluginLID_NoSuchLine;
 213
 214       *isTerminal = FALSE;
 215       return PluginLID_NoError;
 216     }
 217
 218
 219     PLUGIN_FUNCTION_ARG3(IsLinePresent, unsigned,line, PluginLID_Boolean,forceTest, PluginLID_Boolean *,present)
 220     {
 221       if (present == NULL)
 222         return PluginLID_InvalidParameter;
 223
 224       if (m_uiLineCount == 0)
 225         return PluginLID_DeviceNotOpen;
 226
 227       if (line >= m_uiLineCount)
 228         return PluginLID_NoSuchLine;
 229
 230       *present = TRUE;
 231       return PluginLID_NoError;
 232     }
 233
 234
 235     PLUGIN_FUNCTION_ARG2(IsLineOffHook, unsigned,line, PluginLID_Boolean *,offHook)
 236     {
 237       if (offHook == NULL)
 238         return PluginLID_InvalidParameter;
 239
 240       if (m_uiLineCount == 0)
 241         return PluginLID_DeviceNotOpen;
 242
 243       if (line >= m_uiLineCount)
 244         return PluginLID_NoSuchLine;
 245
 246       *offHook = lineState[line].currentHookState;
 247       return PluginLID_NoError;
 248     }
 249
 250
 251     PLUGIN_FUNCTION_ARG2(SetLineOffHook, unsigned,line, PluginLID_Boolean,newState)
 252     {
 253       if (m_uiLineCount == 0)
 254         return PluginLID_DeviceNotOpen;
 255
 256       if (line >= m_uiLineCount)
 257         return PluginLID_NoSuchLine;
 258
 259       return lineState[line].SetLineOffHook(newState) ? PluginLID_NoError : PluginLID_InternalError;
 260     }
 261
 262
 263     //PLUGIN_FUNCTION_ARG2(HookFlash, unsigned,line, unsigned,flashTime)
 264     //PLUGIN_FUNCTION_ARG2(HasHookFlash, unsigned,line, PluginLID_Boolean *,flashed)
 265
 266     PLUGIN_FUNCTION_ARG2(IsLineRinging, unsigned,line, unsigned long *,cadence)
 267     {
 268       if (cadence == NULL)
 269         return PluginLID_InvalidParameter;
 270
 271       if (m_uiLineCount == 0)
 272         return PluginLID_DeviceNotOpen;
 273
 274       if (line >= m_uiLineCount)
 275         return PluginLID_NoSuchLine;
 276
 277       *cadence = 0; // Not ringing
 278
 279       if (!lineState[line].currentHookState) {
 280         // DR 13/1/02 - Dont look at event queue here if off hook, as we will steal events
 281         // that IsToneDetected may be looking for.
 282         VPB_EVENT event;
 283         if (vpb_get_event_ch_async(lineState[line].handle, &event) == VPB_OK && event.type == VPB_RING)
 284           *cadence = 1;
 285       }
 286       return PluginLID_NoError;
 287     }
 288
 289     //PLUGIN_FUNCTION_ARG3(RingLine, unsigned,line, unsigned,nCadence, unsigned *,pattern)
 290     //PLUGIN_FUNCTION_ARG3(IsLineConnected, unsigned,line, PluginLID_Boolean,checkForWink, PluginLID_Boolean *,connected)
 291     //PLUGIN_FUNCTION_ARG3(SetLineToLineDirect, unsigned,line1, unsigned,line2, PluginLID_Boolean,connect)
 292     //PLUGIN_FUNCTION_ARG3(IsLineToLineDirect, unsigned,line1, unsigned,line2, PluginLID_Boolean *,connected)
 293
 294
 295     PLUGIN_FUNCTION_ARG3(GetSupportedFormat, unsigned,index, char *,mediaFormat, unsigned,size)
 296     {
 297       if (mediaFormat == NULL || size < 2)
 298         return PluginLID_InvalidParameter;
 299
 300       if (index >= sizeof(CodecInfo)/sizeof(CodecInfo))
 301         return PluginLID_NoMoreNames;
 302
 303       strncpy(mediaFormat, CodecInfo[index].mediaFormat, size-1);
 304       mediaFormat[size-1] = '\0';
 305       return PluginLID_NoError;
 306     }
 307
 308
 309     PLUGIN_FUNCTION_ARG2(SetReadFormat, unsigned,line, const char *,mediaFormat)
 310     {
 311       if (mediaFormat == NULL)
 312         return PluginLID_InvalidParameter;
 313
 314       if (m_uiLineCount == 0)
 315         return PluginLID_DeviceNotOpen;
 316
 317       if (line >= m_uiLineCount)
 318         return PluginLID_NoSuchLine;
 319
 320       for (int i = 0; i < sizeof(CodecInfo)/sizeof(CodecInfo); i++) {
 321         if (strcmp(mediaFormat, CodecInfo[i].mediaFormat) == 0) {
 322           if (vpb_record_buf_start(lineState[line].handle, CodecInfo[i].mode) < 0)
 323             return PluginLID_InternalError;
 324           lineState[line].readFormat = CodecInfo[i].mediaFormat;
 325           return PluginLID_NoError;
 326         }
 327       }
 328
 329       return PluginLID_UnsupportedMediaFormat;
 330     }
 331
 332
 333     PLUGIN_FUNCTION_ARG2(SetWriteFormat, unsigned,line, const char *,mediaFormat)
 334     {
 335       if (mediaFormat == NULL)
 336         return PluginLID_InvalidParameter;
 337
 338       if (m_uiLineCount == 0)
 339         return PluginLID_DeviceNotOpen;
 340
 341       if (line >= m_uiLineCount)
 342         return PluginLID_NoSuchLine;
 343
 344       for (int i = 0; i < sizeof(CodecInfo)/sizeof(CodecInfo); i++) {
 345         if (strcmp(mediaFormat, CodecInfo[i].mediaFormat) == 0) {
 346           if (vpb_play_buf_start(lineState[line].handle, CodecInfo[i].mode) < 0)
 347             return PluginLID_InternalError;
 348           lineState[line].writeFormat = CodecInfo[i].mediaFormat;
 349           return PluginLID_NoError;
 350         }
 351       }
 352
 353       return PluginLID_UnsupportedMediaFormat;
 354     }
 355
 356
 357     PLUGIN_FUNCTION_ARG3(GetReadFormat, unsigned,line, char *,mediaFormat, unsigned,size)
 358     {
 359       if (mediaFormat == NULL || size == 0)
 360         return PluginLID_InvalidParameter;
 361
 362       if (m_uiLineCount == 0)
 363         return PluginLID_DeviceNotOpen;
 364
 365       if (line >= m_uiLineCount)
 366         return PluginLID_NoSuchLine;
 367
 368       strncpy(mediaFormat, lineState[line].readFormat, size-1);
 369       mediaFormat[size-1] = '\0';
 370       return PluginLID_NoError;
 371     }
 372
 373
 374     PLUGIN_FUNCTION_ARG3(GetWriteFormat, unsigned,line, char *,mediaFormat, unsigned,size)
 375     {
 376       if (mediaFormat == NULL || size == 0)
 377         return PluginLID_InvalidParameter;
 378
 379       if (m_uiLineCount == 0)
 380         return PluginLID_DeviceNotOpen;
 381
 382       if (line >= m_uiLineCount)
 383         return PluginLID_NoSuchLine;
 384
 385       strncpy(mediaFormat, lineState[line].writeFormat, size-1);
 386       mediaFormat[size-1] = '\0';
 387       return PluginLID_NoError;
 388     }
 389
 390
 391     PLUGIN_FUNCTION_ARG1(StopReading, unsigned,line)
 392     {
 393       if (m_uiLineCount == 0)
 394         return PluginLID_DeviceNotOpen;
 395
 396       if (line >= m_uiLineCount)
 397         return PluginLID_NoSuchLine;
 398
 399       vpb_record_terminate(lineState[line].handle);
 400       vpb_record_buf_finish(lineState[line].handle);
 401       return PluginLID_NoError;
 402     }
 403
 404
 405     PLUGIN_FUNCTION_ARG1(StopWriting, unsigned,line)
 406     {
 407       if (m_uiLineCount == 0)
 408         return PluginLID_DeviceNotOpen;
 409
 410       if (line >= m_uiLineCount)
 411         return PluginLID_NoSuchLine;
 412
 413       vpb_play_terminate(lineState[line].handle);
 414       vpb_play_buf_finish(lineState[line].handle);
 415       return PluginLID_NoError;
 416     }
 417
 418
 419     PLUGIN_FUNCTION_ARG2(SetReadFrameSize, unsigned,line, unsigned,frameSize)
 420     {
 421       if (m_uiLineCount == 0)
 422         return PluginLID_DeviceNotOpen;
 423
 424       if (line >= m_uiLineCount)
 425         return PluginLID_NoSuchLine;
 426
 427       lineState[line].readFrameSize = frameSize;
 428       return PluginLID_NoError;
 429     }
 430
 431
 432     PLUGIN_FUNCTION_ARG2(SetWriteFrameSize, unsigned,line, unsigned,frameSize)
 433     {
 434       if (m_uiLineCount == 0)
 435         return PluginLID_DeviceNotOpen;
 436
 437       if (line >= m_uiLineCount)
 438         return PluginLID_NoSuchLine;
 439
 440       lineState[line].writeFrameSize = frameSize;
 441       return PluginLID_NoError;
 442     }
 443
 444
 445     PLUGIN_FUNCTION_ARG2(GetReadFrameSize, unsigned,line, unsigned *,frameSize)
 446     {
 447       if (frameSize == NULL)
 448         return PluginLID_InvalidParameter;
 449
 450       if (m_uiLineCount == 0)
 451         return PluginLID_DeviceNotOpen;
 452
 453       if (line >= m_uiLineCount)
 454         return PluginLID_NoSuchLine;
 455
 456       *frameSize = lineState[line].readFrameSize;
 457       return PluginLID_NoError;
 458     }
 459
 460
 461     PLUGIN_FUNCTION_ARG2(GetWriteFrameSize, unsigned,line, unsigned *,frameSize)
 462     {
 463       if (frameSize == NULL)
 464         return PluginLID_InvalidParameter;
 465
 466       if (m_uiLineCount == 0)
 467         return PluginLID_DeviceNotOpen;
 468
 469       if (line >= m_uiLineCount)
 470         return PluginLID_NoSuchLine;
 471
 472       *frameSize = lineState[line].writeFrameSize;
 473       return PluginLID_NoError;
 474     }
 475
 476
 477     PLUGIN_FUNCTION_ARG3(ReadFrame, unsigned,line, void *,buffer, unsigned *,count)
 478     {
 479       if (buffer == NULL || count == NULL)
 480         return PluginLID_InvalidParameter;
 481
 482       if (m_uiLineCount == 0)
 483         return PluginLID_DeviceNotOpen;
 484
 485       if (line >= m_uiLineCount)
 486         return PluginLID_NoSuchLine;
 487
 488       *count = lineState[line].readFrameSize;
 489       vpb_record_buf_sync(lineState[line].handle, (char *)buffer, (unsigned short)*count);
 490       return PluginLID_NoError;
 491     }
 492
 493
 494     PLUGIN_FUNCTION_ARG4(WriteFrame, unsigned,line, const void *,buffer, unsigned,count, unsigned *,written)
 495     {
 496       if (buffer == NULL || written == NULL)
 497         return PluginLID_InvalidParameter;
 498
 499       if (m_uiLineCount == 0)
 500         return PluginLID_DeviceNotOpen;
 501
 502       if (line >= m_uiLineCount)
 503         return PluginLID_NoSuchLine;
 504
 505       *written = count;
 506       vpb_play_buf_sync(lineState[line].handle, (char *)buffer, (unsigned short)count);
 507       return PluginLID_NoError;
 508     }
 509
 510
 511
 512     //PLUGIN_FUNCTION_ARG3(GetAverageSignalLevel, unsigned,line, PluginLID_Boolean,playback, unsigned *,signal)
 513     //PLUGIN_FUNCTION_ARG2(EnableAudio, unsigned,line, PluginLID_Boolean,enable)
 514     //PLUGIN_FUNCTION_ARG2(IsAudioEnabled, unsigned,line, PluginLID_Boolean *,enable)
 515
 516
 517     PLUGIN_FUNCTION_ARG2(SetRecordVolume, unsigned,line, unsigned,volume)
 518     {
 519       if (m_uiLineCount == 0)
 520         return PluginLID_DeviceNotOpen;
 521
 522       if (line >= m_uiLineCount)
 523         return PluginLID_NoSuchLine;
 524
 525       return vpb_record_set_gain(lineState[line].handle, (float)(volume/100.0*24.0-12.0)) >= 0 ? PluginLID_NoError : PluginLID_InternalError;
 526     }
 527
 528
 529     PLUGIN_FUNCTION_ARG2(SetPlayVolume, unsigned,line, unsigned,volume)
 530     {
 531       if (m_uiLineCount == 0)
 532         return PluginLID_DeviceNotOpen;
 533
 534       if (line >= m_uiLineCount)
 535         return PluginLID_NoSuchLine;
 536
 537       return vpb_play_set_gain(lineState[line].handle, (float)(volume/100.0*24.0-12.0)) >= 0 ? PluginLID_NoError : PluginLID_InternalError;
 538     }
 539
 540
 541     PLUGIN_FUNCTION_ARG2(GetRecordVolume, unsigned,line, unsigned *,volume)
 542     {
 543       if (volume == NULL)
 544         return PluginLID_InvalidParameter;
 545
 546       if (m_uiLineCount == 0)
 547         return PluginLID_DeviceNotOpen;
 548
 549       if (line >= m_uiLineCount)
 550         return PluginLID_NoSuchLine;
 551
 552       float gain;
 553       if (vpb_record_get_gain(lineState[line].handle, &gain) < 0)
 554         return PluginLID_InternalError;
 555
 556       *volume = (unsigned)((gain+12.0)/24.0*100.0);
 557       return PluginLID_NoError;
 558     }
 559
 560
 561     PLUGIN_FUNCTION_ARG2(GetPlayVolume, unsigned,line, unsigned *,volume)
 562     {
 563       if (volume == NULL)
 564         return PluginLID_InvalidParameter;
 565
 566       if (m_uiLineCount == 0)
 567         return PluginLID_DeviceNotOpen;
 568
 569       if (line >= m_uiLineCount)
 570         return PluginLID_NoSuchLine;
 571
 572       float gain;
 573       if (vpb_play_get_gain(lineState[line].handle, &gain) < 0)
 574         return PluginLID_InternalError;
 575
 576       *volume = (unsigned)((gain+12.0)/24.0*100.0);
 577       return PluginLID_NoError;
 578     }
 579
 580
 581
 582     //PLUGIN_FUNCTION_ARG2(GetAEC, unsigned,line, unsigned *,level)
 583     //PLUGIN_FUNCTION_ARG2(SetAEC, unsigned,line, unsigned,level)
 584     //PLUGIN_FUNCTION_ARG2(GetVAD, unsigned,line, PluginLID_Boolean *,enable)
 585     //PLUGIN_FUNCTION_ARG2(SetVAD, unsigned,line, PluginLID_Boolean,enable)
 586     //PLUGIN_FUNCTION_ARG4(GetCallerID, unsigned,line, char *,idString, unsigned,size, PluginLID_Boolean,full)
 587     //PLUGIN_FUNCTION_ARG2(SetCallerID, unsigned,line, const char *,idString)
 588     //PLUGIN_FUNCTION_ARG2(SendCallerIDOnCallWaiting, unsigned,line, const char *,idString)
 589     //PLUGIN_FUNCTION_ARG2(SendVisualMessageWaitingIndicator, unsigned,line, PluginLID_Boolean,on)
 590
 591     PLUGIN_FUNCTION_ARG4(PlayDTMF, unsigned,line, const char *,digits, unsigned,onTime, unsigned,offTime)
 592     {
 593       if (digits == NULL)
 594         return PluginLID_InvalidParameter;
 595
 596       if (m_uiLineCount == 0)
 597         return PluginLID_DeviceNotOpen;
 598
 599       if (line >= m_uiLineCount)
 600         return PluginLID_NoSuchLine;
 601
 602       try {
 603         vpb_dial_sync(lineState[line].handle, (char *)digits);
 604         vpb_dial_sync(lineState[line].handle, ",");
 605       }
 606       catch(VpbException v) {
 607         std::cerr << "VPB\tPlayDTMF Error code = "  << v.code << ", s = " << v.s << " api func = " << v.api_function << std::endl;
 608         return PluginLID_InternalError;
 609       }
 610
 611       return PluginLID_NoError;
 612     }
 613
 614
 615     PLUGIN_FUNCTION_ARG2(ReadDTMF, unsigned,line, char *,digit)
 616     {
 617       return PluginLID_NoError;
 618     }
 619
 620
 621     PLUGIN_FUNCTION_ARG2(GetRemoveDTMF, unsigned,line, PluginLID_Boolean *,removeTones)
 622     {
 623       return PluginLID_NoError;
 624     }
 625
 626
 627     PLUGIN_FUNCTION_ARG2(SetRemoveDTMF, unsigned,line, PluginLID_Boolean,removeTones)
 628     {
 629       return PluginLID_NoError;
 630     }
 631
 632
 633
 634     PLUGIN_FUNCTION_ARG2(IsToneDetected, unsigned,line, unsigned *,tone)
 635     {
 636       if (tone == NULL)
 637         return PluginLID_InvalidParameter;
 638
 639       if (m_uiLineCount == 0)
 640         return PluginLID_DeviceNotOpen;
 641
 642       if (line >= m_uiLineCount)
 643         return PluginLID_NoSuchLine;
 644
 645       *tone = PluginLID_NoTone;
 646
 647       VPB_EVENT event;
 648       try {
 649         if (vpb_get_event_ch_async(lineState[line].handle, &event) == VPB_NO_EVENTS)
 650           return PluginLID_NoError;
 651       }
 652       catch (VpbException v) {
 653         std::cerr << "VPB\tOpalVpbDevice::Open Error code = "  << v.code << ", s = " << v.s << " api func = " << v.api_function << std::endl;
 654         return PluginLID_InternalError;
 655       }
 656
 657       if (event.type == VPB_RING) {
 658         *tone = PluginLID_RingTone;
 659         return PluginLID_NoError;
 660       }
 661
 662       if (event.type != VPB_TONEDETECT)
 663         return PluginLID_NoError;
 664
 665       switch (event.data) {
 666         case VPB_DIAL :
 667           *tone = PluginLID_DialTone;
 668           break;
 669         case VPB_RINGBACK :
 670           *tone = PluginLID_RingTone;
 671           break;
 672         case VPB_BUSY :
 673           *tone = PluginLID_BusyTone;
 674           break;
 675     #ifdef VPB_FASTBUSY
 676         case VPB_FASTBUSY :
 677           *tone = PluginLID_FastBusyTone;
 678           break;
 679     #endif
 680         case VPB_GRUNT :
 681           break;
 682     #ifdef VPB_MWI
 683         case VPB_MWI :
 684           *tone = PluginLID_MwiTone;
 685           break;
 686     #endif
 687         default:
 688           std::cerr << "VPB\tTone Detect: no a known tone." << event.data<< std::endl;
 689           return PluginLID_InternalError;
 690       }
 691
 692       return PluginLID_NoError;
 693     }
 694
 695
 696     //PLUGIN_FUNCTION_ARG3(WaitForToneDetect, unsigned,line, unsigned,timeout, unsigned *,tone)
 697     //PLUGIN_FUNCTION_ARG3(WaitForTone, unsigned,line, unsigned,tone, unsigned,timeout)
 698     //PLUGIN_FUNCTION_ARG7(SetToneFilterParameters, unsigned        ,line,
 699     //                                              unsigned        ,tone,
 700     //                                              unsigned        ,lowFrequency,
 701     //                                              unsigned        ,highFrequency,
 702     //                                              unsigned        ,numCadences,
 703     //                                              const unsigned *,onTimes,
 704     //                                              const unsigned *,offTimes)
 705     //PLUGIN_FUNCTION_ARG2(PlayTone, unsigned,line, unsigned,tone)
 706     //PLUGIN_FUNCTION_ARG2(IsTonePlaying, unsigned,line, PluginLID_Boolean *,playing)
 707     //PLUGIN_FUNCTION_ARG1(StopTone, unsigned,line)
 708     //PLUGIN_FUNCTION_ARG4(DialOut, unsigned,line, const char *,number, PluginLID_Boolean,requireTones, unsigned,uiDialDelay)
 709     //PLUGIN_FUNCTION_ARG2(GetWinkDuration, unsigned,line, unsigned *,winkDuration)
 710     //PLUGIN_FUNCTION_ARG2(SetWinkDuration, unsigned,line, unsigned,winkDuration)
 711     //PLUGIN_FUNCTION_ARG1(SetCountryCode, unsigned,country)
 712     //PLUGIN_FUNCTION_ARG2(GetSupportedCountry, unsigned,index, unsigned *,countryCode)
 713 };
 714
 715
 716
 717 /////////////////////////////////////////////////////////////////////////////
 718
 719 static struct PluginLID_Definition definition[1] =
 720 {
 721
 722   {
 723     // encoder
 724     PLUGIN_LID_VERSION,               // API version
 725
 726     1083666706,                       // timestamp = Tue 04 May 2004 10:31:46 AM UTC =
 727
 728     "VPB",                            // LID name text
 729     "Voicetronix VPB-4",              // LID description text
 730     "Voicetronix",                    // LID manufacturer name
 731     "VPB",                            // LID model name
 732     "1.0",                            // LID hardware revision number
 733     "peter@voicetronix.com.au",       // LID email contact information
 734     "http://www.voicetronix.com.au",  // LID web site
 735
 736     "Robert Jongbloed, Post Increment",                          // source code author
 737     "robertj@postincrement.com",                                 // source code email
 738     "http://www.postincrement.com",                              // source code URL
 739     "Copyright (C) 2006 by Post Increment, All Rights Reserved", // source code copyright
 740     "MPL 1.0",                                                   // source code license
 741     "1.0",                                                       // source code version
 742
 743     NULL,                             // user data value
 744
 745     Context::Create,
 746     Context::Destroy,
 747     Context::GetDeviceName,
 748     Context::Open,
 749     Context::Close,
 750     Context::GetLineCount,
 751     Context::IsLineTerminal,
 752     Context::IsLinePresent,
 753     Context::IsLineOffHook,
 754     Context::SetLineOffHook,
 755     NULL, //Context::HookFlash,
 756     NULL, //Context::HasHookFlash,
 757     Context::IsLineRinging,
 758     NULL, //Context::RingLine,
 759     NULL, //Context::IsLineConnected,
 760     NULL, //Context::SetLineToLineDirect,
 761     NULL, //Context::IsLineToLineDirect,
 762     Context::GetSupportedFormat,
 763     Context::SetReadFormat,
 764     Context::SetWriteFormat,
 765     Context::GetReadFormat,
 766     Context::GetWriteFormat,
 767     Context::StopReading,
 768     Context::StopWriting,
 769     Context::SetReadFrameSize,
 770     Context::SetWriteFrameSize,
 771     Context::GetReadFrameSize,
 772     Context::GetWriteFrameSize,
 773     Context::ReadFrame,
 774     Context::WriteFrame,
 775     NULL,//Context::GetAverageSignalLevel,
 776     NULL,//Context::EnableAudio,
 777     NULL,//Context::IsAudioEnabled,
 778     Context::SetRecordVolume,
 779     Context::SetPlayVolume,
 780     Context::GetRecordVolume,
 781     Context::GetPlayVolume,
 782     NULL,//Context::GetAEC,
 783     NULL,//Context::SetAEC,
 784     NULL,//Context::GetVAD,
 785     NULL,//Context::SetVAD,
 786     NULL,//Context::GetCallerID,
 787     NULL,//Context::SetCallerID,
 788     NULL,//Context::SendCallerIDOnCallWaiting,
 789     NULL,//Context::SendVisualMessageWaitingIndicator,
 790     Context::PlayDTMF,
 791     Context::ReadDTMF,
 792     Context::GetRemoveDTMF,
 793     Context::SetRemoveDTMF,
 794     Context::IsToneDetected,
 795     NULL,//Context::WaitForToneDetect,
 796     NULL,//Context::WaitForTone,
 797     NULL,//Context::SetToneFilterParameters,
 798     NULL,//Context::PlayTone,
 799     NULL,//Context::IsTonePlaying,
 800     NULL,//Context::StopTone,
 801     NULL,//Context::DialOut,
 802     NULL,//Context::GetWinkDuration,
 803     NULL,//Context::SetWinkDuration,
 804     NULL,//Context::SetCountryCode,
 805     NULL,//Context::GetSupportedCountry
 806   }
 807
 808 };
 809
 810 PLUGIN_LID_IMPLEMENTATION(definition);
 811
 812 /////////////////////////////////////////////////////////////////////////////