src/ptlib/unix/macosaudio.cxx

   1 /*
   2  * macosxaudio.cxx
   3  *
   4  * Sound driver implementation.
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23  *
  24  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25  * All Rights Reserved.
  26  *
  27  * Contributor(s):
  28  *
  29  * $Log$
  30  * Revision 1.3  2002/02/09 00:52:01  robertj
  31  * Slight adjustment to API and documentation for volume functions.
  32  *
  33  * Revision 1.2  2002/02/07 20:57:21  dereks
  34  * add SetVolume and GetVolume methods to PSoundChannel
  35  *
  36  * Revision 1.1  2001/08/11 15:38:43  rogerh
  37  * Add Mac OS Carbon changes from John Woods <jfw@jfwhome.funhouse.com>
  38  *
  39  *
  40  */
  41
  42 #pragma implementation "sound.h"
  43
  44 #include <ptlib.h>
  45
  46 // goddamn apple headers
  47 #undef TCP_NODELAY
  48 #undef TCP_MAXSEG
  49
  50 //#include "macosaudio/SoundInput.h"
  51 //#include "macosaudio/SoundPlayer.h"
  52 #include "macosaudio/MacMain.h" // interface to the Main Thread for Carbon
  53 #include "macosaudio/ringbuffer.h"
  54
  55 #define DEFAULTSAMPLESIZE 16
  56
  57 // PSound
  58 PSound::PSound(unsigned channels,
  59                unsigned samplesPerSecond,
  60                unsigned bitsPerSample,
  61                PINDEX   bufferSize,
  62                const BYTE * buffer)
  63 {
  64         // Copy format
  65         SetFormat(channels, samplesPerSecond, DEFAULTSAMPLESIZE);
  66
  67     // Copy data passed
  68     SetSize(bufferSize);
  69     if( buffer )
  70         memcpy(GetPointer(), buffer, bufferSize);
  71 }
  72
  73
  74 PSound::PSound(const PFilePath & filename)
  75 {
  76         // Copy format
  77         SetFormat(1, 8000, DEFAULTSAMPLESIZE);
  78
  79         // Load the sound
  80     SetSize(0);
  81         Load(filename);
  82 }
  83
  84
  85 PSound & PSound::operator=(const PBYTEArray & data)
  86 {
  87   PBYTEArray::operator=(data);
  88   return *this;
  89 }
  90
  91
  92 void PSound::SetFormat(unsigned channels,
  93                        unsigned samplesPerSecond,
  94                        unsigned bitsPerSample)
  95 {
  96         formatInfo.SetSize( 0 ); // media format inside
  97
  98         // Build our format definition
  99         sampleSize = bitsPerSample;
 100         sampleRate = samplesPerSecond;
 101         numChannels = channels;
 102 }
 103
 104 BOOL PSound::Load(const PFilePath & filename)
 105 {
 106     return FALSE;
 107 }
 108
 109
 110 BOOL PSound::Save(const PFilePath & filename)
 111 {
 112     return FALSE;
 113 }
 114
 115
 116 PSoundChannel::PSoundChannel() :
 117         mpInput(NULL),
 118         mNumChannels(1), mSampleRate(8000), mBitsPerSample(16)
 119 {
 120   Construct();
 121 }
 122
 123
 124 PSoundChannel::PSoundChannel(const PString & device,
 125                              Directions dir,
 126                              unsigned numChannels,
 127                              unsigned sampleRate,
 128                              unsigned bitsPerSample) :
 129         mpInput(NULL),
 130         mNumChannels(numChannels), mSampleRate(sampleRate), mBitsPerSample(bitsPerSample)
 131 {
 132   Construct();
 133
 134   Open(device, dir, numChannels, sampleRate, bitsPerSample);
 135 }
 136
 137
 138 void PSoundChannel::Construct()
 139 {
 140 }
 141
 142
 143 PSoundChannel::~PSoundChannel()
 144 {
 145         Close();
 146
 147         if( direction == Recorder && mpInput )
 148                 delete mpInput;
 149 }
 150
 151
 152 PStringArray PSoundChannel::GetDeviceNames(Directions /*dir*/)
 153 {
 154   PStringArray array;
 155
 156   array[0]= "built-in audio";
 157   return array;
 158 }
 159
 160
 161 PString PSoundChannel::GetDefaultDevice(Directions /*dir*/)
 162 {
 163   return "built-in audio";
 164 }
 165
 166
 167 BOOL PSoundChannel::Open(const PString & dev,
 168                          Directions dir,
 169                          unsigned numChannels,
 170                          unsigned sampleRate,
 171                          unsigned bitsPerSample)
 172 {
 173     Close();
 174     PTRACE(1, "PSoundChannel::Open: " <<  dev << "," << (int)dir);
 175
 176         device = dev;
 177         direction = dir;
 178
 179         SetFormat(numChannels, sampleRate, bitsPerSample);
 180
 181     soundParams sp(numChannels, bitsPerSample, sampleRate);
 182
 183     if( direction == Player )
 184         {
 185         int err;
 186
 187         // XXX PString only has a const unsigned char * operator
 188         // XXX if HAS_UNICODE is not defined -- yet they don't provide
 189         // XXX any decent operators for portably extracting into a
 190         // XXX char buffer.
 191         commandRequest r(kOpenPlayer,
 192                          (const unsigned char *)device, &sp);
 193         err = r.CarbonQueue();
 194         if (err == 0 && r.m_status == 0) {
 195             os_handle = r.m_result;
 196         }
 197         else {
 198             fprintf(stderr,"OpenPlayer failed! %d\n",err);
 199             goto bail;
 200         }
 201
 202         r = commandRequest(kSetFormatPlayer, os_handle, &sp);
 203         err = r.CarbonQueue();
 204         if (err != 0 || r.m_status)
 205             goto bail; // destructor will close channel
 206
 207         PTRACE(1, "PSoundChannel::Open(p): returning TRUE");
 208                 return TRUE;
 209         }
 210         else
 211         if( direction == Recorder )
 212         {
 213         mpInput = new JRingBuffer(4096);
 214         if (!mpInput) goto bail;
 215
 216         int err;
 217         commandRequest r(kOpenRecorder, (const unsigned char *)dev, &sp);
 218         err = r.CarbonQueue();
 219         if (err == 0 && r.m_status == 0) {
 220             os_handle = r.m_result;
 221         }
 222         else goto bail;
 223         r = commandRequest(kSetFormatRecorder, os_handle, &sp);
 224         err = r.CarbonQueue();
 225         if (err || r.m_status) goto bail;
 226
 227         r = commandRequest(kStartRecorder,
 228                            os_handle, (void *)mpInput);
 229         err = r.CarbonQueue();
 230         if (err || r.m_status) goto bail;
 231
 232         PTRACE(1, "PSoundChannel::Open(r): returning TRUE");
 233         return TRUE;
 234         } else assert(0); // bad direction type
 235
 236   bail: // badness
 237         return FALSE;
 238 }
 239
 240
 241 BOOL PSoundChannel::SetFormat(unsigned numChannels,
 242                               unsigned sampleRate,
 243                               unsigned bitsPerSample)
 244 {
 245     PTRACE(1, "PSoundChannel::SetFormat: " <<  numChannels << "," << sampleRate << "," << bitsPerSample);
 246
 247         PAssert(numChannels >= 1 && numChannels <= 2, PInvalidParameter);
 248         PAssert(        bitsPerSample == 0 ||
 249                 bitsPerSample == 8 ||
 250                 bitsPerSample == 16 ||
 251                 bitsPerSample == 32, PInvalidParameter);
 252
 253         if( !bitsPerSample )
 254                 PError << "\tWarning: sample bits parameter is zero. Float?" << endl;
 255
 256         mNumChannels = numChannels;
 257         mSampleRate = sampleRate;
 258         mBitsPerSample = bitsPerSample;
 259
 260     soundParams sp(numChannels, bitsPerSample, sampleRate);
 261
 262         if( direction == Player )
 263         {
 264                 if( os_handle < 0 )
 265                         return FALSE;
 266
 267         commandRequest r(kSetFormatPlayer, os_handle, &sp);
 268         int err = r.CarbonQueue();
 269         if (err || r.m_status)
 270             return FALSE;
 271         return TRUE;
 272         }
 273         else
 274         if( direction == Recorder )
 275         {
 276                 if( os_handle < 0 )
 277                         return FALSE;
 278
 279         commandRequest r(kSetFormatRecorder, os_handle, &sp);
 280         int err = r.CarbonQueue();
 281         if (err || r.m_status)
 282             return FALSE;
 283         return TRUE;
 284     }
 285
 286         return FALSE;
 287 }
 288
 289 BOOL PSoundChannel::Read( void * buf, PINDEX len)
 290 {
 291         if( direction == Player )
 292         {
 293                 return FALSE;
 294         }
 295         else
 296         if( direction == Recorder )
 297         {
 298         static int total_read = 0;
 299         static int message_level = 0;
 300
 301                 if( !mpInput )
 302                         return FALSE;
 303
 304                 int rlen = mpInput->Read(buf, len);
 305         PAssert(rlen == -1 || rlen == len, "huh?");
 306         if (rlen >= 0) {
 307             static Nanoseconds gStartTime, gMostRecentTime;
 308             if (total_read == 0) gStartTime = AbsoluteToNanoseconds(UpTime());
 309             else gMostRecentTime = AbsoluteToNanoseconds(UpTime());
 310             total_read += rlen;
 311             if (total_read >= 80000 && message_level == 0) {
 312                 fprintf(stderr,"80000 bytes read\n");
 313                 message_level = 1;
 314             }
 315             else if (total_read >= 240000 && message_level == 1) {
 316                 fprintf(stderr,"240000 bytes read at %d samples per sec\n",
 317                         (total_read*10) /
 318                         (long)( (*(long long *)&gMostRecentTime -
 319                                  *(long long *)&gStartTime ) / 100000000LL));
 320                 message_level = 2;
 321             }
 322         }
 323
 324                 return rlen == len? TRUE : FALSE;
 325         }
 326
 327         return FALSE;
 328 }
 329
 330 BOOL PSoundChannel::Write( const void * buf, PINDEX len)
 331 {
 332         if( direction == Player )
 333         {
 334         commandRequest r(kPlaySample, (unsigned long)os_handle,
 335                          (const unsigned char *)buf,
 336                          (unsigned long)len);
 337         int err = r.CarbonQueue();
 338         if (err || r.m_status) {
 339             fprintf(stderr,"Write failed: err %d status %d\n", err, r.m_status);
 340             return FALSE;
 341         }
 342
 343         return TRUE;
 344         }
 345         else
 346         if( direction == Recorder )
 347         {
 348                 return FALSE;
 349         }
 350
 351         return FALSE;
 352 }
 353
 354 BOOL PSoundChannel::Close()
 355 {
 356         if( direction == Player )
 357         {
 358         if (os_handle >= 0) {
 359             commandRequest r(kClosePlayer, os_handle);
 360             (void) r.CarbonQueue();
 361         }
 362         isInitialised = false;
 363         os_handle = -1;
 364                 return TRUE;
 365         }
 366         else
 367         if( direction == Recorder )
 368         {
 369         if (os_handle > 0) {
 370             commandRequest r(kCloseRecorder, os_handle);
 371             (void) r.CarbonQueue();
 372         }
 373
 374                 isInitialised = false;
 375         os_handle = -1;
 376                 return TRUE;
 377         }
 378
 379         return FALSE;
 380 }
 381
 382 BOOL PSoundChannel::SetBuffers(PINDEX size, PINDEX count)
 383 {
 384   PAssert(size > 0 && count > 0 && count < 65536, PInvalidParameter);
 385
 386   return TRUE;
 387 }
 388
 389
 390 BOOL PSoundChannel::GetBuffers(PINDEX & size, PINDEX & count)
 391 {
 392   return TRUE;
 393 }
 394
 395
 396 BOOL PSoundChannel::PlaySound(const PSound & sound, BOOL wait)
 397 {
 398   if (!Write((const BYTE *)sound, sound.GetSize()))
 399     return FALSE;
 400
 401   if (wait)
 402     return WaitForPlayCompletion();
 403   return TRUE;
 404 }
 405
 406
 407 BOOL PSoundChannel::PlayFile(const PFilePath & filename, BOOL wait)
 408 {
 409   return FALSE;
 410 }
 411
 412
 413 BOOL PSoundChannel::HasPlayCompleted()
 414 {
 415     commandRequest r(kIsPlaying, os_handle);
 416     (void)r.CarbonQueue();
 417         return r.m_result ? FALSE : TRUE;
 418 }
 419
 420
 421 BOOL PSoundChannel::WaitForPlayCompletion()
 422 {
 423     commandRequest r(kWaitForPlayCompletion, os_handle);
 424     int err = r.CarbonQueue();
 425     if (err == 0) err = r.m_status;
 426     return err == 0;
 427 }
 428
 429
 430 BOOL PSoundChannel::RecordSound(PSound & sound)
 431 {
 432   return FALSE;
 433 }
 434
 435
 436 BOOL PSoundChannel::RecordFile(const PFilePath & filename)
 437 {
 438   return FALSE;
 439 }
 440
 441
 442 BOOL PSoundChannel::StartRecording()
 443 {
 444         if( direction == Player )
 445         {
 446                 return FALSE;
 447         }
 448         else
 449         if( direction == Recorder )
 450         {
 451                 PAssertNULL(mpInput);
 452
 453         commandRequest r(kStartRecorder, os_handle, mpInput);
 454         int err = r.CarbonQueue();
 455         if (err == 0) err = r.m_status;
 456
 457                 if( err == 0 )
 458                         PError << "Recording started" << endl;
 459                 return err == 0 ? TRUE : FALSE;
 460         }
 461
 462         return FALSE;
 463 }
 464
 465
 466 // Is there any record data to read?
 467 BOOL PSoundChannel::IsRecordBufferFull()
 468 {
 469         if( direction == Recorder )
 470         {
 471                 PAssertNULL(mpInput);
 472         return !mpInput->IsEmpty();
 473     }
 474     return FALSE;
 475 }
 476
 477
 478 BOOL PSoundChannel::AreAllRecordBuffersFull()
 479 {
 480         if( direction == Recorder )
 481         {
 482                 PAssertNULL(mpInput);
 483         return mpInput->IsFull();
 484     }
 485     return FALSE;
 486 }
 487
 488
 489 BOOL PSoundChannel::WaitForRecordBufferFull()
 490 {
 491         if( direction == Recorder )
 492         {
 493                 PAssertNULL(mpInput);
 494         return mpInput->WaitForData();
 495     }
 496     return FALSE;
 497 }
 498
 499
 500 BOOL PSoundChannel::WaitForAllRecordBuffersFull()
 501 {
 502   return FALSE;
 503 }
 504
 505
 506 BOOL PSoundChannel::Abort()
 507 {
 508         if( direction == Player )
 509         {
 510         commandRequest r(kStopPlayer, os_handle);
 511         int err = r.CarbonQueue();
 512         if (err == 0) err = r.m_status;
 513        return err == 0;
 514         }
 515         else
 516         if( direction == Recorder )
 517         {
 518                 if(!mpInput)
 519                         return FALSE;
 520
 521         commandRequest r(kStopRecorder, os_handle);
 522         int err = r.CarbonQueue();
 523         if (err == 0) err = r.m_status;
 524         return TRUE;
 525         }
 526
 527         return FALSE;
 528 }
 529
 530 BOOL PSoundChannel::SetVolume(unsigned newVolume)
 531 {
 532   cerr << __FILE__ << "PSoundChannel :: SetVolume called in error. Please fix"<<endl;
 533   return FALSE;
 534 }
 535
 536 BOOL  PSoundChannel::GetVolume(unsigned & volume)
 537 {
 538  cerr << __FILE__ << "PSoundChannel :: GetVolume called in error. Please fix"<<endl;
 539   return FALSE;
 540 }
 541
 542
 543 // End of file
 544