src/ptlib/unix/vxaudio.cxx

   1 #pragma implementation "sound.h"
   2
   3 #include <ptlib.h>
   4
   5 #include <time.h>
   6
   7 class SoundHandleEntry : public PObject {
   8
   9   PCLASSINFO(SoundHandleEntry, PObject)
  10
  11   public:
  12     SoundHandleEntry();
  13
  14     int handle;
  15     int direction;
  16
  17     unsigned numChannels;
  18     unsigned sampleRate;
  19     unsigned bitsPerSample;
  20     unsigned fragmentValue;
  21     BOOL isInitialised;
  22 };
  23
  24 PDICTIONARY(SoundHandleDict, PString, SoundHandleEntry);
  25
  26 PMutex           PSoundChannel::dictMutex;
  27
  28 static SoundHandleDict & handleDict()
  29 {
  30   static SoundHandleDict dict;
  31   return dict;
  32 }
  33
  34 #define LOOPBACK_BUFFER_SIZE 5000
  35 #define BYTESINBUF ((startptr<endptr)?(endptr-startptr):(LOOPBACK_BUFFER_SIZE+endptr-startptr))
  36
  37 char soundbuffer[LOOPBACK_BUFFER_SIZE];
  38 int  startptr, endptr;
  39
  40
  41 PSound::PSound(unsigned channels,
  42                unsigned samplesPerSecond,
  43                unsigned bitsPerSample,
  44                PINDEX   bufferSize,
  45                const BYTE * buffer)
  46 {
  47   encoding = 0;
  48   numChannels = channels;
  49   sampleRate = samplesPerSecond;
  50   sampleSize = bitsPerSample;
  51   SetSize(bufferSize);
  52   if (buffer != NULL)
  53     memcpy(GetPointer(), buffer, bufferSize);
  54 }
  55
  56
  57 PSound::PSound(const PFilePath & filename)
  58 {
  59   encoding = 0;
  60   numChannels = 1;
  61   sampleRate = 8000;
  62   sampleSize = 16;
  63   Load(filename);
  64 }
  65
  66
  67 PSound & PSound::operator=(const PBYTEArray & data)
  68 {
  69   PBYTEArray::operator=(data);
  70   return *this;
  71 }
  72
  73
  74 void PSound::SetFormat(unsigned channels,
  75                        unsigned samplesPerSecond,
  76                        unsigned bitsPerSample)
  77 {
  78   encoding = 0;
  79   numChannels = channels;
  80   sampleRate = samplesPerSecond;
  81   sampleSize = bitsPerSample;
  82   formatInfo.SetSize(0);
  83 }
  84
  85
  86 BOOL PSound::Load(const PFilePath & /*filename*/)
  87 {
  88   return FALSE;
  89 }
  90
  91
  92 BOOL PSound::Save(const PFilePath & /*filename*/)
  93 {
  94   return FALSE;
  95 }
  96
  97 ///////////////////////////////////////////////////////////////////////////////
  98
  99 SoundHandleEntry::SoundHandleEntry()
 100 {
 101   handle    = -1;
 102   direction = 0;
 103 }
 104
 105 ///////////////////////////////////////////////////////////////////////////////
 106
 107 PSoundChannel::PSoundChannel()
 108 {
 109   Construct();
 110 }
 111
 112
 113 PSoundChannel::PSoundChannel(const PString & device,
 114                              Directions dir,
 115                              unsigned numChannels,
 116                              unsigned sampleRate,
 117                              unsigned bitsPerSample)
 118 {
 119   Construct();
 120   Open(device, dir, numChannels, sampleRate, bitsPerSample);
 121 }
 122
 123
 124 void PSoundChannel::Construct()
 125 {
 126   os_handle = -1;
 127 }
 128
 129
 130 PSoundChannel::~PSoundChannel()
 131 {
 132   Close();
 133 }
 134
 135
 136 PStringArray PSoundChannel::GetDeviceNames(Directions /*dir*/)
 137 {
 138   static const char * const devices[] = {
 139     "loopback"
 140   };
 141
 142   return PStringArray(PARRAYSIZE(devices), devices);
 143 }
 144
 145
 146 PString PSoundChannel::GetDefaultDevice(Directions /*dir*/)
 147 {
 148   return "loopback";
 149 }
 150
 151
 152 BOOL PSoundChannel::Open(const PString & _device,
 153                               Directions _dir,
 154                                 unsigned _numChannels,
 155                                 unsigned _sampleRate,
 156                                 unsigned _bitsPerSample)
 157 {
 158   Close();
 159
 160   // lock the dictionary
 161   dictMutex.Wait();
 162
 163   // make the direction value 1 or 2
 164   int dir = _dir + 1;
 165
 166   // if this device in in the dictionary
 167   if (handleDict().Contains(_device)) {
 168
 169     SoundHandleEntry & entry = handleDict()[_device];
 170
 171     // see if the sound channel is already open in this direction
 172     if ((entry.direction & dir) != 0) {
 173       dictMutex.Signal();
 174       return FALSE;
 175     }
 176
 177     // flag this entry as open in this direction
 178     entry.direction |= dir;
 179     os_handle = entry.handle;
 180
 181   } else {
 182
 183     // this is the first time this device has been used
 184     // open the device in read/write mode always
 185     if (_device == "loopback") {
 186       startptr = endptr = 0;
 187       os_handle = 0; // Use os_handle value 0 to indicate loopback, cannot ever be stdin!
 188     }
 189     else  {
 190       PAssertAlways(PUnimplementedFunction);
 191       return FALSE;
 192     }
 193
 194     // add the device to the dictionary
 195     SoundHandleEntry * entry = PNEW SoundHandleEntry;
 196     handleDict().SetAt(_device, entry);
 197
 198     // save the information into the dictionary entry
 199     entry->handle        = os_handle;
 200     entry->direction     = dir;
 201     entry->numChannels   = _numChannels;
 202     entry->sampleRate    = _sampleRate;
 203     entry->bitsPerSample = _bitsPerSample;
 204     entry->isInitialised = FALSE;
 205     entry->fragmentValue = 0x7fff0008;
 206   }
 207
 208
 209   // unlock the dictionary
 210   dictMutex.Signal();
 211
 212   // save the direction and device
 213   direction     = _dir;
 214   device        = _device;
 215   isInitialised = FALSE;
 216
 217   return TRUE;
 218 }
 219
 220 BOOL PSoundChannel::Setup()
 221 {
 222   if (os_handle < 0)
 223     return FALSE;
 224
 225   if (isInitialised)
 226     return TRUE;
 227
 228   // lock the dictionary
 229   dictMutex.Wait();
 230
 231   // the device must always be in the dictionary
 232   PAssertOS(handleDict().Contains(device));
 233
 234   // get record for the device
 235   SoundHandleEntry & entry = handleDict()[device];
 236
 237   BOOL stat = FALSE;
 238   if (entry.isInitialised)  {
 239     isInitialised = TRUE;
 240     stat          = TRUE;
 241   } else if (device == "loopback")
 242     stat = TRUE;
 243   else {
 244     PAssertAlways(PUnimplementedFunction);
 245   }
 246
 247   entry.isInitialised = TRUE;
 248   isInitialised       = TRUE;
 249
 250   dictMutex.Signal();
 251
 252   return stat;
 253 }
 254
 255 BOOL PSoundChannel::Close()
 256 {
 257   // if the channel isn't open, do nothing
 258   if (os_handle < 0)
 259     return TRUE;
 260
 261   if (os_handle == 0) {
 262     os_handle = -1;
 263     return TRUE;
 264   }
 265
 266   // the device must be in the dictionary
 267   dictMutex.Wait();
 268   SoundHandleEntry * entry;
 269   PAssert((entry = handleDict().GetAt(device)) != NULL, "Unknown sound device \"" + device + "\" found");
 270
 271   // modify the directions bit mask in the dictionary
 272   entry->direction ^= (direction+1);
 273
 274   // if this is the last usage of this entry, then remove it
 275   if (entry->direction == 0) {
 276     handleDict().RemoveAt(device);
 277     dictMutex.Signal();
 278     return PChannel::Close();
 279   }
 280
 281   // flag this channel as closed
 282   dictMutex.Signal();
 283   os_handle = -1;
 284   return TRUE;
 285 }
 286
 287 BOOL PSoundChannel::Write(const void * buf, PINDEX len)
 288 {
 289   static struct timespec ts = {0, 5000000};
 290
 291   if (!Setup()) {
 292     return FALSE;
 293         }
 294
 295   if (os_handle > 0) {
 296     while (!ConvertOSError(::write(os_handle, (char *)buf, len)))
 297       if (GetErrorCode() != Interrupted) {
 298         return FALSE;
 299                         }
 300     return TRUE;
 301   }
 302
 303   int index = 0;
 304
 305   while (len > 0) {
 306     len--;
 307     soundbuffer[endptr++] = ((char *)buf)[index++];
 308     if (endptr == LOOPBACK_BUFFER_SIZE)
 309       endptr = 0;
 310     while (((startptr - 1) == endptr) || ((endptr==LOOPBACK_BUFFER_SIZE - 1) && (startptr==0))) {
 311       nanosleep(&ts, 0);
 312     }
 313   }
 314   return TRUE;
 315 }
 316
 317 BOOL PSoundChannel::Read(void * buf, PINDEX len)
 318 {
 319   static struct timespec ts = {0, 5000000};
 320
 321   if (!Setup())
 322     return FALSE;
 323
 324   if (os_handle > 0) {
 325     while (!ConvertOSError(::read(os_handle, (char *)buf, len)))
 326       if (GetErrorCode() != Interrupted)
 327         return FALSE;
 328     return TRUE;
 329   }
 330
 331   int index = 0;
 332
 333   while (len > 0) {
 334
 335         int i = 0;
 336     while ((startptr == endptr) && (i < 30)){           // int i is a very dirty hack to get the
 337                                                                                                                                                                                                 // call-termination to work. Transmit thread
 338                                                                                                                                                                                                 // will otherwise not end! (channels.cxx line 706
 339                                                                                                                                                                                                 // while() will get stuck. This should be fixed.
 340                         i++;
 341       nanosleep(&ts, 0);
 342                 }
 343     len--;
 344     ((char *)buf)[index++]=soundbuffer[startptr++];
 345     if (startptr == LOOPBACK_BUFFER_SIZE)
 346       startptr = 0;
 347   }
 348
 349   return TRUE;
 350 }
 351
 352
 353 BOOL PSoundChannel::SetFormat(unsigned numChannels,
 354                               unsigned sampleRate,
 355                               unsigned bitsPerSample)
 356 {
 357   if (os_handle < 0) {
 358     return SetErrorValues(NotOpen, EBADF);
 359   }
 360
 361   // check parameters
 362   PAssert((bitsPerSample == 8) || (bitsPerSample == 16), PInvalidParameter);
 363   PAssert(numChannels >= 1 && numChannels <= 2, PInvalidParameter);
 364
 365   Abort();
 366
 367   // lock the dictionary
 368   dictMutex.Wait();
 369
 370   // the device must always be in the dictionary
 371   PAssertOS(handleDict().Contains(device));
 372
 373   // get record for the device
 374   SoundHandleEntry & entry = handleDict()[device];
 375
 376   entry.numChannels   = numChannels;
 377   entry.sampleRate    = sampleRate;
 378   entry.bitsPerSample = bitsPerSample;
 379   entry.isInitialised  = FALSE;
 380
 381   // unlock dictionary
 382   dictMutex.Signal();
 383
 384   // mark this channel as uninitialised
 385   isInitialised = FALSE;
 386
 387   return TRUE;
 388 }
 389
 390
 391 BOOL PSoundChannel::SetBuffers(PINDEX size, PINDEX count)
 392 {
 393   if (os_handle < 0) {
 394     return SetErrorValues(NotOpen, EBADF);
 395   }
 396
 397   Abort();
 398
 399   PAssert(size > 0 && count > 0 && count < 65536, PInvalidParameter);
 400   int arg = 1;
 401   while (size > (PINDEX)(1 << arg))
 402     arg++;
 403
 404   arg |= count << 16;
 405
 406   // lock the dictionary
 407   dictMutex.Wait();
 408
 409   // the device must always be in the dictionary
 410   PAssertOS(handleDict().Contains(device));
 411
 412   // get record for the device
 413   SoundHandleEntry & entry = handleDict()[device];
 414
 415   // set information in the common record
 416   entry.fragmentValue = arg;
 417   entry.isInitialised = FALSE;
 418
 419   // flag this channel as not initialised
 420   isInitialised       = FALSE;
 421
 422   dictMutex.Signal();
 423
 424   return TRUE;
 425 }
 426
 427
 428 BOOL PSoundChannel::GetBuffers(PINDEX & size, PINDEX & count)
 429 {
 430   if (os_handle < 0) {
 431     return SetErrorValues(NotOpen, EBADF);
 432   }
 433
 434   // lock the dictionary
 435   dictMutex.Wait();
 436
 437   // the device must always be in the dictionary
 438   PAssertOS(handleDict().Contains(device));
 439
 440   SoundHandleEntry & entry = handleDict()[device];
 441
 442   int arg = entry.fragmentValue;
 443
 444   dictMutex.Signal();
 445
 446   count = arg >> 16;
 447   size = 1 << (arg&0xffff);
 448   return TRUE;
 449 }
 450
 451
 452 BOOL PSoundChannel::PlaySound(const PSound & sound, BOOL wait)
 453 {
 454   if (os_handle < 0) {
 455     return SetErrorValues(NotOpen, EBADF);
 456   }
 457
 458   Abort();
 459
 460   if (!Write((const BYTE *)sound, sound.GetSize()))
 461     return FALSE;
 462
 463   if (wait)
 464     return WaitForPlayCompletion();
 465
 466   return TRUE;
 467 }
 468
 469
 470 BOOL PSoundChannel::PlayFile(const PFilePath & filename, BOOL wait)
 471 {
 472   if (os_handle < 0) {
 473     return SetErrorValues(NotOpen, EBADF);
 474   }
 475
 476   return FALSE;
 477 }
 478
 479
 480 BOOL PSoundChannel::HasPlayCompleted()
 481 {
 482   if (os_handle < 0) {
 483     return SetErrorValues(NotOpen, EBADF);
 484   }
 485
 486   if (os_handle == 0)
 487     return BYTESINBUF <= 0;
 488
 489   PAssertAlways(PUnimplementedFunction);
 490   return FALSE;
 491 }
 492
 493
 494 BOOL PSoundChannel::WaitForPlayCompletion()
 495 {
 496   static struct timespec ts = {0, 1000000};
 497
 498   if (os_handle < 0) {
 499     return SetErrorValues(NotOpen, EBADF);
 500   }
 501
 502   if (os_handle == 0) {
 503     while (BYTESINBUF > 0)
 504       nanosleep(&ts, 0);
 505     return TRUE;
 506   }
 507
 508   PAssertAlways(PUnimplementedFunction);
 509   return FALSE;
 510 }
 511
 512
 513 BOOL PSoundChannel::RecordSound(PSound & sound)
 514 {
 515   if (os_handle < 0) {
 516     return SetErrorValues(NotOpen, EBADF);
 517   }
 518
 519   return FALSE;
 520 }
 521
 522
 523 BOOL PSoundChannel::RecordFile(const PFilePath & filename)
 524 {
 525   if (os_handle < 0) {
 526     return SetErrorValues(NotOpen, EBADF);
 527   }
 528
 529   return FALSE;
 530 }
 531
 532
 533 BOOL PSoundChannel::StartRecording()
 534 {
 535   if (os_handle < 0) {
 536     return SetErrorValues(NotOpen, EBADF);
 537   }
 538
 539   if (os_handle == 0)
 540     return TRUE;
 541
 542   fd_set fds;
 543   FD_ZERO(&fds);
 544   FD_SET(os_handle, &fds);
 545
 546   struct timeval timeout;
 547   memset(&timeout, 0, sizeof(timeout));
 548
 549   return ConvertOSError(::select(1, &fds, NULL, NULL, &timeout));
 550 }
 551
 552
 553 BOOL PSoundChannel::IsRecordBufferFull()
 554 {
 555   if (os_handle < 0) {
 556     return SetErrorValues(NotOpen, EBADF);
 557   }
 558
 559   if (os_handle == 0)
 560     return (BYTESINBUF > 0);
 561
 562   PAssertAlways(PUnimplementedFunction);
 563   return FALSE;
 564 }
 565
 566
 567 BOOL PSoundChannel::AreAllRecordBuffersFull()
 568 {
 569   if (os_handle < 0) {
 570     return SetErrorValues(NotOpen, EBADF);
 571   }
 572
 573   if (os_handle == 0)
 574     return (BYTESINBUF == LOOPBACK_BUFFER_SIZE);
 575
 576   PAssertAlways(PUnimplementedFunction);
 577   return FALSE;
 578 }
 579
 580
 581 BOOL PSoundChannel::WaitForRecordBufferFull()
 582 {
 583   if (os_handle < 0) {
 584     return SetErrorValues(NotOpen, EBADF);
 585   }
 586
 587   return PXSetIOBlock(PXReadBlock, readTimeout);
 588 }
 589
 590
 591 BOOL PSoundChannel::WaitForAllRecordBuffersFull()
 592 {
 593   return FALSE;
 594 }
 595
 596
 597 BOOL PSoundChannel::Abort()
 598 {
 599   if (os_handle == 0) {
 600     startptr = endptr = 0;
 601     return TRUE;
 602   }
 603
 604   PAssertAlways(PUnimplementedFunction);
 605   return FALSE;
 606 }
 607
 608
 609 // End of file