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