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