contrib/src/mmedia/sndwin.cpp

   1 // --------------------------------------------------------------------------
   2 // Name: sndwin.cpp
   3 // Purpose:
   4 // Date: 08/11/1999
   5 // Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 1999, 2000
   6 // CVSID: $Id$
   7 // --------------------------------------------------------------------------
   8 #ifdef __GNUG__
   9 #pragma implementation "sndwin.cpp"
  10 #endif
  11
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __WINDOWS__
  15
  16 #ifndef WX_PRECOMP
  17     #include "wx/defs.h"
  18     #include "wx/app.h"
  19     #include "wx/string.h"
  20 #endif
  21
  22 #include "wx/module.h"
  23 #include "wx/msw/private.h"
  24
  25 // -------------------------------------------------------------------------
  26 // MMedia headers
  27 // -------------------------------------------------------------------------
  28
  29 #include "wx/mmedia/sndbase.h"
  30 #include "wx/mmedia/sndwin.h"
  31 #include "wx/mmedia/sndpcm.h"
  32
  33 // -------------------------------------------------------------------------
  34 // System headers
  35 // -------------------------------------------------------------------------
  36
  37 #include <windows.h>
  38 #include <mmsystem.h>
  39
  40 // -------------------------------------------------------------------------
  41 // External definitions, forward, ...
  42 // -------------------------------------------------------------------------
  43
  44 typedef struct _wxSoundInternal wxSoundInternal;
  45 typedef struct _wxSoundInfoHeader wxSoundInfoHeader;
  46
  47 extern const wxChar *wxCanvasClassName;
  48
  49 wxList *wxSoundHandleList = NULL;
  50
  51 static inline wxSoundStreamWin *wxFindSoundFromHandle(WXHWND hWnd)
  52 {
  53   wxObjectList::compatibility_iterator node = wxSoundHandleList->Find((long)hWnd);
  54   if (!node)
  55     return NULL;
  56   return (wxSoundStreamWin *)node->GetData();
  57 }
  58
  59 struct _wxSoundInternal {
  60   HWND m_sndWin;
  61   HWAVEIN m_devin;
  62   HWAVEOUT m_devout;
  63   bool m_output_enabled, m_input_enabled;
  64 };
  65
  66 struct _wxSoundInfoHeader {
  67   HGLOBAL m_h_header, m_h_data;
  68   char *m_data;
  69   WAVEHDR *m_header;
  70   int m_mode;
  71   bool m_playing, m_recording;
  72   wxUint32 m_position, m_size;
  73
  74   wxSoundStreamWin *m_driver;
  75 };
  76
  77 #define WXSOUND_MAX_QUEUE 10
  78
  79 wxSoundStreamWin::wxSoundStreamWin()
  80 {
  81   wxSoundFormatPcm pcm;
  82
  83   m_production_started = false;
  84   m_internal = new wxSoundInternal;
  85   if (!m_internal) {
  86     m_snderror = wxSOUND_MEMERROR;
  87     m_internal = NULL;
  88     return;
  89   }
  90   m_snderror = wxSOUND_NOERROR;
  91
  92   // Setup defaults
  93   CreateSndWindow();
  94   SetSoundFormat(pcm);
  95
  96   m_internal->m_input_enabled = false;
  97   m_internal->m_output_enabled = false;
  98
  99   m_waiting_for = false;
 100
 101   if (!OpenDevice(wxSOUND_OUTPUT)) {
 102     m_snderror = wxSOUND_NOERROR; //next call to OpenDevice won't do this
 103     if (!OpenDevice(wxSOUND_INPUT))
 104       return;
 105   }
 106
 107   CloseDevice();
 108 }
 109
 110 wxSoundStreamWin::~wxSoundStreamWin()
 111 {
 112   if (m_internal) {
 113     if (m_production_started)
 114       StopProduction();
 115     DestroySndWindow();
 116
 117     delete m_internal;
 118   }
 119 }
 120
 121 // -----------------------------------------------------------------------
 122 // _wxSoundHandlerWndProc: Window callback to handle buffer completion
 123 // -----------------------------------------------------------------------
 124 LRESULT APIENTRY _EXPORT
 125
 126  _wxSoundHandlerWndProc(HWND hWnd, UINT message,
 127                  WPARAM wParam, LPARAM WXUNUSED(lParam))
 128 {
 129   wxSoundStreamWin *sndwin;
 130
 131   sndwin = wxFindSoundFromHandle((WXHWND)hWnd);
 132   if (!sndwin)
 133     return (LRESULT)0;
 134
 135   switch (message) {
 136   case MM_WOM_DONE:
 137     sndwin->NotifyDoneBuffer(wParam, wxSOUND_OUTPUT);
 138     break;
 139   case MM_WIM_DATA:
 140     sndwin->NotifyDoneBuffer(wParam, wxSOUND_INPUT);
 141     break;
 142   default:
 143     break;
 144   }
 145   return (LRESULT)0;
 146 }
 147
 148 // -----------------------------------------------------------------------
 149 // CreateSndWindow() creates an hidden window which will receive the sound
 150 // events
 151 // -----------------------------------------------------------------------
 152
 153 void wxSoundStreamWin::CreateSndWindow()
 154 {
 155   FARPROC proc = MakeProcInstance((FARPROC)_wxSoundHandlerWndProc,
 156                                   wxGetInstance());
 157   // NB: class name must be kept in sync with wxCanvasClassName in
 158   // src/msw/app.cpp!
 159   m_internal->m_sndWin = ::CreateWindow(wxT("wxWindowClass"), NULL, 0,
 160                     0, 0, 0, 0, NULL, (HMENU) NULL,
 161                                         wxGetInstance(), NULL);
 162
 163   GetLastError();
 164
 165   ::SetWindowLong(m_internal->m_sndWin, GWL_WNDPROC, (LONG)proc);
 166
 167   // Add this window to the sound handle list so we'll be able to redecode
 168   // the "magic" number.
 169   wxSoundHandleList->Append((long)m_internal->m_sndWin, (wxObject *)this);
 170 }
 171
 172 // -----------------------------------------------------------------------
 173 // DestroySndWindow() destroys the hidden window
 174 // -----------------------------------------------------------------------
 175
 176 void wxSoundStreamWin::DestroySndWindow()
 177 {
 178   if (m_internal->m_sndWin) {
 179     ::DestroyWindow(m_internal->m_sndWin);
 180     wxSoundHandleList->DeleteObject((wxObject *)this);
 181   }
 182 }
 183
 184 // -------------------------------------------------------------------------
 185 // OpenDevice(int mode) initializes the windows driver for a "mode"
 186 // operation. mode is a bit mask: if the bit "wxSOUND_OUTPUT" is set,
 187 // the driver is opened for output operation, and if the bit "wxSOUND_INPUT"
 188 // is set, then the driver is opened for input operation. The two modes
 189 // aren't exclusive.
 190 // The initialization parameters (sample rate, ...) are taken from the
 191 // m_sndformat object.
 192 // At the end, OpenDevice() calls AllocHeaders() to initialize the Sound IO
 193 // queue.
 194 // -------------------------------------------------------------------------
 195 bool wxSoundStreamWin::OpenDevice(int mode)
 196 {
 197   wxSoundFormatPcm *pcm;
 198   WAVEFORMATEX wformat;
 199
 200   if (!m_sndformat) {
 201     m_snderror = wxSOUND_INVFRMT;
 202     return false;
 203   }
 204
 205   pcm = (wxSoundFormatPcm *)m_sndformat;
 206
 207   wformat.wFormatTag      = WAVE_FORMAT_PCM;
 208   wformat.nChannels       = pcm->GetChannels();
 209   wformat.nBlockAlign     = wformat.nChannels * pcm->GetBPS() / 8;
 210   wformat.nSamplesPerSec  = pcm->GetSampleRate();
 211   wformat.nAvgBytesPerSec = wformat.nSamplesPerSec * wformat.nBlockAlign;
 212   wformat.wBitsPerSample  = pcm->GetBPS();
 213   wformat.cbSize          = 0;
 214
 215   // -----------------------------------
 216   // Open the driver for Output operation
 217   // -----------------------------------
 218   if (mode & wxSOUND_OUTPUT) {
 219     MMRESULT result;
 220
 221     result = waveOutOpen(&m_internal->m_devout,
 222                          WAVE_MAPPER, &wformat,
 223                          (DWORD)m_internal->m_sndWin, 0,
 224                          CALLBACK_WINDOW);
 225
 226     if (result != MMSYSERR_NOERROR) {
 227       m_snderror = wxSOUND_INVDEV;
 228       return false;
 229     }
 230
 231     m_output_frag_out  = WXSOUND_MAX_QUEUE-1;
 232     m_current_frag_out = 0;
 233
 234     m_internal->m_output_enabled = true;
 235   }
 236   // -----------------------------------
 237   // Open the driver for Input operation
 238   // -----------------------------------
 239   if (mode & wxSOUND_INPUT) {
 240     MMRESULT result;
 241
 242     result = waveInOpen(&m_internal->m_devin,
 243                         WAVE_MAPPER, &wformat,
 244                         (DWORD)m_internal->m_sndWin, 0,
 245                         CALLBACK_WINDOW);
 246
 247     if (result != MMSYSERR_NOERROR) {
 248       m_snderror = wxSOUND_INVDEV;
 249       return false;
 250     }
 251
 252     m_current_frag_in = WXSOUND_MAX_QUEUE-1;
 253     m_input_frag_in   = 0;
 254
 255     m_internal->m_input_enabled = true;
 256   }
 257
 258   if (mode & wxSOUND_OUTPUT) {
 259     if (!AllocHeaders(wxSOUND_OUTPUT)) {
 260       CloseDevice();
 261       return false;
 262     }
 263   }
 264   if (mode & wxSOUND_INPUT) {
 265     if (!AllocHeaders(wxSOUND_INPUT)) {
 266       CloseDevice();
 267       return false;
 268     }
 269   }
 270
 271   return true;
 272 }
 273
 274 // -------------------------------------------------------------------------
 275 // CloseDevice() closes the driver handles and frees memory allocated for
 276 // IO queues.
 277 // -------------------------------------------------------------------------
 278 void wxSoundStreamWin::CloseDevice()
 279 {
 280   if (m_internal->m_output_enabled) {
 281     FreeHeaders(wxSOUND_OUTPUT);
 282     m_internal->m_output_enabled = false;
 283     waveOutClose(m_internal->m_devout);
 284   }
 285
 286   if (m_internal->m_input_enabled) {
 287     FreeHeaders(wxSOUND_INPUT);
 288     m_internal->m_input_enabled  = false;
 289     waveInClose(m_internal->m_devin);
 290   }
 291 }
 292
 293 // -------------------------------------------------------------------------
 294 // AllocHeader(int mode)
 295 //
 296 // mode has the same mean as in OpenDevice() except that here the two flags
 297 // must be exclusive.
 298 // AllocHeader() initializes an element of an operation (this can be input
 299 // or output). It means it allocates the sound header's memory block
 300 // and "prepares" it (It is needed by Windows). At the same time, it sets
 301 // private datas so we can the header's owner (See callback).
 302 //
 303 // It returns the new allocated block or NULL.
 304 // -------------------------------------------------------------------------
 305 wxSoundInfoHeader *wxSoundStreamWin::AllocHeader(int mode)
 306 {
 307   wxSoundInfoHeader *info;
 308   WAVEHDR *header;
 309
 310   // Some memory allocation
 311   info = new wxSoundInfoHeader;
 312   info->m_h_data   = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, GetBestSize());
 313   info->m_h_header = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, sizeof(WAVEHDR));
 314   if (!info->m_h_data || !info->m_h_header) {
 315     delete info;
 316     m_snderror = wxSOUND_MEMERROR;
 317     return NULL;
 318   }
 319
 320   // Get the two pointers from the system
 321   info->m_data      = (char *)GlobalLock(info->m_h_data);
 322   info->m_header    = (WAVEHDR *)GlobalLock(info->m_h_header);
 323   // Set the header's mode
 324   info->m_mode      = mode;
 325   // Set the parent of the header
 326   info->m_driver    = this;
 327   // Clean it up
 328   ClearHeader(info);
 329
 330   header            = info->m_header;
 331   // Initialize Windows variables
 332   header->lpData         = info->m_data;
 333   header->dwBufferLength = GetBestSize();
 334   header->dwUser         = (DWORD)info;
 335   header->dwFlags        = WHDR_DONE;
 336
 337   // "Prepare" the header
 338   if (mode == wxSOUND_INPUT) {
 339     MMRESULT result;
 340
 341     result  = waveInPrepareHeader(m_internal->m_devin, header,
 342                                   sizeof(WAVEHDR));
 343
 344     if (result != MMSYSERR_NOERROR) {
 345       // If something goes wrong, free everything.
 346       GlobalUnlock(info->m_data);
 347       GlobalUnlock(info->m_header);
 348       GlobalFree(info->m_h_data);
 349       GlobalFree(info->m_h_header);
 350       delete info;
 351
 352       m_snderror = wxSOUND_IOERROR;
 353       return NULL;
 354     }
 355   } else if (mode == wxSOUND_OUTPUT) {
 356     MMRESULT result;
 357
 358     result  = waveOutPrepareHeader(m_internal->m_devout, header,
 359                                    sizeof(WAVEHDR));
 360
 361     if (result != MMSYSERR_NOERROR) {
 362       // If something goes wrong, free everything.
 363       GlobalUnlock(info->m_data);
 364       GlobalUnlock(info->m_header);
 365       GlobalFree(info->m_h_data);
 366       GlobalFree(info->m_h_header);
 367       delete info;
 368
 369       m_snderror = wxSOUND_IOERROR;
 370       return NULL;
 371     }
 372   }
 373   return info;
 374 }
 375
 376 // -------------------------------------------------------------------------
 377 // AllocHeaders(int mode)
 378 //
 379 // "mode" has the same mean as for OpenDevice() except that the two flags must
 380 // be exclusive.
 381 // AllocHeaders() allocates WXSOUND_MAX_QUEUE (= 128) blocks for an operation
 382 // queue. It uses AllocHeader() for each element.
 383 //
 384 // Once it has allocated all blocks, it returns true and if an error occured
 385 // it returns false.
 386 // -------------------------------------------------------------------------
 387 bool wxSoundStreamWin::AllocHeaders(int mode)
 388 {
 389   int i;
 390   wxSoundInfoHeader **headers;
 391
 392   if (mode == wxSOUND_OUTPUT)
 393     headers = m_headers_play = new wxSoundInfoHeader *[WXSOUND_MAX_QUEUE];
 394   else
 395     headers = m_headers_rec = new wxSoundInfoHeader *[WXSOUND_MAX_QUEUE];
 396
 397   memset(headers, 0, WXSOUND_MAX_QUEUE*sizeof(wxSoundInfoHeader *));
 398
 399   for (i=0;i<WXSOUND_MAX_QUEUE;i++) {
 400     headers[i] = AllocHeader(mode);
 401     if (!headers[i]) {
 402       FreeHeaders(mode);
 403       return false;
 404     }
 405   }
 406   return true;
 407 }
 408
 409 // -------------------------------------------------------------------------
 410 // FreeHeader(int mode)
 411 //
 412 // "mode" has the same mean as for OpenDevice() except that the two flags must
 413 // be exclusive.
 414 // FreeHeader() frees a memory block and "unprepares" it.
 415 // -------------------------------------------------------------------------
 416 void wxSoundStreamWin::FreeHeader(wxSoundInfoHeader *header, int mode)
 417 {
 418   if (mode == wxSOUND_OUTPUT)
 419     waveOutUnprepareHeader(m_internal->m_devout, header->m_header, sizeof(WAVEHDR));
 420   else
 421     waveInUnprepareHeader(m_internal->m_devin, header->m_header, sizeof(WAVEHDR));
 422
 423   GlobalUnlock(header->m_data);
 424   GlobalUnlock(header->m_header);
 425   GlobalFree(header->m_h_header);
 426   GlobalFree(header->m_h_data);
 427   delete header;
 428 }
 429
 430 // -------------------------------------------------------------------------
 431 // FreeHeaders(int mode)
 432 //
 433 // "mode" has the same mean as for OpenDevice() except that the two flags must
 434 // be exclusive.
 435 // FreeHeaders() frees all an operation queue once it has checked that
 436 // all buffers have been terminated.
 437 // -------------------------------------------------------------------------
 438 void wxSoundStreamWin::FreeHeaders(int mode)
 439 {
 440   int i;
 441   wxSoundInfoHeader ***headers;
 442
 443   if (mode == wxSOUND_OUTPUT)
 444     headers = &m_headers_play;
 445   else
 446     headers = &m_headers_rec;
 447
 448   for (i=0;i<WXSOUND_MAX_QUEUE;i++) {
 449     if ((*headers)[i]) {
 450       // We wait for the end of the buffer
 451       WaitFor((*headers)[i]);
 452       // Then, we free the header
 453       FreeHeader((*headers)[i], mode);
 454     }
 455   }
 456   delete[] (*headers);
 457   (*headers) = NULL;
 458 }
 459
 460 // -------------------------------------------------------------------------
 461 // WaitFor(wxSoundInfoHeader *info)
 462 //
 463 // "info" is one element of an IO queue
 464 // WaitFor() checks whether the specified block has been terminated.
 465 // If it hasn't been terminated, it waits for its termination.
 466 //
 467 // NB: if it's a partially filled buffer it adds it to the Windows queue
 468 // -------------------------------------------------------------------------
 469 void wxSoundStreamWin::WaitFor(wxSoundInfoHeader *info)
 470 {
 471     // If the buffer is finished, we return immediately
 472     if (!info->m_playing) {
 473
 474         // We begun filling it: we must send it to the Windows queue
 475         if (info->m_position != 0) {
 476             memset(info->m_data + info->m_position, 0, info->m_size);
 477             AddToQueue(info);
 478         }
 479     }
 480
 481     if (m_waiting_for) {
 482         // PROBLEM //
 483         return;
 484     }
 485     m_waiting_for = true;
 486     // Else, we wait for its termination
 487     while (info->m_playing || info->m_recording)
 488       wxYield();
 489     m_waiting_for = false;
 490 }
 491
 492 // -------------------------------------------------------------------------
 493 // AddToQueue(wxSoundInfoHeader *info)
 494 //
 495 // For "info", see WaitFor()
 496 // AddToQueue() sends the IO queue element to the Windows queue.
 497 //
 498 // Warning: in the current implementation, it partially assume we send the
 499 // element in the right order. This is true in that implementation but if
 500 // you use it elsewhere, be careful: it may shuffle all your sound datas.
 501 // -------------------------------------------------------------------------
 502 bool wxSoundStreamWin::AddToQueue(wxSoundInfoHeader *info)
 503 {
 504     MMRESULT result;
 505
 506     if (info->m_mode == wxSOUND_INPUT) {
 507         // Increment the input fragment pointer
 508         result = waveInAddBuffer(m_internal->m_devin,
 509                                  info->m_header, sizeof(WAVEHDR));
 510         if (result == MMSYSERR_NOERROR)
 511             info->m_recording = true;
 512         else
 513             return false;
 514     } else if (info->m_mode == wxSOUND_OUTPUT) {
 515         result = waveOutWrite(m_internal->m_devout,
 516                               info->m_header, sizeof(WAVEHDR));
 517         if (result == MMSYSERR_NOERROR)
 518       info->m_playing = true;
 519         else
 520             return false;
 521     }
 522     return true;
 523 }
 524
 525 // -------------------------------------------------------------------------
 526 // ClearHeader(wxSoundInfoHeader *info)
 527 //
 528 // ClearHeader() reinitializes the parameters of "info" to their default
 529 // value.
 530 // -------------------------------------------------------------------------
 531 void wxSoundStreamWin::ClearHeader(wxSoundInfoHeader *info)
 532 {
 533   info->m_playing   = false;
 534   info->m_recording = false;
 535   info->m_position  = 0;
 536   info->m_size      = GetBestSize();
 537 }
 538
 539 // -------------------------------------------------------------------------
 540 // wxSoundInfoHeader *NextFragmentOutput()
 541 //
 542 // NextFragmentOutput() looks for a free output block. It will always
 543 // return you a non-NULL pointer but it may waits for an empty buffer a long
 544 // time.
 545 // -------------------------------------------------------------------------
 546 wxSoundInfoHeader *wxSoundStreamWin::NextFragmentOutput()
 547 {
 548   if (m_headers_play[m_current_frag_out]->m_playing) {
 549     m_current_frag_out = (m_current_frag_out + 1) % WXSOUND_MAX_QUEUE;
 550
 551     if (m_headers_play[m_current_frag_out]->m_playing)
 552       WaitFor(m_headers_play[m_current_frag_out]);
 553   }
 554   if (m_current_frag_out == m_output_frag_out)
 555     m_queue_filled = true;
 556   return m_headers_play[m_current_frag_out];
 557 }
 558
 559 // -------------------------------------------------------------------------
 560 // The behaviour of Write is documented in the global documentation.
 561 // -------------------------------------------------------------------------
 562 wxSoundStream& wxSoundStreamWin::Write(const void *buffer, wxUint32 len)
 563 {
 564     m_lastcount = 0;
 565     if (!m_internal->m_output_enabled) {
 566         m_snderror = wxSOUND_NOTSTARTED;
 567         return *this;
 568     }
 569
 570
 571     while (len > 0) {
 572         wxSoundInfoHeader *header;
 573         wxUint32 to_copy;
 574
 575         // Get a new output fragment
 576         header              = NextFragmentOutput();
 577
 578         to_copy             = (len > header->m_size) ? header->m_size : len;
 579         memcpy(header->m_data + header->m_position, buffer, to_copy);
 580
 581         header->m_position += to_copy;
 582         header->m_size     -= to_copy;
 583         buffer              = (((const char *)buffer) + to_copy);
 584         len                -= to_copy;
 585         m_lastcount        += to_copy;
 586
 587         // If the fragment is full, we send it to the Windows queue.
 588         if (header->m_size == 0)
 589             if (!AddToQueue(header)) {
 590                 m_snderror = wxSOUND_IOERROR;
 591                 return *this;
 592             }
 593     }
 594     return *this;
 595 }
 596
 597 // -------------------------------------------------------------------------
 598 // NextFragmentInput is not functional.
 599 // -------------------------------------------------------------------------
 600 wxSoundInfoHeader *wxSoundStreamWin::NextFragmentInput()
 601 {
 602     wxSoundInfoHeader *header;
 603
 604     // Queue pointer: reader
 605     m_current_frag_in = (m_current_frag_in + 1) % WXSOUND_MAX_QUEUE;
 606
 607     header = m_headers_rec[m_current_frag_in];
 608     // If the current buffer is in recording mode, we must wait for its
 609     // completion.
 610     if (header->m_recording)
 611         WaitFor(header);
 612
 613     // We reached the writer position: the queue is full.
 614     if (m_current_frag_in == m_input_frag_in)
 615         m_queue_filled = true;
 616
 617     return header;
 618 }
 619
 620 // -------------------------------------------------------------------------
 621 // The behaviour of Read is documented in the global documentation.
 622 // -------------------------------------------------------------------------
 623 wxSoundStream& wxSoundStreamWin::Read(void *buffer, wxUint32 len)
 624 {
 625     wxSoundInfoHeader *header;
 626     wxUint32 to_copy;
 627
 628     m_lastcount = 0;
 629     if (!m_internal->m_input_enabled)
 630         return *this;
 631
 632     while (len > 0) {
 633         header = NextFragmentInput();
 634
 635         to_copy             = (len > header->m_size) ? header->m_size : len;
 636         memcpy(buffer, header->m_data + header->m_position, to_copy);
 637
 638         header->m_position += to_copy;
 639         header->m_size     -= to_copy;
 640         buffer              = (((char *)buffer) + to_copy);
 641         len                -= to_copy;
 642         m_lastcount        += to_copy;
 643
 644         if (header->m_size == 0) {
 645             ClearHeader(header);
 646             if (!AddToQueue(header)) {
 647                 m_snderror = wxSOUND_IOERROR;
 648                 return *this;
 649             }
 650         }
 651     }
 652     return *this;
 653 }
 654
 655 // -------------------------------------------------------------------------
 656 // NotifyDoneBuffer(wxUint32 dev_handle)
 657 //
 658 // NotifyDoneBuffer() is called by wxSoundHandlerProc each time a sound
 659 // fragment finished. It reinitializes the parameters of the fragment and
 660 // sends an event to the clients.
 661 // -------------------------------------------------------------------------
 662 void wxSoundStreamWin::NotifyDoneBuffer(wxUint32 WXUNUSED(dev_handle), int flag)
 663 {
 664     wxSoundInfoHeader *info;
 665
 666     if (flag == wxSOUND_OUTPUT) {
 667         if (!m_internal->m_output_enabled)
 668             return;
 669
 670         // Queue pointer: reader
 671         m_output_frag_out = (m_output_frag_out + 1) % WXSOUND_MAX_QUEUE;
 672         info = m_headers_play[m_output_frag_out];
 673         // Clear header to tell the system the buffer is free now
 674         ClearHeader(info);
 675         m_queue_filled = false;
 676         if (!m_waiting_for)
 677             // Try to requeue a new buffer.
 678             OnSoundEvent(wxSOUND_OUTPUT);
 679     } else {
 680         if (!m_internal->m_input_enabled)
 681             return;
 682
 683         // Recording completed
 684         m_headers_rec[m_input_frag_in]->m_recording = false;
 685         // Queue pointer: writer
 686         m_input_frag_in = (m_input_frag_in + 1) % WXSOUND_MAX_QUEUE;
 687         if (!m_waiting_for)
 688             OnSoundEvent(wxSOUND_INPUT);
 689         m_queue_filled = false;
 690     }
 691 }
 692
 693 // -------------------------------------------------------------------------
 694 // SetSoundFormat()
 695 // -------------------------------------------------------------------------
 696 bool wxSoundStreamWin::SetSoundFormat(const wxSoundFormatBase& base)
 697 {
 698   // TODO: detect best format
 699   return wxSoundStream::SetSoundFormat(base);
 700 }
 701
 702 // -------------------------------------------------------------------------
 703 // StartProduction()
 704 // -------------------------------------------------------------------------
 705 bool wxSoundStreamWin::StartProduction(int evt)
 706 {
 707   if (!m_internal)
 708     return false;
 709
 710   if ((m_internal->m_output_enabled && (evt & wxSOUND_OUTPUT)) ||
 711       (m_internal->m_input_enabled && (evt & wxSOUND_INPUT)))
 712     CloseDevice();
 713
 714   if (!OpenDevice(evt))
 715     return false;
 716
 717   m_production_started = true;
 718   m_queue_filled = false;
 719   // Send a dummy event to start.
 720   if (evt & wxSOUND_OUTPUT)
 721     OnSoundEvent(wxSOUND_OUTPUT);
 722
 723   if (evt & wxSOUND_INPUT) {
 724     int i;
 725     for (i=0;i<WXSOUND_MAX_QUEUE;i++)
 726       AddToQueue(m_headers_rec[i]);
 727
 728     waveInStart(m_internal->m_devin);
 729   }
 730
 731   return true;
 732 }
 733
 734 // -------------------------------------------------------------------------
 735 // StopProduction()
 736 // ------------------------------------------------------------------------
 737 bool wxSoundStreamWin::StopProduction()
 738 {
 739     if (!m_production_started) {
 740         m_snderror = wxSOUND_NOTSTARTED;
 741         return false;
 742     }
 743
 744     m_snderror = wxSOUND_NOERROR;
 745     m_production_started = false;
 746     CloseDevice();
 747     return true;
 748 }
 749
 750 // -------------------------------------------------------------------------
 751 // QueueFilled()
 752 // -------------------------------------------------------------------------
 753 bool wxSoundStreamWin::QueueFilled() const
 754 {
 755   return (!m_production_started || m_queue_filled);
 756 }
 757
 758
 759 // --------------------------------------------------------------------------
 760 // wxSoundWinModule
 761 // --------------------------------------------------------------------------
 762
 763 class wxSoundWinModule : public wxModule {
 764    DECLARE_DYNAMIC_CLASS(wxSoundWinModule)
 765  public:
 766    bool OnInit();
 767    void OnExit();
 768 };
 769
 770 IMPLEMENT_DYNAMIC_CLASS(wxSoundWinModule, wxModule)
 771
 772 bool wxSoundWinModule::OnInit() {
 773   wxSoundHandleList = new wxList(wxKEY_INTEGER);
 774   return true;
 775 }
 776
 777 void wxSoundWinModule::OnExit() {
 778   delete wxSoundHandleList;
 779 }
 780
 781 #endif
 782   // __WINDOWS__