static inline wxSoundStreamWin *wxFindSoundFromHandle(WXHWND hWnd)
{
- wxNode *node = wxSoundHandleList->Find((long)hWnd);
+ wxObjectList::compatibility_iterator node = wxSoundHandleList->Find((long)hWnd);
if (!node)
return NULL;
- return (wxSoundStreamWin *)node->Data();
+ return (wxSoundStreamWin *)node->GetData();
}
struct _wxSoundInternal {
{
wxSoundFormatPcm pcm;
- m_production_started = FALSE;
+ m_production_started = false;
m_internal = new wxSoundInternal;
if (!m_internal) {
m_snderror = wxSOUND_MEMERROR;
CreateSndWindow();
SetSoundFormat(pcm);
- m_internal->m_input_enabled = FALSE;
- m_internal->m_output_enabled = FALSE;
+ m_internal->m_input_enabled = false;
+ m_internal->m_output_enabled = false;
- m_waiting_for = FALSE;
+ m_waiting_for = false;
if (!OpenDevice(wxSOUND_OUTPUT)) {
m_snderror = wxSOUND_NOERROR; //next call to OpenDevice won't do this
// -----------------------------------------------------------------------
// _wxSoundHandlerWndProc: Window callback to handle buffer completion
// -----------------------------------------------------------------------
-/*
-LRESULT APIENTRY _EXPORT
-*/
-
-LRESULT WXDLLEXPORT APIENTRY _EXPORT
+LRESULT APIENTRY _EXPORT
_wxSoundHandlerWndProc(HWND hWnd, UINT message,
- WPARAM wParam, LPARAM lParam)
+ WPARAM wParam, LPARAM WXUNUSED(lParam))
{
wxSoundStreamWin *sndwin;
{
FARPROC proc = MakeProcInstance((FARPROC)_wxSoundHandlerWndProc,
wxGetInstance());
- int error;
-
- m_internal->m_sndWin = ::CreateWindow(wxCanvasClassName, NULL, 0,
- 0, 0, 0, 0, NULL, (HMENU) NULL,
+ // NB: class name must be kept in sync with wxCanvasClassName in
+ // src/msw/app.cpp!
+ m_internal->m_sndWin = ::CreateWindow(wxT("wxWindowClass"), NULL, 0,
+ 0, 0, 0, 0, NULL, (HMENU) NULL,
wxGetInstance(), NULL);
- error = GetLastError();
+ GetLastError();
::SetWindowLong(m_internal->m_sndWin, GWL_WNDPROC, (LONG)proc);
if (!m_sndformat) {
m_snderror = wxSOUND_INVFRMT;
- return FALSE;
+ return false;
}
pcm = (wxSoundFormatPcm *)m_sndformat;
if (result != MMSYSERR_NOERROR) {
m_snderror = wxSOUND_INVDEV;
- return FALSE;
+ return false;
}
m_output_frag_out = WXSOUND_MAX_QUEUE-1;
m_current_frag_out = 0;
- m_internal->m_output_enabled = TRUE;
+ m_internal->m_output_enabled = true;
}
// -----------------------------------
// Open the driver for Input operation
if (result != MMSYSERR_NOERROR) {
m_snderror = wxSOUND_INVDEV;
- return FALSE;
+ return false;
}
m_current_frag_in = WXSOUND_MAX_QUEUE-1;
m_input_frag_in = 0;
- m_internal->m_input_enabled = TRUE;
+ m_internal->m_input_enabled = true;
}
if (mode & wxSOUND_OUTPUT) {
if (!AllocHeaders(wxSOUND_OUTPUT)) {
CloseDevice();
- return FALSE;
+ return false;
}
}
if (mode & wxSOUND_INPUT) {
if (!AllocHeaders(wxSOUND_INPUT)) {
CloseDevice();
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
// -------------------------------------------------------------------------
{
if (m_internal->m_output_enabled) {
FreeHeaders(wxSOUND_OUTPUT);
- m_internal->m_output_enabled = FALSE;
+ m_internal->m_output_enabled = false;
waveOutClose(m_internal->m_devout);
}
if (m_internal->m_input_enabled) {
FreeHeaders(wxSOUND_INPUT);
- m_internal->m_input_enabled = FALSE;
+ m_internal->m_input_enabled = false;
waveInClose(m_internal->m_devin);
}
}
// AllocHeaders() allocates WXSOUND_MAX_QUEUE (= 128) blocks for an operation
// queue. It uses AllocHeader() for each element.
//
-// Once it has allocated all blocks, it returns TRUE and if an error occured
-// it returns FALSE.
+// Once it has allocated all blocks, it returns true and if an error occured
+// it returns false.
// -------------------------------------------------------------------------
bool wxSoundStreamWin::AllocHeaders(int mode)
{
headers[i] = AllocHeader(mode);
if (!headers[i]) {
FreeHeaders(mode);
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
// -------------------------------------------------------------------------
// PROBLEM //
return;
}
- m_waiting_for = TRUE;
+ m_waiting_for = true;
// Else, we wait for its termination
while (info->m_playing || info->m_recording)
wxYield();
- m_waiting_for = FALSE;
+ m_waiting_for = false;
}
// -------------------------------------------------------------------------
result = waveInAddBuffer(m_internal->m_devin,
info->m_header, sizeof(WAVEHDR));
if (result == MMSYSERR_NOERROR)
- info->m_recording = TRUE;
+ info->m_recording = true;
else
- return FALSE;
+ return false;
} else if (info->m_mode == wxSOUND_OUTPUT) {
result = waveOutWrite(m_internal->m_devout,
info->m_header, sizeof(WAVEHDR));
if (result == MMSYSERR_NOERROR)
- info->m_playing = TRUE;
+ info->m_playing = true;
else
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
void wxSoundStreamWin::ClearHeader(wxSoundInfoHeader *info)
{
- info->m_playing = FALSE;
- info->m_recording = FALSE;
+ info->m_playing = false;
+ info->m_recording = false;
info->m_position = 0;
info->m_size = GetBestSize();
}
WaitFor(m_headers_play[m_current_frag_out]);
}
if (m_current_frag_out == m_output_frag_out)
- m_queue_filled = TRUE;
+ m_queue_filled = true;
return m_headers_play[m_current_frag_out];
}
// We reached the writer position: the queue is full.
if (m_current_frag_in == m_input_frag_in)
- m_queue_filled = TRUE;
+ m_queue_filled = true;
return header;
}
// fragment finished. It reinitializes the parameters of the fragment and
// sends an event to the clients.
// -------------------------------------------------------------------------
-void wxSoundStreamWin::NotifyDoneBuffer(wxUint32 dev_handle, int flag)
+void wxSoundStreamWin::NotifyDoneBuffer(wxUint32 WXUNUSED(dev_handle), int flag)
{
wxSoundInfoHeader *info;
info = m_headers_play[m_output_frag_out];
// Clear header to tell the system the buffer is free now
ClearHeader(info);
- m_queue_filled = FALSE;
+ m_queue_filled = false;
if (!m_waiting_for)
// Try to requeue a new buffer.
OnSoundEvent(wxSOUND_OUTPUT);
return;
// Recording completed
- m_headers_rec[m_input_frag_in]->m_recording = FALSE;
+ m_headers_rec[m_input_frag_in]->m_recording = false;
// Queue pointer: writer
m_input_frag_in = (m_input_frag_in + 1) % WXSOUND_MAX_QUEUE;
if (!m_waiting_for)
OnSoundEvent(wxSOUND_INPUT);
- m_queue_filled = FALSE;
+ m_queue_filled = false;
}
}
// -------------------------------------------------------------------------
// SetSoundFormat()
// -------------------------------------------------------------------------
-bool wxSoundStreamWin::SetSoundFormat(wxSoundFormatBase& base)
+bool wxSoundStreamWin::SetSoundFormat(const wxSoundFormatBase& base)
{
// TODO: detect best format
return wxSoundStream::SetSoundFormat(base);
bool wxSoundStreamWin::StartProduction(int evt)
{
if (!m_internal)
- return FALSE;
+ return false;
if ((m_internal->m_output_enabled && (evt & wxSOUND_OUTPUT)) ||
(m_internal->m_input_enabled && (evt & wxSOUND_INPUT)))
CloseDevice();
if (!OpenDevice(evt))
- return FALSE;
+ return false;
- m_production_started = TRUE;
- m_queue_filled = FALSE;
+ m_production_started = true;
+ m_queue_filled = false;
// Send a dummy event to start.
if (evt & wxSOUND_OUTPUT)
OnSoundEvent(wxSOUND_OUTPUT);
waveInStart(m_internal->m_devin);
}
- return TRUE;
+ return true;
}
// -------------------------------------------------------------------------
{
if (!m_production_started) {
m_snderror = wxSOUND_NOTSTARTED;
- return FALSE;
+ return false;
}
m_snderror = wxSOUND_NOERROR;
- m_production_started = FALSE;
+ m_production_started = false;
CloseDevice();
- return TRUE;
+ return true;
}
// -------------------------------------------------------------------------
// wxSoundWinModule
// --------------------------------------------------------------------------
-class WXDLLEXPORT wxSoundWinModule : public wxModule {
+class wxSoundWinModule : public wxModule {
DECLARE_DYNAMIC_CLASS(wxSoundWinModule)
public:
bool OnInit();
bool wxSoundWinModule::OnInit() {
wxSoundHandleList = new wxList(wxKEY_INTEGER);
- return TRUE;
+ return true;
}
void wxSoundWinModule::OnExit() {
projects / wxWidgets.git / blobdiff