开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
sound.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：31k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

sound.cxx：源码内容
  1. /*
  2.  * sound.cxx
  3.  *
  4.  * Implementation of sound classes for Win32
  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: sound.cxx,v $
  30.  * Revision 1.15  2000/07/04 04:30:47  robertj
  31.  * Fixed shutdown issues with buffers in use, again.
  32.  *
  33.  * Revision 1.14  2000/07/01 09:39:31  robertj
  34.  * Fixed shutdown issues with buffers in use.
  35.  *
  36.  * Revision 1.13  2000/06/29 00:39:29  robertj
  37.  * Fixed bug when PWaveFormat is assigned to itself.
  38.  *
  39.  * Revision 1.12  2000/05/22 07:17:50  robertj
  40.  * Fixed missing initialisation of format data block in Win32 PSound::Load().
  41.  *
  42.  * Revision 1.11  2000/05/01 05:59:11  robertj
  43.  * Added mutex to PSoundChannel buffer structure.
  44.  *
  45.  * Revision 1.10  2000/03/04 10:15:32  robertj
  46.  * Added simple play functions for sound files.
  47.  *
  48.  * Revision 1.9  2000/02/17 11:33:33  robertj
  49.  * Changed PSoundChannel::Write so blocks instead of error if no buffers available.
  50.  *
  51.  * Revision 1.8  1999/10/09 01:22:07  robertj
  52.  * Fixed error display for sound channels.
  53.  *
  54.  * Revision 1.7  1999/09/23 04:28:44  robertj
  55.  * Allowed some Win32 only access to wave format in sound channel
  56.  *
  57.  * Revision 1.6  1999/07/08 08:39:53  robertj
  58.  * Fixed bug when breaking block by closing the PSoundChannel in other thread.
  59.  *
  60.  * Revision 1.5  1999/06/24 14:01:25  robertj
  61.  * Fixed bug in not returning correct default recorder (waveIn) device.
  62.  *
  63.  * Revision 1.4  1999/06/07 01:36:28  robertj
  64.  * Fixed incorrect;ly set block alignment in sound structure.
  65.  *
  66.  * Revision 1.3  1999/05/28 14:04:51  robertj
  67.  * Added function to get default audio device.
  68.  *
  69.  * Revision 1.2  1999/02/22 10:15:15  robertj
  70.  * Sound driver interface implementation to Linux OSS specification.
  71.  *
  72.  * Revision 1.1  1999/02/16 06:02:07  robertj
  73.  * Major implementation to Linux OSS model
  74.  *
  75.  */
  77. #include <ptlib.h>
  78. #include <mmsystem.h>
  79. #include <process.h>
  82. class PMultiMediaFile
  83. {
  84.   public:
  85.     PMultiMediaFile();
  86.     ~PMultiMediaFile();
  88.     BOOL CreateWaveFile(const PFilePath & filename,
  89.                         const PWaveFormat & waveFormat,
  90.                         DWORD dataSize);
  91.     BOOL OpenWaveFile(const PFilePath & filename,
  92.                       PWaveFormat & waveFormat,
  93.                       DWORD & dataSize);
  95.     BOOL Open(const PFilePath & filename, DWORD dwOpenFlags, LPMMIOINFO lpmmioinfo = NULL);
  96.     BOOL Close(UINT wFlags = 0);
  97.     BOOL Ascend(MMCKINFO & ckinfo, UINT wFlags = 0);
  98.     BOOL Descend(UINT wFlags, MMCKINFO & ckinfo, LPMMCKINFO lpckParent = NULL);
  99.     BOOL Read(void * data, PINDEX len);
  100.     BOOL CreateChunk(MMCKINFO & ckinfo, UINT wFlags = 0);
  101.     BOOL Write(const void * data, PINDEX len);
  103.     DWORD GetLastError() const { return dwLastError; }
  105.   protected:
  106.     HMMIO hmmio;
  107.     DWORD dwLastError;
  108. };
  111. #define new PNEW
  114. ///////////////////////////////////////////////////////////////////////////////
  116. PMultiMediaFile::PMultiMediaFile()
  117. {
  118.   hmmio = NULL;
  119. }
  122. PMultiMediaFile::~PMultiMediaFile()
  123. {
  124.   Close();
  125. }
  128. BOOL PMultiMediaFile::CreateWaveFile(const PFilePath & filename,
  129.                                      const PWaveFormat & waveFormat,
  130.                                      DWORD dataSize)
  131. {
  132.   if (!Open(filename, MMIO_CREATE|MMIO_WRITE))
  133.     return FALSE;
  135.   MMCKINFO mmChunk;
  136.   mmChunk.fccType = mmioFOURCC('W', 'A', 'V', 'E');
  137.   mmChunk.cksize = 4 + // Form type
  138.                    4 + sizeof(DWORD) + waveFormat.GetSize() + // fmt chunk
  139.                    4 + sizeof(DWORD) + dataSize;              // data chunk
  141.   // Create a RIFF chunk
  142.   if (!CreateChunk(mmChunk, MMIO_CREATERIFF))
  143.     return FALSE;
  145.   // Save the format sub-chunk
  146.   mmChunk.ckid = mmioFOURCC('f', 'm', 't', ' ');
  147.   mmChunk.cksize = waveFormat.GetSize();
  148.   if (!CreateChunk(mmChunk))
  149.     return FALSE;
  151.   if (!Write(waveFormat, waveFormat.GetSize()))
  152.     return FALSE;
  154.   // Save the data sub-chunk
  155.   mmChunk.ckid = mmioFOURCC('d', 'a', 't', 'a');
  156.   mmChunk.cksize = dataSize;
  157.   return CreateChunk(mmChunk);
  158. }
  161. BOOL PMultiMediaFile::OpenWaveFile(const PFilePath & filename,
  162.                                    PWaveFormat  & waveFormat,
  163.                                    DWORD & dataSize)
  164. {
  165.   // Open wave file
  166.   if (!Open(filename, MMIO_READ | MMIO_ALLOCBUF))
  167.     return FALSE;
  169.   MMCKINFO mmParentChunk, mmSubChunk;
  170.   dwLastError = MMSYSERR_NOERROR;
  172.   // Locate a 'RIFF' chunk with a 'WAVE' form type
  173.   mmParentChunk.fccType = mmioFOURCC('W', 'A', 'V', 'E');
  174.   if (!Descend(MMIO_FINDRIFF, mmParentChunk))
  175.     return FALSE;
  177.   // Find the format chunk
  178.   mmSubChunk.ckid = mmioFOURCC('f', 'm', 't', ' ');
  179.   if (!Descend(MMIO_FINDCHUNK, mmSubChunk, &mmParentChunk))
  180.     return FALSE;
  182.   // Get the size of the format chunk, allocate memory for it
  183.   if (!waveFormat.SetSize(mmSubChunk.cksize))
  184.     return FALSE;
  186.   // Read the format chunk
  187.   if (!Read(waveFormat.GetPointer(), waveFormat.GetSize()))
  188.     return FALSE;
  190.   // Ascend out of the format subchunk
  191.   Ascend(mmSubChunk);
  193.   // Find the data subchunk
  194.   mmSubChunk.ckid = mmioFOURCC('d', 'a', 't', 'a');
  195.   if (!Descend(MMIO_FINDCHUNK, mmSubChunk, &mmParentChunk))
  196.     return FALSE;
  198.   // Get the size of the data subchunk
  199.   if (mmSubChunk.cksize == 0) {
  200.     dwLastError = MMSYSERR_INVALPARAM;
  201.     return FALSE;
  202.   }
  204.   dataSize = mmSubChunk.cksize;
  205.   return TRUE;
  206. }
  209. BOOL PMultiMediaFile::Open(const PFilePath & filename,
  210.                           DWORD dwOpenFlags,
  211.                           LPMMIOINFO lpmmioinfo)
  212. {
  213.   MMIOINFO local_mmioinfo;
  214.   if (lpmmioinfo == NULL) {
  215.     lpmmioinfo = &local_mmioinfo;
  216.     memset(lpmmioinfo, 0, sizeof(local_mmioinfo));
  217.   }
  219.   hmmio = mmioOpen((char *)(const char *)filename, lpmmioinfo, dwOpenFlags);
  221.   dwLastError = lpmmioinfo->wErrorRet;
  223.   return hmmio != NULL;
  224. }
  227. BOOL PMultiMediaFile::Close(UINT wFlags)
  228. {
  229.   if (hmmio == NULL)
  230.     return FALSE;
  232.   mmioClose(hmmio, wFlags);
  233.   hmmio = NULL;
  234.   return TRUE;
  235. }
  238. BOOL PMultiMediaFile::Ascend(MMCKINFO & ckinfo, UINT wFlags)
  239. {
  240.   dwLastError = mmioAscend(hmmio, &ckinfo, wFlags);
  241.   return dwLastError == MMSYSERR_NOERROR;
  242. }
  245. BOOL PMultiMediaFile::Descend(UINT wFlags, MMCKINFO & ckinfo, LPMMCKINFO lpckParent)
  246. {
  247.   dwLastError = mmioDescend(hmmio, &ckinfo, lpckParent, wFlags);
  248.   return dwLastError == MMSYSERR_NOERROR;
  249. }
  252. BOOL PMultiMediaFile::Read(void * data, PINDEX len)
  253. {
  254.   return mmioRead(hmmio, (char *)data, len) == len;
  255. }
  258. BOOL PMultiMediaFile::CreateChunk(MMCKINFO & ckinfo, UINT wFlags)
  259. {
  260.   dwLastError = mmioCreateChunk(hmmio, &ckinfo, wFlags);
  261.   return dwLastError == MMSYSERR_NOERROR;
  262. }
  265. BOOL PMultiMediaFile::Write(const void * data, PINDEX len)
  266. {
  267.   return mmioWrite(hmmio, (char *)data, len) == len;
  268. }
  271. ///////////////////////////////////////////////////////////////////////////////
  273. PWaveFormat::PWaveFormat()
  274. {
  275.   size = 0;
  276.   waveFormat = NULL;
  277. }
  280. PWaveFormat::~PWaveFormat()
  281. {
  282.   if (waveFormat != NULL)
  283.     free(waveFormat);
  284. }
  287. PWaveFormat::PWaveFormat(const PWaveFormat & fmt)
  288. {
  289.   size = fmt.size;
  290.   waveFormat = (WAVEFORMATEX *)malloc(size);
  291.   PAssert(waveFormat != NULL, POutOfMemory);
  293.   memcpy(waveFormat, fmt.waveFormat, size);
  294. }
  297. PWaveFormat & PWaveFormat::operator=(const PWaveFormat & fmt)
  298. {
  299.   if (this == &fmt)
  300.     return *this;
  302.   if (waveFormat != NULL)
  303.     free(waveFormat);
  305.   size = fmt.size;
  306.   waveFormat = (WAVEFORMATEX *)malloc(size);
  307.   PAssert(waveFormat != NULL, POutOfMemory);
  309.   memcpy(waveFormat, fmt.waveFormat, size);
  310.   return *this;
  311. }
  314. void PWaveFormat::PrintOn(ostream & out) const
  315. {
  316.   if (waveFormat == NULL)
  317.     out << "<null>";
  318.   else {
  319.     out << waveFormat->wFormatTag << ','
  320.         << waveFormat->nChannels << ','
  321.         << waveFormat->nSamplesPerSec << ','
  322.         << waveFormat->nAvgBytesPerSec << ','
  323.         << waveFormat->nBlockAlign << ','
  324.         << waveFormat->wBitsPerSample;
  325.     if (waveFormat->cbSize > 0) {
  326.       out << hex << setfill('0');
  327.       const BYTE * ptr = (const BYTE *)&waveFormat[1];
  328.       for (PINDEX i = 0; i < waveFormat->cbSize; i++)
  329.         out << ',' << setw(2) << (unsigned)*ptr++;
  330.       out << dec << setfill(' ');
  331.     }
  332.   }
  333. }
  336. void PWaveFormat::ReadFrom(istream &)
  337. {
  338. }
  341. void PWaveFormat::SetFormat(unsigned numChannels,
  342.                             unsigned sampleRate,
  343.                             unsigned bitsPerSample)
  344. {
  345.   PAssert(numChannels == 1 || numChannels == 2, PInvalidParameter);
  346.   PAssert(bitsPerSample == 8 || bitsPerSample == 16, PInvalidParameter);
  348.   if (waveFormat != NULL)
  349.     free(waveFormat);
  351.   size = sizeof(WAVEFORMATEX);
  352.   waveFormat = (WAVEFORMATEX *)malloc(sizeof(WAVEFORMATEX));
  353.   PAssert(waveFormat != NULL, POutOfMemory);
  355.   waveFormat->wFormatTag = WAVE_FORMAT_PCM;
  356.   waveFormat->nChannels = (WORD)numChannels;
  357.   waveFormat->nSamplesPerSec = sampleRate;
  358.   waveFormat->wBitsPerSample = (WORD)bitsPerSample;
  359.   waveFormat->nBlockAlign = (WORD)(numChannels*(bitsPerSample+7)/8);
  360.   waveFormat->nAvgBytesPerSec = waveFormat->nSamplesPerSec*waveFormat->nBlockAlign;
  361.   waveFormat->cbSize = 0;
  362. }
  365. void PWaveFormat::SetFormat(const void * data, PINDEX size)
  366. {
  367.   SetSize(size);
  368.   memcpy(waveFormat, data, size);
  369. }
  372. BOOL PWaveFormat::SetSize(PINDEX sz)
  373. {
  374.   if (waveFormat != NULL)
  375.     free(waveFormat);
  377.   size = sz;
  378.   if (sz == 0)
  379.     waveFormat = NULL;
  380.   else {
  381.     waveFormat = (WAVEFORMATEX *)calloc(sz, 1);
  382.     waveFormat->cbSize = (WORD)(sz - sizeof(WAVEFORMATEX));
  383.   }
  385.   return waveFormat != NULL;
  386. }
  389. ///////////////////////////////////////////////////////////////////////////////
  391. PSound::PSound(unsigned channels,
  392.                unsigned samplesPerSecond,
  393.                unsigned bitsPerSample,
  394.                PINDEX   bufferSize,
  395.                const BYTE * buffer)
  396. {
  397.   encoding = 0;
  398.   numChannels = channels;
  399.   sampleRate = samplesPerSecond;
  400.   sampleSize = bitsPerSample;
  401.   SetSize(bufferSize);
  402.   if (buffer != NULL)
  403.     memcpy(GetPointer(), buffer, bufferSize);
  404. }
  407. PSound::PSound(const PFilePath & filename)
  408. {
  409.   encoding = 0;
  410.   numChannels = 1;
  411.   sampleRate = 8000;
  412.   sampleSize = 16;
  413.   Load(filename);
  414. }
  417. PSound & PSound::operator=(const PBYTEArray & data)
  418. {
  419.   PBYTEArray::operator=(data);
  420.   return *this;
  421. }
  424. void PSound::SetFormat(unsigned channels,
  425.                        unsigned samplesPerSecond,
  426.                        unsigned bitsPerSample)
  427. {
  428.   encoding = 0;
  429.   numChannels = channels;
  430.   sampleRate = samplesPerSecond;
  431.   sampleSize = bitsPerSample;
  432.   formatInfo.SetSize(0);
  433. }
  436. BOOL PSound::Load(const PFilePath & filename)
  437. {
  438.   // Open wave file
  439.   PMultiMediaFile mmio;
  440.   PWaveFormat waveFormat;
  441.   DWORD dataSize;
  442.   if (!mmio.OpenWaveFile(filename, waveFormat, dataSize)) {
  443.     dwLastError = mmio.GetLastError();
  444.     return FALSE;
  445.   }
  447.   encoding = waveFormat->wFormatTag;
  448.   numChannels = waveFormat->nChannels;
  449.   sampleRate = waveFormat->nSamplesPerSec;
  450.   sampleSize = waveFormat->wBitsPerSample;
  452.   if (encoding != 0) {
  453.     PINDEX formatSize = waveFormat->cbSize + sizeof(WAVEFORMATEX);
  454.     memcpy(formatInfo.GetPointer(formatSize), waveFormat, formatSize);
  455.   }
  457.   // Allocate and lock memory for the waveform data.
  458.   if (!SetSize(dataSize)) {
  459.     dwLastError = MMSYSERR_NOMEM;
  460.     return FALSE;
  461.   }
  463.   // Read the waveform data subchunk
  464.   if (!mmio.Read(GetPointer(), GetSize())) {
  465.     dwLastError = mmio.GetLastError();
  466.     return FALSE;
  467.   }
  469.   return TRUE;
  470. }
  473. BOOL PSound::Save(const PFilePath & filename)
  474. {
  475.   PWaveFormat waveFormat;
  476.   if (encoding == 0)
  477.     waveFormat.SetFormat(numChannels, sampleRate, sampleSize);
  478.   else {
  479.     waveFormat.SetSize(GetFormatInfoSize());
  480.     memcpy(waveFormat.GetPointer(), GetFormatInfoData(), GetFormatInfoSize());
  481.   }
  483.   // Open wave file
  484.   PMultiMediaFile mmio;
  485.   if (!mmio.CreateWaveFile(filename, waveFormat, GetSize())) {
  486.     dwLastError = mmio.GetLastError();
  487.     return FALSE;
  488.   }
  490.   if (!mmio.Write(GetPointer(), GetSize())) {
  491.     dwLastError = mmio.GetLastError();
  492.     return FALSE;
  493.   }
  495.   return TRUE;
  496. }
  499. BOOL PSound::Play()
  500. {
  501.   PSoundChannel channel(PSoundChannel::GetDefaultDevice(PSoundChannel::Player),
  502.                         PSoundChannel::Player);
  503.   if (!channel.IsOpen())
  504.     return FALSE;
  506.   return channel.PlaySound(*this, TRUE);
  507. }
  510. BOOL PSound::PlayFile(const PFilePath & file, BOOL wait)
  511. {
  512.   return ::PlaySound(file, NULL, SND_FILENAME|(wait ? SND_SYNC : SND_ASYNC));
  513. }
  516. ///////////////////////////////////////////////////////////////////////////////
  518. PWaveBuffer::PWaveBuffer(PINDEX sz)
  519.  : PBYTEArray(sz)
  520. {
  521.   hWaveOut = NULL;
  522.   hWaveIn = NULL;
  523.   header.dwFlags = WHDR_DONE;
  524. }
  527. PWaveBuffer::~PWaveBuffer()
  528. {
  529.   Release();
  530. }
  533. PWaveBuffer & PWaveBuffer::operator=(const PSound & sound)
  534. {
  535.   PBYTEArray::operator=(sound);
  536.   return *this;
  537. }
  540. void PWaveBuffer::PrepareCommon(PINDEX count)
  541. {
  542.   Release();
  544.   memset(&header, 0, sizeof(header));
  545.   header.lpData = (char *)GetPointer();
  546.   header.dwBufferLength = count;
  547.   header.dwUser = (DWORD)this;
  548. }
  551. DWORD PWaveBuffer::Prepare(HWAVEOUT hOut, PINDEX & count)
  552. {
  553.   // Set up WAVEHDR structure and prepare it to be written to wave device
  554.   if (count > GetSize())
  555.     count = GetSize();
  557.   PrepareCommon(count);
  558.   hWaveOut = hOut;
  559.   return waveOutPrepareHeader(hWaveOut, &header, sizeof(header));
  560. }
  563. DWORD PWaveBuffer::Prepare(HWAVEIN hIn)
  564. {
  565.   // Set up WAVEHDR structure and prepare it to be read from wave device
  566.   PrepareCommon(GetSize());
  567.   hWaveIn = hIn;
  568.   return waveInPrepareHeader(hWaveIn, &header, sizeof(header));
  569. }
  572. DWORD PWaveBuffer::Release()
  573. {
  574.   DWORD err = MMSYSERR_NOERROR;
  576.   // There seems to be some pathalogical cases where on an Abort() call the buffers
  577.   // still are "in use", even though waveOutReset() was called. So wait until the
  578.   // sound driver has finished with the buffer before releasing it.
  580.   if (hWaveOut != NULL) {
  581.     if ((err = waveOutUnprepareHeader(hWaveOut, &header, sizeof(header))) == WAVERR_STILLPLAYING)
  582.       return err;
  583.     hWaveOut = NULL;
  584.   }
  586.   if (hWaveIn != NULL) {
  587.     if ((err = waveInUnprepareHeader(hWaveIn, &header, sizeof(header))) == WAVERR_STILLPLAYING)
  588.       return err;
  589.     hWaveIn = NULL;
  590.   }
  592.   header.dwFlags |= WHDR_DONE;
  593.   return err;
  594. }
  597. ///////////////////////////////////////////////////////////////////////////////
  599. PSoundChannel::PSoundChannel()
  600. {
  601.   Construct();
  602. }
  605. PSoundChannel::PSoundChannel(const PString & device,
  606.                              Directions dir,
  607.                              unsigned numChannels,
  608.                              unsigned sampleRate,
  609.                              unsigned bitsPerSample)
  610. {
  611.   Construct();
  612.   Open(device, dir, numChannels, sampleRate, bitsPerSample);
  613. }
  616. void PSoundChannel::Construct()
  617. {
  618.   direction = Player;
  619.   hWaveOut = NULL;
  620.   hWaveIn = NULL;
  621.   hEventDone = CreateEvent(NULL, FALSE, FALSE, NULL);
  623.   waveFormat.SetFormat(1, 8000, 16);
  625.   bufferByteOffset = P_MAX_INDEX;
  627.   SetBuffers(32768, 2);
  628. }
  631. PSoundChannel::~PSoundChannel()
  632. {
  633.   Close();
  635.   if (hEventDone != NULL)
  636.     DeleteObject(hEventDone);
  637. }
  640. PString PSoundChannel::GetName() const
  641. {
  642.   return deviceName;
  643. }
  646. PStringArray PSoundChannel::GetDeviceNames(Directions dir)
  647. {
  648.   PStringArray array;
  650.   unsigned numDevs, id;
  652.   switch (dir) {
  653.     case Player :
  654.       numDevs = waveOutGetNumDevs();
  655.       for (id = 0; id < numDevs; id++) {
  656.         WAVEOUTCAPS caps;
  657.         if (waveOutGetDevCaps(id, &caps, sizeof(caps)) == 0)
  658.           array[array.GetSize()] = caps.szPname;
  659.       }
  660.       break;
  662.     case Recorder :
  663.       numDevs = waveInGetNumDevs();
  664.       for (id = 0; id < numDevs; id++) {
  665.         WAVEINCAPS caps;
  666.         if (waveInGetDevCaps(id, &caps, sizeof(caps)) == 0)
  667.           array[array.GetSize()] = caps.szPname;
  668.       }
  669.       break;
  670.   }
  672.   return array;
  673. }
  676. PString PSoundChannel::GetDefaultDevice(Directions dir)
  677. {
  678.   RegistryKey registry("HKEY_CURRENT_USER\Software\Microsoft\Multimedia\Sound Mapper",
  679.                        RegistryKey::ReadOnly);
  681.   PString str;
  683.   if (dir == Player) {
  684.     if (!registry.QueryValue("Playback", str)) {
  685.       WAVEOUTCAPS caps;
  686.       if (waveOutGetDevCaps(0, &caps, sizeof(caps)) == 0)
  687.         str = caps.szPname;
  688.     }
  689.   }
  690.   else {
  691.     if (!registry.QueryValue("Record", str)) {
  692.       WAVEINCAPS caps;
  693.       if (waveInGetDevCaps(0, &caps, sizeof(caps)) == 0)
  694.         str = caps.szPname;
  695.     }
  696.   }
  698.   return str;
  699. }
  702. BOOL PSoundChannel::Open(const PString & device,
  703.                          Directions dir,
  704.                          unsigned numChannels,
  705.                          unsigned sampleRate,
  706.                          unsigned bitsPerSample)
  707. {
  708.   Close();
  710.   BOOL bad = TRUE;
  711.   unsigned id = 0;
  713.   if (device[0] == '#') {
  714.     id = device.Mid(1).AsUnsigned();
  715.     switch (dir) {
  716.       case Player :
  717.         if (id < waveOutGetNumDevs()) {
  718.           WAVEOUTCAPS caps;
  719.           osError = waveOutGetDevCaps(id, &caps, sizeof(caps));
  720.           if (osError == 0) {
  721.             deviceName = caps.szPname;
  722.             bad = FALSE;
  723.           }
  724.         }
  725.         break;
  727.       case Recorder :
  728.         if (id < waveInGetNumDevs()) {
  729.           WAVEINCAPS caps;
  730.           osError = waveInGetDevCaps(id, &caps, sizeof(caps));
  731.           if (osError == 0) {
  732.             deviceName = caps.szPname;
  733.             bad = FALSE;
  734.           }
  735.         }
  736.         break;
  737.     }
  738.   }
  739.   else {
  740.     switch (dir) {
  741.       case Player :
  742.         for (id = 0; id < waveOutGetNumDevs(); id++) {
  743.           WAVEOUTCAPS caps;
  744.           osError = waveOutGetDevCaps(id, &caps, sizeof(caps));
  745.           if (osError == 0 && stricmp(caps.szPname, device) == 0) {
  746.             deviceName = caps.szPname;
  747.             bad = FALSE;
  748.             break;
  749.           }
  750.         }
  751.         break;
  753.       case Recorder :
  754.         for (id = 0; id < waveInGetNumDevs(); id++) {
  755.           WAVEINCAPS caps;
  756.           osError = waveInGetDevCaps(id, &caps, sizeof(caps));
  757.           if (osError == 0 && stricmp(caps.szPname, device) == 0) {
  758.             deviceName = caps.szPname;
  759.             bad = FALSE;
  760.             break;
  761.           }
  762.         }
  763.         break;
  764.     }
  765.   }
  767.   if (bad) {
  768.     osError = MMSYSERR_BADDEVICEID;
  769.     return FALSE;
  770.   }
  772.   waveFormat.SetFormat(numChannels, sampleRate, bitsPerSample);
  774.   direction = dir;
  775.   return OpenDevice(id);
  776. }
  779. BOOL PSoundChannel::OpenDevice(unsigned id)
  780. {
  781.   Close();
  783.   PWaitAndSignal mutex(bufferMutex);
  785.   bufferByteOffset = P_MAX_INDEX;
  786.   bufferIndex = 0;
  788.   switch (direction) {
  789.     case Player :
  790.       osError = waveOutOpen(&hWaveOut, id, waveFormat,
  791.                             (DWORD)hEventDone, 0, CALLBACK_EVENT);
  792.       break;
  794.     case Recorder :
  795.       osError = waveInOpen(&hWaveIn, id, waveFormat,
  796.                            (DWORD)hEventDone, 0, CALLBACK_EVENT);
  797.       break;
  798.   }
  800.   if (osError != MMSYSERR_NOERROR)
  801.     return FALSE;
  803.   os_handle = id;
  804.   return TRUE;
  805. }
  808. BOOL PSoundChannel::SetFormat(unsigned numChannels,
  809.                               unsigned sampleRate,
  810.                               unsigned bitsPerSample)
  811. {
  812.   Abort();
  814.   waveFormat.SetFormat(numChannels, sampleRate, bitsPerSample);
  816.   return OpenDevice(os_handle);
  817. }
  820. BOOL PSoundChannel::SetFormat(const PWaveFormat & format)
  821. {
  822.   Abort();
  824.   waveFormat = format;
  826.   return OpenDevice(os_handle);
  827. }
  830. BOOL PSoundChannel::Close()
  831. {
  832.   if (!IsOpen())
  833.     return FALSE;
  835.   Abort();
  837.   if (hWaveOut != NULL) {
  838.     while ((osError = waveOutClose(hWaveOut)) == WAVERR_STILLPLAYING)
  839.       waveOutReset(hWaveOut);
  840.     hWaveOut = NULL;
  841.   }
  843.   if (hWaveIn != NULL) {
  844.     while ((osError = waveInClose(hWaveIn)) == WAVERR_STILLPLAYING)
  845.       waveInReset(hWaveIn);
  846.     hWaveIn = NULL;
  847.   }
  849.   Abort();
  851.   os_handle = -1;
  852.   return TRUE;
  853. }
  856. BOOL PSoundChannel::SetBuffers(PINDEX size, PINDEX count)
  857. {
  858.   Abort();
  860.   PAssert(size > 0 && count > 0, PInvalidParameter);
  862.   BOOL ok = TRUE;
  864.   PWaitAndSignal mutex(bufferMutex);
  866.   if (!buffers.SetSize(count))
  867.     ok = FALSE;
  868.   else {
  869.     for (PINDEX i = 0; i < count; i++) {
  870.       if (buffers.GetAt(i) == NULL)
  871.         buffers.SetAt(i, new PWaveBuffer(size));
  872.       if (!buffers[i].SetSize(size))
  873.         ok = FALSE;
  874.     }
  875.   }
  877.   bufferByteOffset = P_MAX_INDEX;
  878.   bufferIndex = 0;
  880.   return ok;
  881. }
  884. BOOL PSoundChannel::GetBuffers(PINDEX & size, PINDEX & count)
  885. {
  886.   PWaitAndSignal mutex(bufferMutex);
  888.   count = buffers.GetSize();
  890.   if (count == 0)
  891.     size = 0;
  892.   else
  893.     size = buffers[0].GetSize();
  895.   return TRUE;
  896. }
  899. BOOL PSoundChannel::Write(const void * data, PINDEX size)
  900. {
  901.   lastWriteCount = 0;
  903.   if (hWaveOut == NULL) {
  904.     osError = MMSYSERR_NOTSUPPORTED;
  905.     return FALSE;
  906.   }
  908.   const BYTE * ptr = (const BYTE *)data;
  910.   bufferMutex.Wait();
  912.   while (size > 0) {
  913.     PWaveBuffer & buffer = buffers[bufferIndex];
  914.     while ((buffer.header.dwFlags&WHDR_DONE) == 0) {
  915.       bufferMutex.Signal();
  916.       // No free buffers, so wait for one
  917.       if (WaitForSingleObject(hEventDone, INFINITE) != WAIT_OBJECT_0) {
  918.         osError = MMSYSERR_ERROR;
  919.         return FALSE; // No free buffers
  920.       }
  921.       bufferMutex.Wait();
  922.     }
  924.     // Can't write more than a buffer full
  925.     PINDEX count = size;
  926.     if ((osError = buffer.Prepare(hWaveOut, count)) != MMSYSERR_NOERROR)
  927.       break;
  929.     memcpy(buffer.GetPointer(), data, count);
  931.     if ((osError = waveOutWrite(hWaveOut, &buffer.header, sizeof(WAVEHDR))) != MMSYSERR_NOERROR)
  932.       break;
  934.     bufferIndex = (bufferIndex+1)%buffers.GetSize();
  935.     lastWriteCount += count;
  936.     size -= count;
  937.     ptr += count;
  938.   }
  940.   bufferMutex.Signal();
  942.   return size == 0;
  943. }
  946. BOOL PSoundChannel::PlaySound(const PSound & sound, BOOL wait)
  947. {
  948.   Abort();
  950.   BOOL ok = FALSE;
  952.   PINDEX bufferSize;
  953.   PINDEX bufferCount;
  954.   GetBuffers(bufferSize, bufferCount);
  956.   unsigned numChannels = waveFormat->nChannels;
  957.   unsigned sampleRate = waveFormat->nSamplesPerSec;
  958.   unsigned bitsPerSample = waveFormat->wBitsPerSample;
  959.   if (sound.GetEncoding() == 0)
  960.     ok = SetFormat(sound.GetChannels(), sound.GetSampleRate(), sound.GetSampleSize());
  961.   else {
  962.     waveFormat.SetFormat(sound.GetFormatInfoData(), sound.GetFormatInfoSize());
  963.     ok = OpenDevice(os_handle);
  964.   }
  966.   if (ok) {
  967.     bufferMutex.Wait();
  969.     // To avoid lots of copying of sound data, we fake the PSound buffer into
  970.     // the internal buffers and play directly from the PSound object.
  971.     buffers.SetSize(1);
  972.     PWaveBuffer & buffer = buffers[0];
  973.     buffer = sound;
  975.     PINDEX count = sound.GetSize();
  976.     if ((osError = buffer.Prepare(hWaveOut, count)) == MMSYSERR_NOERROR &&
  977.         (osError = waveOutWrite(hWaveOut, &buffer.header, sizeof(WAVEHDR))) == MMSYSERR_NOERROR) {
  978.       if (wait)
  979.         ok = WaitForPlayCompletion();
  980.     }
  981.     else
  982.       ok = FALSE;
  984.     bufferMutex.Signal();
  985.   }
  987.   SetFormat(numChannels, sampleRate, bitsPerSample);
  988.   SetBuffers(bufferSize, bufferCount);
  989.   return ok;
  990. }
  993. BOOL PSoundChannel::PlayFile(const PFilePath & filename, BOOL wait)
  994. {
  995.   Abort();
  997.   PMultiMediaFile mmio;
  998.   PWaveFormat fileFormat;
  999.   DWORD dataSize;
  1000.   if (!mmio.OpenWaveFile(filename, fileFormat, dataSize)) {
  1001.     osError = mmio.GetLastError();
  1002.     return FALSE;
  1003.   }
  1005.   // Save old format and set to one loaded from file.
  1006.   unsigned numChannels = waveFormat->nChannels;
  1007.   unsigned sampleRate = waveFormat->nSamplesPerSec;
  1008.   unsigned bitsPerSample = waveFormat->wBitsPerSample;
  1009.   waveFormat = fileFormat;
  1010.   if (!OpenDevice(os_handle)) {
  1011.     SetFormat(numChannels, sampleRate, bitsPerSample);
  1012.     return FALSE;
  1013.   }
  1015.   bufferMutex.Wait();
  1017.   while (dataSize > 0) {
  1018.     PWaveBuffer & buffer = buffers[bufferIndex];
  1019.     while ((buffer.header.dwFlags&WHDR_DONE) == 0) {
  1020.       bufferMutex.Signal();
  1021.       // No free buffers, so wait for one
  1022.       if (WaitForSingleObject(hEventDone, INFINITE) != WAIT_OBJECT_0) {
  1023.         SetFormat(numChannels, sampleRate, bitsPerSample);
  1024.         return FALSE;
  1025.       }
  1026.       bufferMutex.Wait();
  1027.     }
  1029.     // Can't write more than a buffer full
  1030.     PINDEX count = dataSize;
  1031.     if ((osError = buffer.Prepare(hWaveOut, count)) != MMSYSERR_NOERROR)
  1032.       break;
  1034.     // Read the waveform data subchunk
  1035.     if (!mmio.Read(buffer.GetPointer(), count)) {
  1036.       osError = mmio.GetLastError();
  1037.       break;
  1038.     }
  1040.     if ((osError = waveOutWrite(hWaveOut, &buffer.header, sizeof(WAVEHDR))) != MMSYSERR_NOERROR)
  1041.       break;
  1043.     bufferIndex = (bufferIndex+1)%buffers.GetSize();
  1044.     dataSize -= count;
  1045.   }
  1047.   bufferMutex.Signal();
  1049.   if (dataSize == 0 && wait)
  1050.     WaitForPlayCompletion();
  1052.   SetFormat(numChannels, sampleRate, bitsPerSample);
  1053.   return TRUE;
  1054. }
  1057. BOOL PSoundChannel::HasPlayCompleted()
  1058. {
  1059.   PWaitAndSignal mutex(bufferMutex);
  1061.   for (PINDEX i = 0; i < buffers.GetSize(); i++) {
  1062.     if ((buffers[i].header.dwFlags&WHDR_DONE) == 0)
  1063.       return FALSE;
  1064.   }
  1066.   return TRUE;
  1067. }
  1070. BOOL PSoundChannel::WaitForPlayCompletion()
  1071. {
  1072.   while (!HasPlayCompleted()) {
  1073.     if (WaitForSingleObject(hEventDone, INFINITE) != WAIT_OBJECT_0)
  1074.       return FALSE;
  1075.   }
  1077.   return TRUE;
  1078. }
  1081. BOOL PSoundChannel::StartRecording()
  1082. {
  1083.   PWaitAndSignal mutex(bufferMutex);
  1085.   // See if has started already.
  1086.   if (bufferByteOffset != P_MAX_INDEX)
  1087.     return TRUE;
  1089.   // Start the first read, queue all the buffers
  1090.   for (PINDEX i = 0; i < buffers.GetSize(); i++) {
  1091.     PWaveBuffer & buffer = buffers[i];
  1092.     if ((osError = buffer.Prepare(hWaveIn)) != MMSYSERR_NOERROR)
  1093.       return FALSE;
  1094.     if ((osError = waveInAddBuffer(hWaveIn, &buffer.header, sizeof(WAVEHDR))) != MMSYSERR_NOERROR)
  1095.       return FALSE;
  1096.   }
  1098.   bufferByteOffset = 0;
  1100.   if ((osError = waveInStart(hWaveIn)) == MMSYSERR_NOERROR) // start recording
  1101.     return TRUE;
  1103.   bufferByteOffset = P_MAX_INDEX;
  1104.   return FALSE;
  1105. }
  1108. BOOL PSoundChannel::Read(void * data, PINDEX size)
  1109. {
  1110.   lastReadCount = 0;
  1112.   if (hWaveIn == NULL) {
  1113.     osError = MMSYSERR_NOTSUPPORTED;
  1114.     return FALSE;
  1115.   }
  1117.   if (!StartRecording())  // Start the first read, queue all the buffers
  1118.     return FALSE;
  1120.   if (!WaitForRecordBufferFull())
  1121.     return FALSE;
  1123.   PWaitAndSignal mutex(bufferMutex);
  1125.   PWaveBuffer & buffer = buffers[bufferIndex];
  1127.   PINDEX bytesRecorded = buffer.header.dwBytesRecorded;
  1128.   lastReadCount = bytesRecorded - bufferByteOffset;
  1129.   if (lastReadCount > size)
  1130.     lastReadCount = size;
  1132.   if (lastReadCount == 0 || bufferByteOffset == P_MAX_INDEX)
  1133.     return FALSE;
  1135.   memcpy(data, &buffer[bufferByteOffset], lastReadCount);
  1137.   bufferByteOffset += lastReadCount;
  1138.   if (bufferByteOffset >= buffer.GetSize()) {
  1139.     if ((osError = buffer.Prepare(hWaveIn)) != MMSYSERR_NOERROR)
  1140.       return FALSE;
  1141.     if ((osError = waveInAddBuffer(hWaveIn, &buffer.header, sizeof(WAVEHDR))) != MMSYSERR_NOERROR)
  1142.       return FALSE;
  1144.     bufferIndex = (bufferIndex+1)%buffers.GetSize();
  1145.     bufferByteOffset = 0;
  1146.   }
  1148.   return TRUE;
  1149. }
  1152. BOOL PSoundChannel::RecordSound(PSound & sound)
  1153. {
  1154.   if (!StartRecording())  // Start the first read, queue all the buffers
  1155.     return FALSE;
  1157.   if (!WaitForAllRecordBuffersFull())
  1158.     return FALSE;
  1160.   sound.SetFormat(waveFormat->nChannels,
  1161.                   waveFormat->nSamplesPerSec,
  1162.                   waveFormat->wBitsPerSample);
  1164.   PWaitAndSignal mutex(bufferMutex);
  1166.   if (buffers.GetSize() == 1 &&
  1167.           (PINDEX)buffers[0].header.dwBytesRecorded == buffers[0].GetSize())
  1168.     sound = buffers[0];
  1169.   else {
  1170.     PINDEX totalSize = 0;
  1171.     PINDEX i;
  1172.     for (i = 0; i < buffers.GetSize(); i++)
  1173.       totalSize += buffers[i].header.dwBytesRecorded;
  1175.     if (!sound.SetSize(totalSize)) {
  1176.       osError = MMSYSERR_NOMEM;
  1177.       return FALSE;
  1178.     }
  1180.     BYTE * ptr = sound.GetPointer();
  1181.     for (i = 0; i < buffers.GetSize(); i++) {
  1182.       PINDEX sz = buffers[i].header.dwBytesRecorded;
  1183.       memcpy(ptr, buffers[i], sz);
  1184.       ptr += sz;
  1185.     }
  1186.   }
  1188.   return TRUE;
  1189. }
  1192. BOOL PSoundChannel::RecordFile(const PFilePath & filename)
  1193. {
  1194.   if (!StartRecording())  // Start the first read, queue all the buffers
  1195.     return FALSE;
  1197.   if (!WaitForAllRecordBuffersFull())
  1198.     return FALSE;
  1200.   PWaitAndSignal mutex(bufferMutex);
  1202.   PINDEX dataSize = 0;
  1203.   PINDEX i;
  1204.   for (i = 0; i < buffers.GetSize(); i++)
  1205.     dataSize += buffers[i].header.dwBytesRecorded;
  1207.   PMultiMediaFile mmio;
  1208.   if (!mmio.CreateWaveFile(filename, waveFormat, dataSize)) {
  1209.     osError = mmio.GetLastError();
  1210.     return FALSE;
  1211.   }
  1213.   for (i = 0; i < buffers.GetSize(); i++) {
  1214.     if (!mmio.Write(buffers[i], buffers[i].header.dwBytesRecorded)) {
  1215.       osError = mmio.GetLastError();
  1216.       return FALSE;
  1217.     }
  1218.   }
  1220.   return TRUE;
  1221. }
  1224. BOOL PSoundChannel::IsRecordBufferFull()
  1225. {
  1226.   PWaitAndSignal mutex(bufferMutex);
  1228.   if (bufferByteOffset == P_MAX_INDEX)
  1229.     return TRUE;
  1231.   return (buffers[bufferIndex].header.dwFlags&WHDR_DONE) != 0;
  1232. }
  1235. BOOL PSoundChannel::AreAllRecordBuffersFull()
  1236. {
  1237.   PWaitAndSignal mutex(bufferMutex);
  1239.   if (bufferByteOffset == P_MAX_INDEX)
  1240.     return TRUE;
  1242.   for (PINDEX i = 0; i < buffers.GetSize(); i++) {
  1243.     if ((buffers[i].header.dwFlags&WHDR_DONE) == 0)
  1244.       return FALSE;
  1245.   }
  1247.   return TRUE;
  1248. }
  1251. BOOL PSoundChannel::WaitForRecordBufferFull()
  1252. {
  1253.   if (bufferByteOffset == P_MAX_INDEX)
  1254.     return FALSE;
  1256.   while (!IsRecordBufferFull()) {
  1257.     if (WaitForSingleObject(hEventDone, INFINITE) != WAIT_OBJECT_0)
  1258.       return FALSE;
  1259.   }
  1261.   return TRUE;
  1262. }
  1265. BOOL PSoundChannel::WaitForAllRecordBuffersFull()
  1266. {
  1267.   if (bufferByteOffset == P_MAX_INDEX)
  1268.     return FALSE;
  1270.   while (!AreAllRecordBuffersFull()) {
  1271.     if (WaitForSingleObject(hEventDone, INFINITE) != WAIT_OBJECT_0)
  1272.       return FALSE;
  1273.   }
  1275.   return TRUE;
  1276. }
  1279. BOOL PSoundChannel::Abort()
  1280. {
  1281.   if (hWaveOut != NULL)
  1282.     osError = waveOutReset(hWaveOut);
  1284.   if (hWaveIn != NULL)
  1285.     osError = waveInReset(hWaveIn);
  1287.   PWaitAndSignal mutex(bufferMutex);
  1289.   for (PINDEX i = 0; i < buffers.GetSize(); i++) {
  1290.     if (buffers[i].Release() == WAVERR_STILLPLAYING) {
  1291.       if (hWaveOut != NULL)
  1292.         waveOutReset(hWaveOut);
  1293.       if (hWaveIn != NULL)
  1294.         waveInReset(hWaveIn);
  1295.     }
  1296.   }
  1298.   bufferByteOffset = P_MAX_INDEX;
  1299.   bufferIndex = 0;
  1301.   return osError == MMSYSERR_NOERROR;
  1302. }
  1305. PString PSoundChannel::GetErrorText() const
  1306. {
  1307.   PString str;
  1309.   if (direction == Recorder) {
  1310.     if (waveInGetErrorText(osError, str.GetPointer(256), 256) != MMSYSERR_NOERROR)
  1311.       return PChannel::GetErrorText();
  1312.   }
  1313.   else {
  1314.     if (waveOutGetErrorText(osError, str.GetPointer(256), 256) != MMSYSERR_NOERROR)
  1315.       return PChannel::GetErrorText();
  1316.   }
  1318.   return str;
  1319. }
  1322. // End of File ///////////////////////////////////////////////////////////////