src/ptlib/unix/dummyaudio.cxx

   1 /*
   2  * dummyaudio.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.5  2005/07/13 13:02:35  csoutheren
  31  * Unified interface across Windows and Unix
  32  *
  33  * Revision 1.4  2002/02/09 00:52:01  robertj
  34  * Slight adjustment to API and documentation for volume functions.
  35  *
  36  * Revision 1.3  2002/02/07 20:57:21  dereks
  37  * add SetVolume and GetVolume methods to PSoundChannel
  38  *
  39  * Revision 1.2  2001/09/27 08:37:45  rogerh
  40  * remove unwanted lastError
  41  *
  42  * Revision 1.1  2001/02/23 08:48:10  rogerh
  43  * Implement a dummy PSoundChannel class. There is no functionality
  44  * but it allows OpenH323 to link.
  45  *
  46  *
  47  */
  48
  49 #pragma implementation "sound.h"
  50
  51 #include <ptlib.h>
  52
  53 PSound::PSound(unsigned channels,
  54                unsigned samplesPerSecond,
  55                unsigned bitsPerSample,
  56                PINDEX   bufferSize,
  57                const BYTE * buffer)
  58 {
  59   encoding = 0;
  60   numChannels = channels;
  61   sampleRate = samplesPerSecond;
  62   sampleSize = bitsPerSample;
  63   SetSize(bufferSize);
  64   if (buffer != NULL)
  65     memcpy(GetPointer(), buffer, bufferSize);
  66 }
  67
  68
  69 PSound::PSound(const PFilePath & filename)
  70 {
  71   encoding = 0;
  72   numChannels = 1;
  73   sampleRate = 8000;
  74   sampleSize = 16;
  75   Load(filename);
  76 }
  77
  78
  79 PSound & PSound::operator=(const PBYTEArray & data)
  80 {
  81   PBYTEArray::operator=(data);
  82   return *this;
  83 }
  84
  85
  86 void PSound::SetFormat(unsigned channels,
  87                        unsigned samplesPerSecond,
  88                        unsigned bitsPerSample)
  89 {
  90   encoding = 0;
  91   numChannels = channels;
  92   sampleRate = samplesPerSecond;
  93   sampleSize = bitsPerSample;
  94   formatInfo.SetSize(0);
  95 }
  96
  97
  98 BOOL PSound::Load(const PFilePath & /*filename*/)
  99 {
 100   return FALSE;
 101 }
 102
 103
 104 BOOL PSound::Save(const PFilePath & /*filename*/)
 105 {
 106   return FALSE;
 107 }
 108
 109 BOOL PSound::Play(const PString & device)
 110 {
 111
 112   PSoundChannel channel(device,
 113                        PSoundChannel::Player);
 114   if (!channel.IsOpen())
 115     return FALSE;
 116
 117   return channel.PlaySound(*this, TRUE);
 118 }
 119
 120 ///////////////////////////////////////////////////////////////////////////////
 121
 122 PSoundChannel::PSoundChannel()
 123 {
 124   Construct();
 125 }
 126
 127
 128 PSoundChannel::PSoundChannel(const PString & device,
 129                              Directions dir,
 130                              unsigned numChannels,
 131                              unsigned sampleRate,
 132                              unsigned bitsPerSample)
 133 {
 134   Construct();
 135   Open(device, dir, numChannels, sampleRate, bitsPerSample);
 136 }
 137
 138
 139 void PSoundChannel::Construct()
 140 {
 141 }
 142
 143
 144 PSoundChannel::~PSoundChannel()
 145 {
 146   Close();
 147 }
 148
 149
 150 PStringArray PSoundChannel::GetDeviceNames(Directions /*dir*/)
 151 {
 152   PStringArray array;
 153
 154   array[0] = "/dev/audio";
 155   array[1] = "/dev/dsp";
 156
 157   return array;
 158 }
 159
 160
 161 PString PSoundChannel::GetDefaultDevice(Directions /*dir*/)
 162 {
 163   return "/dev/audio";
 164 }
 165
 166
 167 BOOL PSoundChannel::Open(const PString & device,
 168                          Directions dir,
 169                          unsigned numChannels,
 170                          unsigned sampleRate,
 171                          unsigned bitsPerSample)
 172 {
 173   Close();
 174
 175   if (!ConvertOSError(os_handle = ::open(device, dir == Player ? O_RDONLY : O_WRONLY)))
 176     return FALSE;
 177
 178   return SetFormat(numChannels, sampleRate, bitsPerSample);
 179 }
 180
 181
 182 BOOL PSoundChannel::Close()
 183 {
 184   return PChannel::Close();
 185 }
 186
 187
 188 BOOL PSoundChannel::SetFormat(unsigned numChannels,
 189                               unsigned sampleRate,
 190                               unsigned bitsPerSample)
 191 {
 192   Abort();
 193
 194   PAssert(numChannels >= 1 && numChannels <= 2, PInvalidParameter);
 195   PAssert(bitsPerSample == 8 || bitsPerSample == 16, PInvalidParameter);
 196
 197   return TRUE;
 198 }
 199
 200
 201 BOOL PSoundChannel::SetBuffers(PINDEX size, PINDEX count)
 202 {
 203   Abort();
 204
 205   PAssert(size > 0 && count > 0 && count < 65536, PInvalidParameter);
 206
 207   return TRUE;
 208 }
 209
 210
 211 BOOL PSoundChannel::GetBuffers(PINDEX & size, PINDEX & count)
 212 {
 213   return TRUE;
 214 }
 215
 216
 217 BOOL PSoundChannel::Write(const void * buffer, PINDEX length)
 218 {
 219   return PChannel::Write(buffer, length);
 220 }
 221
 222
 223 BOOL PSoundChannel::PlaySound(const PSound & sound, BOOL wait)
 224 {
 225   Abort();
 226
 227   if (!Write((const BYTE *)sound, sound.GetSize()))
 228     return FALSE;
 229
 230   if (wait)
 231     return WaitForPlayCompletion();
 232
 233   return TRUE;
 234 }
 235
 236
 237 BOOL PSoundChannel::PlayFile(const PFilePath & filename, BOOL wait)
 238 {
 239   return TRUE;
 240 }
 241
 242
 243 BOOL PSoundChannel::HasPlayCompleted()
 244 {
 245   return TRUE;
 246 }
 247
 248
 249 BOOL PSoundChannel::WaitForPlayCompletion()
 250 {
 251   return TRUE;
 252 }
 253
 254
 255 BOOL PSoundChannel::Read(void * buffer, PINDEX length)
 256 {
 257   return PChannel::Read(buffer, length);
 258 }
 259
 260
 261 BOOL PSoundChannel::RecordSound(PSound & sound)
 262 {
 263   return TRUE;
 264 }
 265
 266
 267 BOOL PSoundChannel::RecordFile(const PFilePath & filename)
 268 {
 269   return TRUE;
 270 }
 271
 272
 273 BOOL PSoundChannel::StartRecording()
 274 {
 275   return TRUE;
 276 }
 277
 278
 279 BOOL PSoundChannel::IsRecordBufferFull()
 280 {
 281   return TRUE;
 282 }
 283
 284
 285 BOOL PSoundChannel::AreAllRecordBuffersFull()
 286 {
 287   return TRUE;
 288 }
 289
 290
 291 BOOL PSoundChannel::WaitForRecordBufferFull()
 292 {
 293   if (os_handle < 0) {
 294     return FALSE;
 295   }
 296
 297   return PXSetIOBlock(PXReadBlock, readTimeout);
 298 }
 299
 300
 301 BOOL PSoundChannel::WaitForAllRecordBuffersFull()
 302 {
 303   return FALSE;
 304 }
 305
 306
 307 BOOL PSoundChannel::Abort()
 308 {
 309   return TRUE;
 310 }
 311
 312 BOOL PSoundChannel::SetVolume(unsigned newVolume)
 313 {
 314   return FALSE;
 315 }
 316
 317 BOOL  PSoundChannel::GetVolume(unsigned & volume)
 318 {
 319   return FALSE;
 320 }
 321
 322
 323 // End of file
 324