Aliases for [G|S]etCaretLineBack

[wxWidgets.git] / contrib / src / mmedia / sndesd.cpp

diff --git a/contrib/src/mmedia/sndesd.cpp b/contrib/src/mmedia/sndesd.cpp
index e3d6860253616410ec1a6267816ee53382ccc1dc..8c38f4dea26517d6730f3f6ee4bc63ca8af2dcce 100644 (file)
--- a/contrib/src/mmedia/sndesd.cpp
+++ b/contrib/src/mmedia/sndesd.cpp
@@ -4,10 +4,8 @@
 // Date: 08/11/1999
 // Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 1999
 // CVSID: $Id$
 // Date: 08/11/1999
 // Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 1999
 // CVSID: $Id$

+// wxWindows licence

 // --------------------------------------------------------------------------
 // --------------------------------------------------------------------------

-#ifdef __GNUG__
-#pragma implementation "sndesd.cpp"
-#endif

 
 #include "wx/wxprec.h"
 
 
 #include "wx/wxprec.h"
 


@@ -20,8 +18,6 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-#ifdef HAVE_ESD_H
-

 // --------------------------------------------------------------------------
 // MMedia headers
 // --------------------------------------------------------------------------
 // --------------------------------------------------------------------------
 // MMedia headers
 // --------------------------------------------------------------------------


@@ -34,6 +30,7 @@
 // System headers
 // --------------------------------------------------------------------------
 
 // System headers
 // --------------------------------------------------------------------------
 

+#ifdef HAVE_ESD_H

 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>


@@ -41,10 +38,11 @@
 #ifdef __WXGTK__
 #include <gdk/gdk.h>
 #endif
 #ifdef __WXGTK__
 #include <gdk/gdk.h>
 #endif

+#endif

 
 // --------------------------------------------------------------------------
 
 
 // --------------------------------------------------------------------------
 

-#define MY_ESD_NAME "wxWindows/wxSoundStreamESD"
+#define MY_ESD_NAME "wxWidgets/wxSoundStreamESD"

 
 // --------------------------------------------------------------------------
 // wxSoundStreamESD: ESD sound driver
 
 // --------------------------------------------------------------------------
 // wxSoundStreamESD: ESD sound driver


