{
int i;
+ // Reset all variables to their neutral value.
m_sndformat = NULL;
m_handler = NULL;
m_snderror = wxSOUND_NOERR;
delete m_sndformat;
}
-// SetSoundFormat returns TRUE when the format can be handled.
+// --------------------------------------------------------------------------
+// SetSoundFormat(const wxSoundFormatBase& format) is one of the most
+// important function of the wxSoundStream class. It prepares the stream to
+// receive or send the data in a strict format. Normally, the sound stream
+// should be ready to accept any format it is asked to manage but in certain
+// cases, it really cannot: in that case it returns FALSE. To have more
+// details in the functionnalities of SetSoundFormat see
+// wxSoundRouterStream::SetSoundFormat()
+// --------------------------------------------------------------------------
bool wxSoundStream::SetSoundFormat(const wxSoundFormatBase& format)
{
+ // delete the previous prepared format
if (m_sndformat)
delete m_sndformat;
+ // create a new one by cloning the format passed in parameter
m_sndformat = format.Clone();
return TRUE;
}
-// Register a callback for a specified async event.
+
+// --------------------------------------------------------------------------
+// Register(int evt, ...) registers the callback for a specified async event.
+// Warning ! Only one callback by event is supported. It means that if you
+// call twice this function the previous registered callback is absolutely
+// ignored.
+// --------------------------------------------------------------------------
void wxSoundStream::Register(int evt, wxSoundCallback cbk, char *cdata)
{
int c;
m_cdata[c] = cdata;
}
+// --------------------------------------------------------------------------
+// OnSoundEvent(int evt) is called either when the driver is ready to receive
+// a new block to play or when the driver has a new recorded buffer. You
+// must be careful here and try not to spend a lot of time: this is a
+// real-time call. In the case, an "event handler" was specified previously,
+// it called him before everything.
+// --------------------------------------------------------------------------
void wxSoundStream::OnSoundEvent(int evt)
{
int c;
#include <wx/defs.h>
+// ------------------------------------------------------------------------
+// DEFINITIONS
+
+// ---------------------
+// Sound streaming mode:
+// - wxSOUND_INPUT: simple recording mode
+// - wxSOUND_OUTPUT: simple playing mode
+// - wxSOUND_DUPLEX: full duplex record/play at the same time
+// ---------------------
enum {
wxSOUND_INPUT = 1,
wxSOUND_OUTPUT = 2,
wxSOUND_DUPLEX = wxSOUND_INPUT | wxSOUND_OUTPUT,
};
+// ---------------------
+// wxSoundFormatType: it specifies the format family of the sound data
+// which will be passed to the stream.
+// ---------------------
typedef enum {
wxSOUND_NOFORMAT,
wxSOUND_PCM,
wxSOUND_G72X
} wxSoundFormatType;
+// ---------------------
+// wxSoundError:
+// - wxSOUND_NOERR: No error occured
+// - wxSOUND_IOERR: an input/output error occured, it may concern either
+// a driver or a file
+// - wxSOUND_INVFRMT: the sound format passed to the function is invalid.
+// Generally, it means that you passed out of range values
+// to the codec stream or you don't pass the right sound
+// format object to the right sound codec stream.
+// - wxSOUND_INVDEV: Invalid device. Generally, it means that the sound stream
+// didn't manage to open the device driver due to an invalid// parameter or to the fact that sound is not supported on
+// this computer.
+// - wxSOUND_NOEXACT: No exact matching sound codec has been found for
+// this sound format. It means that the sound driver didn't
+// manage to setup the sound card with the specified
+// values.
+// - wxSOUND_NOCODEC: No matching codec has been found. Generally, it
+// may happen when you call
+// wxSoundRouterStream::SetSoundFormat().
+// - wxSOUND_MEMERR: Not enough memory.
+// ---------------------
typedef enum {
wxSOUND_NOERR,
wxSOUND_IOERR,
wxSOUND_INVFRMT,
wxSOUND_INVDEV,
- wxSOUND_NOTEXACT,
+ wxSOUND_NOEXACT,
wxSOUND_INVSTRM,
wxSOUND_NOCODEC,
wxSOUND_MEMERR
class WXDLLEXPORT wxSoundStream;
+// ---------------------
+// wxSoundCallback(stream, evt, cdata): C callback for sound event.
+// - stream: current wxSoundStream
+// - evt: the sound event which has occured, it may be wxSOUND_INPUT,
+// wxSOUND_OUTPUT or wxSOUND_DUPLEX
+// - cdata: User callback data
+// ---------------------
typedef void (*wxSoundCallback)(wxSoundStream *stream, int evt,
char *cdata);
wxSoundFormatBase();
virtual ~wxSoundFormatBase();
+ // It returns a "standard" format type.
virtual wxSoundFormatType GetType() const { return wxSOUND_NOFORMAT; }
+ // It clones the current format.
virtual wxSoundFormatBase *Clone() const;
virtual wxUint32 GetTimeFromBytes(wxUint32 bytes) const = 0;
// Register a callback for a specified async event.
void Register(int evt, wxSoundCallback cbk, char *cdata);
- // Starts the async notifier.
+ // Starts the async notifier. After this call, the stream begins either
+ // recording or playing or the two at the same time.
virtual bool StartProduction(int evt) = 0;
// Stops the async notifier.
virtual bool StopProduction() = 0;
m_snderror = wxSOUND_NOERR;
if (*pcm_format != format) {
- m_snderror = wxSOUND_NOTEXACT;
+ m_snderror = wxSOUND_NOEXACT;
return FALSE;
}
return TRUE;
// --------------------------------------------------------------------------
// Sound codec router
+// A very important class: it ensures that everybody is satisfied.
+// It is supposed to create as many codec as it is necessary to transform
+// a signal in a specific format in an another.
// --------------------------------------------------------------------------
-
wxSoundRouterStream::wxSoundRouterStream(wxSoundStream& sndio)
: wxSoundStreamCodec(sndio)
{
delete m_router;
}
+// --------------------------------------------------------------------------
+// Read(void *buffer, wxUint32 len): It reads data synchronously. See sndbase.h
+// for possible errors and behaviours ...
+// --------------------------------------------------------------------------
wxSoundStream& wxSoundRouterStream::Read(void *buffer, wxUint32 len)
{
if (m_router) {
return *this;
}
+// --------------------------------------------------------------------------
+// Write(const void *buffer, wxUint32 len): It writes data synchronously
+// --------------------------------------------------------------------------
wxSoundStream& wxSoundRouterStream::Write(const void *buffer, wxUint32 len)
{
if (m_router) {
return *this;
}
+// --------------------------------------------------------------------------
+// SetSoundFormat(const wxSoundFormatBase& format) first tries to setup the
+// sound driver using the specified format. If this fails, it uses personnal
+// codec converters: for the moment there is a PCM converter (PCM to PCM:
+// with optional resampling, ...), an ULAW converter (ULAW to PCM), a G72X
+// converter (G72X to PCM). If nothing works, it returns FALSE.
+// --------------------------------------------------------------------------
bool wxSoundRouterStream::SetSoundFormat(const wxSoundFormatBase& format)
{
if (m_router)
return TRUE;
}
+// --------------------------------------------------------------------------
+// GetBestSize() returns the specific best buffer size a sound driver
+// can manage. It means that it will be easier for it to manage the buffer
+// and so it will be faster and in some case more accurate for real-time event.
+// --------------------------------------------------------------------------
wxUint32 wxSoundRouterStream::GetBestSize() const
{
if (m_router)
return m_sndio->GetBestSize();
}
+// --------------------------------------------------------------------------
+// StartProduction(int evt). See sndbase.h
+// --------------------------------------------------------------------------
bool wxSoundRouterStream::StartProduction(int evt)
{
if (!m_router) {
return FALSE;
}
+// --------------------------------------------------------------------------
+// StopProduction(). See sndbase.h
+// --------------------------------------------------------------------------
bool wxSoundRouterStream::StopProduction()
{
if (!m_router) {
m_state = wxSOUND_FILE_STOPPED;
return FALSE;
}
+
+ if (m_input)
+ m_input->SeekI(0, wxFromStart);
+
+ if (m_output)
+ m_output->SeekO(0, wxFromStart);
- // TODO reset counter
m_state = wxSOUND_FILE_STOPPED;
return TRUE;
}
m_snderror = wxSOUND_NOERR;
if (*pcm_format != format) {
- m_snderror = wxSOUND_NOTEXACT;
+ m_snderror = wxSOUND_NOEXACT;
return FALSE;
}
return TRUE;
StopProduction();
old_frmt = m_sndformat->Clone();
+ if (!old_frmt) {
+ m_snderror = wxSOUND_MEMERR;
+ return FALSE;
+ }
if (evt == wxSOUND_OUTPUT)
m_fd = open(m_devname.mb_str(), O_WRONLY);
delete frmt;
}
- data << (fmt_data.GetSize() + 8 + m_sndformat->GetBytesFromTime(time));
+ data << (fmt_data.GetSize() + m_sndformat->GetBytesFromTime(time));
{
char *out_buf;
bool wxSoundWave::FinishRecording()
{
+ if (m_output->SeekO(0, wxFromStart) == wxInvalidOffset)
+ // We can't but there is no error.
+ return TRUE;
+
+ if (m_len == 0)
+ return TRUE;
+
+
+
// TODO: Update headers when we stop before the specified time (if possible)
return TRUE;
}
m_production_started = FALSE;
m_internal = new wxSoundInternal;
+ if (!m_internal) {
+ m_snderror = wxSOUND_MEMERR;
+ m_internal = NULL;
+ return;
+ }
m_snderror = wxSOUND_NOERR;
// Setup defaults
wxSoundStreamWin::~wxSoundStreamWin()
{
- if (m_production_started)
- StopProduction();
- DestroySndWindow();
+ if (m_internal) {
+ if (m_production_started)
+ StopProduction();
+ DestroySndWindow();
- delete m_internal;
+ delete m_internal;
+ }
}
LRESULT APIENTRY _EXPORT _wxSoundHandlerWndProc(HWND hWnd, UINT message,
// -------------------------------------------------------------------------
bool wxSoundStreamWin::StartProduction(int evt)
{
+ if (!m_internal)
+ return FALSE;
+
if ((m_internal->m_output_enabled && (evt & wxSOUND_OUTPUT)) ||
(m_internal->m_input_enabled && (evt & wxSOUND_INPUT)))
CloseDevice();
// -------------------------------------------------------------------------
bool wxSoundStreamWin::StopProduction()
{
+ if (!m_production_started)
+ return FALSE;
+
m_production_started = FALSE;
CloseDevice();
return TRUE;
projects / wxWidgets.git / commitdiff