@@ -55,44 +53,51 @@
 
 wxSoundStreamESD::wxSoundStreamESD(const wxString& hostname)
 {
 
 wxSoundStreamESD::wxSoundStreamESD(const wxString& hostname)
 {

+#ifndef HAVE_ESD_H
+    m_snderror = wxSOUND_INVDEV;
+    return;
+#else

     wxSoundFormatPcm pcm_default;
     wxSoundFormatPcm pcm_default;

-    
+

     // First, we make some basic test: is there ESD on this computer ?
     // First, we make some basic test: is there ESD on this computer ?

-    m_esd_ok = FALSE;
-    
+    m_esd_ok = false;
+

     if (hostname.IsNull())
     if (hostname.IsNull())

-        m_fd_output = esd_play_stream(ESD_PLAY | ESD_STREAM, 22050, 
+        m_fd_output = esd_play_stream(ESD_PLAY | ESD_STREAM, 22050,

                                       hostname.mb_str(), MY_ESD_NAME);
     else
                                       hostname.mb_str(), MY_ESD_NAME);
     else

-        m_fd_output = esd_play_stream(ESD_PLAY | ESD_STREAM, 22050, 
+        m_fd_output = esd_play_stream(ESD_PLAY | ESD_STREAM, 22050,

                                       NULL, MY_ESD_NAME);
     if (m_fd_output == -1) {
         // Answer: no. We return with an error.
         m_snderror = wxSOUND_INVDEV;
         return;
     }
                                       NULL, MY_ESD_NAME);
     if (m_fd_output == -1) {
         // Answer: no. We return with an error.
         m_snderror = wxSOUND_INVDEV;
         return;
     }

-    
+

     // Close this unuseful stream.
     esd_close(m_fd_output);
     // Close this unuseful stream.
     esd_close(m_fd_output);

-    
+

     m_hostname = hostname;
     m_hostname = hostname;

-    
+

     // Set the default audio format
     SetSoundFormat(pcm_default);
     // Set the default audio format
     SetSoundFormat(pcm_default);

-    
+

     // Initialize some variable
     m_snderror = wxSOUND_NOERROR;
     // Initialize some variable
     m_snderror = wxSOUND_NOERROR;

-    m_esd_stop = TRUE;
-    m_q_filled = TRUE;
-    m_esd_ok   = TRUE;
+    m_esd_stop = true;
+    m_q_filled = true;
+    m_esd_ok   = true;

     m_fd_output= -1;
     m_fd_input = -1;
     m_fd_output= -1;
     m_fd_input = -1;

+#endif // defined HAVE_ESD_H

 }
 
 wxSoundStreamESD::~wxSoundStreamESD()
 {
 }
 
 wxSoundStreamESD::~wxSoundStreamESD()
 {

+#ifdef HAVE_ESD_H

     if (!m_esd_stop)
         StopProduction();
     if (!m_esd_stop)
         StopProduction();

+#endif // defined HAVE_ESD_H

 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------


@@ -101,21 +106,27 @@ wxSoundStreamESD::~wxSoundStreamESD()
 
 wxSoundStream& wxSoundStreamESD::Read(void *buffer, wxUint32 len)
 {
 
 wxSoundStream& wxSoundStreamESD::Read(void *buffer, wxUint32 len)
 {

+#ifndef HAVE_ESD_H
+    m_snderror = wxSOUND_INVDEV;
+    return *this;
+#else

     int ret;
     int ret;

-    
+

     if (m_esd_stop) {
         m_snderror = wxSOUND_NOTSTARTED;
         return *this;
     }
     if (m_esd_stop) {
         m_snderror = wxSOUND_NOTSTARTED;
         return *this;
     }

-    
-    m_lastcount = (wxUint32)ret = read(m_fd_input, buffer, len);
-    
+
+    ret = read(m_fd_input, buffer, len);
+    m_lastcount = (wxUint32)ret;
+

     if (ret < 0)
         m_snderror = wxSOUND_IOERROR;
     else
         m_snderror = wxSOUND_NOERROR;
     if (ret < 0)
         m_snderror = wxSOUND_IOERROR;
     else
         m_snderror = wxSOUND_NOERROR;

-    
+

     return *this;
     return *this;

+#endif // defined HAVE_ESD_H

 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------


@@ -123,6 +134,10 @@ wxSoundStream& wxSoundStreamESD::Read(void *buffer, wxUint32 len)
 // --------------------------------------------------------------------------
 wxSoundStream& wxSoundStreamESD::Write(const void *buffer, wxUint32 len)
 {
 // --------------------------------------------------------------------------
 wxSoundStream& wxSoundStreamESD::Write(const void *buffer, wxUint32 len)
 {

+#ifndef HAVE_ESD_H
+    m_snderror = wxSOUND_INVDEV;
+    return *this;
+#else

     int ret;
 
     if (m_esd_stop) {
     int ret;
 
     if (m_esd_stop) {


@@ -130,17 +145,19 @@ wxSoundStream& wxSoundStreamESD::Write(const void *buffer, wxUint32 len)
         m_snderror = wxSOUND_NOTSTARTED;
         return *this;
     }
         m_snderror = wxSOUND_NOTSTARTED;
         return *this;
     }

-    
-    m_lastcount = (wxUint32)ret = write(m_fd_output, buffer, len);
-    
+
+    ret = write(m_fd_output, buffer, len);
+    m_lastcount = (wxUint32)ret;
+

     if (ret < 0)
         m_snderror = wxSOUND_IOERROR;
   else
       m_snderror = wxSOUND_NOERROR;
     if (ret < 0)
         m_snderror = wxSOUND_IOERROR;
   else
       m_snderror = wxSOUND_NOERROR;

-    
-    m_q_filled = TRUE;
-    
+
+    m_q_filled = true;
+

     return *this;
     return *this;

+#endif // defined HAVE_ESD_H

 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------


@@ -149,49 +166,54 @@ wxSoundStream& wxSoundStreamESD::Write(const void *buffer, wxUint32 len)
 // --------------------------------------------------------------------------
 bool wxSoundStreamESD::SetSoundFormat(const wxSoundFormatBase& format)
 {
 // --------------------------------------------------------------------------
 bool wxSoundStreamESD::SetSoundFormat(const wxSoundFormatBase& format)
 {

+#ifndef HAVE_ESD_H
+    m_snderror = wxSOUND_INVDEV;
+    return false;
+#else

     wxSoundFormatPcm *pcm_format;
     wxSoundFormatPcm *pcm_format;

-    
+

     if (format.GetType() != wxSOUND_PCM) {
         m_snderror = wxSOUND_INVFRMT;
     if (format.GetType() != wxSOUND_PCM) {
         m_snderror = wxSOUND_INVFRMT;

-        return FALSE;
+        return false;

     }
 
     if (!m_esd_ok) {
         m_snderror = wxSOUND_INVDEV;
     }
 
     if (!m_esd_ok) {
         m_snderror = wxSOUND_INVDEV;

-        return FALSE;
+        return false;

     }
     }

-    
+

     if (m_sndformat)
         delete m_sndformat;
     if (m_sndformat)
         delete m_sndformat;

-    
+

     m_sndformat = format.Clone();
     if (!m_sndformat) {
         m_snderror = wxSOUND_MEMERROR;
     m_sndformat = format.Clone();
     if (!m_sndformat) {
         m_snderror = wxSOUND_MEMERROR;

-        return FALSE;
+        return false;

     }
     pcm_format = (wxSoundFormatPcm *)m_sndformat;
     }
     pcm_format = (wxSoundFormatPcm *)m_sndformat;

-    
+

     // Detect the best format
     DetectBest(pcm_format);
     // Detect the best format
     DetectBest(pcm_format);

-    
+

     m_snderror = wxSOUND_NOERROR;
     if (*pcm_format != format) {
         m_snderror = wxSOUND_NOEXACT;
     m_snderror = wxSOUND_NOERROR;
     if (*pcm_format != format) {
         m_snderror = wxSOUND_NOEXACT;

-        return FALSE;
+        return false;

     }
     }

-    return TRUE;
+    return true;
+#endif // defined HAVE_ESD_H

 }
 
 // --------------------------------------------------------------------------
 // _wxSound_OSS_CBack (internal): it is called when the driver (ESD) is
 // ready for a next buffer.
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------
 // _wxSound_OSS_CBack (internal): it is called when the driver (ESD) is
 // ready for a next buffer.
 // --------------------------------------------------------------------------

-#ifdef __WXGTK__
+#if defined(__WXGTK__) && defined(HAVE_ESD_H)

 static void _wxSound_OSS_CBack(gpointer data, int source,
                                GdkInputCondition condition)
 {
     wxSoundStreamESD *esd = (wxSoundStreamESD *)data;
 static void _wxSound_OSS_CBack(gpointer data, int source,
                                GdkInputCondition condition)
 {
     wxSoundStreamESD *esd = (wxSoundStreamESD *)data;

-    
+

     switch (condition) {
         case GDK_INPUT_READ:
             esd->WakeUpEvt(wxSOUND_INPUT);
     switch (condition) {
         case GDK_INPUT_READ:
             esd->WakeUpEvt(wxSOUND_INPUT);


@@ -212,7 +234,7 @@ static void _wxSound_OSS_CBack(gpointer data, int source,
 // --------------------------------------------------------------------------
 void wxSoundStreamESD::WakeUpEvt(int evt)
 {
 // --------------------------------------------------------------------------
 void wxSoundStreamESD::WakeUpEvt(int evt)
 {

-    m_q_filled = FALSE;
+    m_q_filled = false;

     OnSoundEvent(evt);
 }
 
     OnSoundEvent(evt);
 }
 


@@ -221,34 +243,38 @@ void wxSoundStreamESD::WakeUpEvt(int evt)
 // --------------------------------------------------------------------------
 bool wxSoundStreamESD::StartProduction(int evt)
 {
 // --------------------------------------------------------------------------
 bool wxSoundStreamESD::StartProduction(int evt)
 {

+#ifndef HAVE_ESD_H
+    m_snderror = wxSOUND_INVDEV;
+    return false;
+#else

     wxSoundFormatPcm *pcm;
     int flag = 0;
 
     if (!m_esd_ok) {
         m_snderror = wxSOUND_INVDEV;
     wxSoundFormatPcm *pcm;
     int flag = 0;
 
     if (!m_esd_ok) {
         m_snderror = wxSOUND_INVDEV;

-        return FALSE;
+        return false;

     }
     }

-    
+

     if (!m_esd_stop)
         StopProduction();
     if (!m_esd_stop)
         StopProduction();

-    
+

     pcm = (wxSoundFormatPcm *)m_sndformat;
     pcm = (wxSoundFormatPcm *)m_sndformat;

-    
+

     flag |= (pcm->GetBPS() == 16) ? ESD_BITS16 : ESD_BITS8;
     flag |= (pcm->GetChannels() == 2) ? ESD_STEREO : ESD_MONO;
     flag |= (pcm->GetBPS() == 16) ? ESD_BITS16 : ESD_BITS8;
     flag |= (pcm->GetChannels() == 2) ? ESD_STEREO : ESD_MONO;

-    
+

     if ((evt & wxSOUND_OUTPUT) != 0) {
         flag |= ESD_PLAY | ESD_STREAM;
         m_fd_output = esd_play_stream(flag, pcm->GetSampleRate(), NULL,
                                       MY_ESD_NAME);
     if ((evt & wxSOUND_OUTPUT) != 0) {
         flag |= ESD_PLAY | ESD_STREAM;
         m_fd_output = esd_play_stream(flag, pcm->GetSampleRate(), NULL,
                                       MY_ESD_NAME);

-    } 
-    
+    }
+

     if ((evt & wxSOUND_INPUT) != 0) {
         flag |= ESD_RECORD | ESD_STREAM;
         m_fd_input = esd_record_stream(flag, pcm->GetSampleRate(), NULL,
                                        MY_ESD_NAME);
     }
     if ((evt & wxSOUND_INPUT) != 0) {
         flag |= ESD_RECORD | ESD_STREAM;
         m_fd_input = esd_record_stream(flag, pcm->GetSampleRate(), NULL,
                                        MY_ESD_NAME);
     }

-    
+

 #ifdef __WXGTK__
     if ((evt & wxSOUND_OUTPUT) != 0) {
         m_tag_output = gdk_input_add(m_fd_output, GDK_INPUT_WRITE,
 #ifdef __WXGTK__
     if ((evt & wxSOUND_OUTPUT) != 0) {
         m_tag_output = gdk_input_add(m_fd_output, GDK_INPUT_WRITE,


@@ -259,11 +285,12 @@ bool wxSoundStreamESD::StartProduction(int evt)
                                     _wxSound_OSS_CBack, (gpointer)this);
     }
 #endif
                                     _wxSound_OSS_CBack, (gpointer)this);
     }
 #endif

-  
-    m_esd_stop = FALSE;
-    m_q_filled = FALSE;
-    
-    return TRUE;
+
+    m_esd_stop = false;
+    m_q_filled = false;
+
+    return true;
+#endif // defined HAVE_ESD_H

 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------


@@ -271,9 +298,13 @@ bool wxSoundStreamESD::StartProduction(int evt)
 // --------------------------------------------------------------------------
 bool wxSoundStreamESD::StopProduction()
 {
 // --------------------------------------------------------------------------
 bool wxSoundStreamESD::StopProduction()
 {

+#ifndef HAVE_ESD_H
+    m_snderror = wxSOUND_INVDEV;
+    return false;
+#else

     if (m_esd_stop)
     if (m_esd_stop)

-        return FALSE;
-    
+        return false;
+

     if (m_fd_input != -1) {
         esd_close(m_fd_input);
 #ifdef __WXGTK__
     if (m_fd_input != -1) {
         esd_close(m_fd_input);
 #ifdef __WXGTK__


@@ -286,12 +317,13 @@ bool wxSoundStreamESD::StopProduction()
         gdk_input_remove(m_tag_output);
 #endif
     }
         gdk_input_remove(m_tag_output);
 #endif
     }

-    
+

     m_fd_input = -1;
     m_fd_output= -1;
     m_fd_input = -1;
     m_fd_output= -1;

-    m_esd_stop = TRUE;
-    m_q_filled = TRUE;
-    return TRUE;
+    m_esd_stop = true;
+    m_q_filled = true;
+    return true;
+#endif // defined HAVE_ESD_H

 }
 
 //
 }
 
 //


@@ -299,14 +331,18 @@ bool wxSoundStreamESD::StopProduction()
 //
 void wxSoundStreamESD::DetectBest(wxSoundFormatPcm *pcm)
 {
 //
 void wxSoundStreamESD::DetectBest(wxSoundFormatPcm *pcm)
 {

+#ifndef HAVE_ESD_H
+    m_snderror = wxSOUND_INVDEV;
+    return;
+#else

     wxSoundFormatPcm best_pcm;
 
     // We change neither the number of channels nor the sample rate
     // because ESD is clever.
     wxSoundFormatPcm best_pcm;
 
     // We change neither the number of channels nor the sample rate
     // because ESD is clever.

-    
+

     best_pcm.SetSampleRate(pcm->GetSampleRate());
     best_pcm.SetChannels(pcm->GetChannels());
     best_pcm.SetSampleRate(pcm->GetSampleRate());
     best_pcm.SetChannels(pcm->GetChannels());

-    
+

     // It supports 16 bits
     if (pcm->GetBPS() >= 16)
         best_pcm.SetBPS(16);
     // It supports 16 bits
     if (pcm->GetBPS() >= 16)
         best_pcm.SetBPS(16);


@@ -314,10 +350,10 @@ void wxSoundStreamESD::DetectBest(wxSoundFormatPcm *pcm)
         best_pcm.SetBPS(8);
 
     best_pcm.SetOrder(wxLITTLE_ENDIAN);
         best_pcm.SetBPS(8);
 
     best_pcm.SetOrder(wxLITTLE_ENDIAN);

-    best_pcm.Signed(TRUE);
-    
+    best_pcm.Signed(true);
+

     // Finally recopy the new format
     *pcm = best_pcm;
     // Finally recopy the new format
     *pcm = best_pcm;

+#endif // defined HAVE_ESD_H

 }
 
 }
 

-#endif // HAVE_ESD_H