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

// --------------------------------------------------------------------------
// Name: sndwav.cpp
// Purpose:
// Date: 08/11/1999
// Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 1999
// CVSID: $Id$
// --------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "sndwav.cpp"
#endif

#include "wx/wxprec.h"

#ifndef WX_PRECOMP
    #include "wx/defs.h"
#endif

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/stream.h"
#include "wx/datstrm.h"
#include "wx/filefn.h"
#include "wx/mstream.h"

#include "wx/mmedia/sndbase.h"
#include "wx/mmedia/sndcodec.h"
#include "wx/mmedia/sndfile.h"
#include "wx/mmedia/sndpcm.h"
#include "wx/mmedia/sndg72x.h"
#include "wx/mmedia/sndmsad.h"
#include "wx/mmedia/sndwav.h"

#define BUILD_SIGNATURE(a,b,c,d) (((wxUint32)a) | (((wxUint32)b) << 8) | (((wxUint32)c) << 16)  | (((wxUint32)d) << 24)) 

#define RIFF_SIGNATURE BUILD_SIGNATURE('R','I','F','F')
#define WAVE_SIGNATURE BUILD_SIGNATURE('W','A','V','E')
#define FMT_SIGNATURE BUILD_SIGNATURE('f','m','t',' ')
#define DATA_SIGNATURE BUILD_SIGNATURE('d','a','t','a')

#define HEADER_SIZE 4+4 + 4+4+16 + 4+4
// 4+4 => NAME + LEN
// 16 => fmt size

wxSoundWave::wxSoundWave(wxInputStream& stream, wxSoundStream& io_sound)
        : wxSoundFileStream(stream, io_sound)
{
    m_base_offset = wxInvalidOffset;
}

wxSoundWave::wxSoundWave(wxOutputStream& stream, wxSoundStream& io_sound)
        : wxSoundFileStream(stream, io_sound)
{
    m_base_offset = wxInvalidOffset;
}

wxSoundWave::~wxSoundWave()
{
}

wxString wxSoundWave::GetCodecName() const
{
    return wxString(wxT("wxSoundWave codec"));
}

#define FAIL_WITH(condition, err) if (condition) { m_snderror = err; return FALSE; }

bool wxSoundWave::CanRead()
{
    wxUint32 len, signature1, signature2;
    m_snderror = wxSOUND_NOERROR;

    // Test the main signatures:
    //   "RIFF"
    FAIL_WITH(m_input->Read(&signature1, 4).LastRead() != 4, wxSOUND_INVSTRM);
    
    if (wxUINT32_SWAP_ON_BE(signature1) != RIFF_SIGNATURE) {
        m_input->Ungetch(&signature1, 4);
        return FALSE;
    }

    // Pass the global length
    m_input->Read(&len, 4);
    FAIL_WITH(m_input->LastRead() != 4, wxSOUND_INVSTRM);

    // Get the second signature
    FAIL_WITH(m_input->Read(&signature2, 4).LastRead() != 4, wxSOUND_INVSTRM);
    // Ungetch all
    m_input->Ungetch(&signature2, 4);
    m_input->Ungetch(&len, 4);
    m_input->Ungetch(&signature1, 4);

    // Test the second signature
    if (wxUINT32_SWAP_ON_BE(signature2) != WAVE_SIGNATURE)
        return FALSE;
    
    return TRUE;
}

bool wxSoundWave::HandleOutputPCM(wxDataInputStream& WXUNUSED(data), wxUint32 len,
                                  wxUint16 channels, 
                                  wxUint32 sample_fq, wxUint32 WXUNUSED(byte_p_sec),
                                  wxUint16 WXUNUSED(byte_p_spl), wxUint16 bits_p_spl)
{
    wxSoundFormatPcm sndformat;
    
    sndformat.SetSampleRate(sample_fq);
    sndformat.SetBPS(bits_p_spl);
    sndformat.SetChannels(channels);
    sndformat.Signed(TRUE);
    sndformat.SetOrder(wxLITTLE_ENDIAN);
    
    if (!SetSoundFormat(sndformat))
        return FALSE;
    
    m_input->SeekI(len, wxFromCurrent);

    return TRUE;
}

bool wxSoundWave::HandleOutputMSADPCM(wxDataInputStream& data, wxUint32 len,
                                      wxUint16 channels, 
                                      wxUint32 sample_fq, wxUint32 WXUNUSED(byte_p_sec),
                                      wxUint16 WXUNUSED(byte_p_spl), wxUint16 WXUNUSED(bits_p_spl))
{
    wxSoundFormatMSAdpcm sndformat;
    wxInt16 *coefs[2];
    wxUint16 coefs_len, i;
    wxUint16 block_size;
    
    sndformat.SetSampleRate(sample_fq);
    sndformat.SetChannels(channels);
    
    block_size = data.Read16();
    coefs_len = data.Read16();

    coefs[0] = new wxInt16[coefs_len];
    coefs[1] = new wxInt16[coefs_len];
    
    for (i=0;i<coefs_len;i++) {
        coefs[0][i] = data.Read16();
        coefs[1][i] = data.Read16();
    }

    sndformat.SetCoefs(coefs, 2, coefs_len);
    sndformat.SetBlockSize(block_size);

    delete[] coefs[0];
    delete[] coefs[1];
    
    if (!SetSoundFormat(sndformat))
        return FALSE;

    len -= coefs_len*4 + 4;
    
    m_input->SeekI(len, wxFromCurrent);
    
    return TRUE;
}

bool wxSoundWave::HandleOutputG721(wxDataInputStream& WXUNUSED(data), wxUint32 len,
                                   wxUint16 WXUNUSED(channels),
                                   wxUint32 sample_fq, wxUint32 WXUNUSED(byte_p_sec),
                                   wxUint16 WXUNUSED(byte_p_spl), wxUint16 WXUNUSED(bits_p_spl))
{
    wxSoundFormatG72X sndformat;
    
    sndformat.SetSampleRate(sample_fq);
    sndformat.SetG72XType(wxSOUND_G721);
    
    if (!SetSoundFormat(sndformat))
        return FALSE;
    
    m_input->SeekI(len, wxFromCurrent);

    return TRUE;
}

bool wxSoundWave::PrepareToPlay()
{
    wxUint32 signature, len;
    bool end_headers;
    
    if (!m_input) {
        m_snderror = wxSOUND_INVSTRM;
        return FALSE;
    }
    
    wxDataInputStream data(*m_input);
    data.BigEndianOrdered(FALSE);

    // Get the first signature
    FAIL_WITH(m_input->Read(&signature, 4).LastRead() != 4, wxSOUND_INVSTRM);
    FAIL_WITH(wxUINT32_SWAP_ON_BE(signature) != RIFF_SIGNATURE, wxSOUND_INVSTRM);
    // "RIFF"
    
    len = data.Read32();
    wxUnusedVar(len);
    FAIL_WITH(m_input->LastRead() != 4, wxSOUND_INVSTRM);
    // dummy len

    // Get the second signature
    FAIL_WITH(m_input->Read(&signature, 4).LastRead() != 4, wxSOUND_INVSTRM);
    FAIL_WITH(wxUINT32_SWAP_ON_BE(signature) != WAVE_SIGNATURE, wxSOUND_INVSTRM);
    // "WAVE"
    
    end_headers = FALSE;
    // Chunk loop
    while (!end_headers) {
        FAIL_WITH(m_input->Read(&signature, 4).LastRead() != 4, wxSOUND_INVSTRM);
        
        len = data.Read32();
        FAIL_WITH(m_input->LastRead() != 4, wxSOUND_INVSTRM);
        
        switch (wxUINT32_SWAP_ON_BE(signature)) {
            case FMT_SIGNATURE: {  // "fmt "
                wxUint16 format, channels, byte_p_spl, bits_p_spl;
                wxUint32 sample_fq, byte_p_sec;

                // Get the common parameters
                data >> format >> channels >> sample_fq 
                     >> byte_p_sec >> byte_p_spl >> bits_p_spl;
                len -= 16;
                
                switch (format) {
                    case 0x01: // PCM
                        if (!HandleOutputPCM(data, len, channels, sample_fq,
                                             byte_p_sec, byte_p_spl,
                                             bits_p_spl))
                            return FALSE;
                        break;
                    case 0x02: // MS ADPCM
                        if (!HandleOutputMSADPCM(data, len,
                                                 channels, sample_fq,
                                                 byte_p_sec, byte_p_spl,
                                                 bits_p_spl))
                            return FALSE;
                        break;
                    case 0x40: // G721
                        if (!HandleOutputG721(data, len,
                                              channels, sample_fq,
                                              byte_p_sec, byte_p_spl,
                                              bits_p_spl))
                            return FALSE;
                        break;
                    default: 
                        m_snderror = wxSOUND_NOCODEC;
                        return FALSE;
                }
                break;
            }
            case DATA_SIGNATURE: // "data"
                m_base_offset = m_input->TellI();
                end_headers = TRUE;
                FinishPreparation(len);
                break;
            default:
                // We pass the chunk
                m_input->SeekI(len, wxFromCurrent);
                break;
        }
    }
    return TRUE;
}

wxSoundFormatBase *wxSoundWave::HandleInputPCM(wxDataOutputStream& data)
{
    wxUint16 format, channels, byte_p_spl, bits_p_spl;
    wxUint32 sample_fq, byte_p_sec;
    wxSoundFormatPcm *pcm;
    
    pcm = (wxSoundFormatPcm *)(m_sndformat->Clone());
    
    // Write block length
    data.Write32(16);
    
    sample_fq  = pcm->GetSampleRate();
    bits_p_spl = pcm->GetBPS();
    channels   = pcm->GetChannels();
    byte_p_spl = pcm->GetBPS() / 8;
    byte_p_sec = pcm->GetBytesFromTime(1);
    format     = 0x01;
    
    pcm->Signed(TRUE);
    pcm->SetOrder(wxLITTLE_ENDIAN);
    
    data << format << channels << sample_fq
         << byte_p_sec << byte_p_spl << bits_p_spl;
    
    return pcm;
}

wxSoundFormatBase *wxSoundWave::HandleInputG72X(wxDataOutputStream& data)
{
    wxUint16 format, channels, byte_p_spl, bits_p_spl;
    wxUint32 sample_fq, byte_p_sec;
    wxSoundFormatG72X *g72x;
    
    // Write block length
    data.Write32(16);
    
    g72x = (wxSoundFormatG72X *)(m_sndformat->Clone());
    if (g72x->GetG72XType() != wxSOUND_G721) {
        delete g72x;
        return NULL;
    } 
    
    sample_fq  = g72x->GetSampleRate();
    bits_p_spl = 4;
    channels   = 1;
    byte_p_spl = 0;
    byte_p_sec = g72x->GetBytesFromTime(1);
    format     = 0x40;
    data << format << channels << sample_fq
         << byte_p_sec << byte_p_spl << bits_p_spl;
    
    return g72x;
}

bool wxSoundWave::PrepareToRecord(wxUint32 time)
{
#define WRITE_SIGNATURE(s,sig) \
signature = sig; \
signature = wxUINT32_SWAP_ON_BE(signature); \
FAIL_WITH(s->Write(&signature, 4).LastWrite() != 4, wxSOUND_INVSTRM);
    
    wxUint32 signature;
    wxMemoryOutputStream fmt_data;
    
    if (!m_output) {
        m_snderror = wxSOUND_INVSTRM;
        return FALSE;
    }
    
    wxDataOutputStream data(*m_output);
    wxDataOutputStream fmt_d_data(fmt_data);
    
    data.BigEndianOrdered(FALSE);
    fmt_d_data.BigEndianOrdered(FALSE);
    
    WRITE_SIGNATURE(m_output, RIFF_SIGNATURE);
    
    FAIL_WITH(m_output->LastWrite() != 4, wxSOUND_INVSTRM);
    
    WRITE_SIGNATURE((&fmt_data), WAVE_SIGNATURE);
    
    {
        wxSoundFormatBase *frmt;
        
        WRITE_SIGNATURE((&fmt_data), FMT_SIGNATURE);
        
        switch (m_sndformat->GetType()) {
            case wxSOUND_PCM:
                frmt = HandleInputPCM(fmt_d_data);
                break;
            case wxSOUND_G72X:
                frmt = HandleInputG72X(fmt_d_data);
                break;
            default:
                m_snderror = wxSOUND_NOCODEC;
                return FALSE;
        }
        
        FAIL_WITH(!frmt, wxSOUND_NOCODEC);
        
        if (!SetSoundFormat(*frmt)) {
            delete frmt;
            return FALSE;
        }
        
        delete frmt;
    }
    
    data << (fmt_data.GetSize() + m_sndformat->GetBytesFromTime(time));

    // We, finally, copy the header block to the output stream 
    {
        char *out_buf;
        out_buf = new char[fmt_data.GetSize()];
        
        fmt_data.CopyTo(out_buf, fmt_data.GetSize());
        m_output->Write(out_buf, fmt_data.GetSize());
        
        delete[] out_buf;
    }
    
    WRITE_SIGNATURE(m_output, DATA_SIGNATURE);
    data.Write32(m_sndformat->GetBytesFromTime(time));
    return TRUE;
}

bool wxSoundWave::FinishRecording()
{
    if (m_output->SeekO(0, wxFromStart) == wxInvalidOffset)
        // We can't but there is no error.
        return TRUE;
    
    if (m_bytes_left == 0)
        return TRUE;
    
    // TODO: Update headers when we stop before the specified time (if possible)
    return TRUE;
}

bool wxSoundWave::RepositionStream(wxUint32 WXUNUSED(position))
{
    if (m_base_offset == wxInvalidOffset)
        return FALSE;
    m_input->SeekI(m_base_offset, wxFromStart);
    return TRUE;
}

wxUint32 wxSoundWave::GetData(void *buffer, wxUint32 len)
{
    return m_input->Read(buffer, len).LastRead();
}

wxUint32 wxSoundWave::PutData(const void *buffer, wxUint32 len)
{
    return m_output->Write(buffer, len).LastWrite();
}
Commit	Line	Data
e8482f24 GL	1	// --------------------------------------------------------------------------
	2	// Name: sndwav.cpp
	3	// Purpose:
	4	// Date: 08/11/1999
	5	// Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 1999
	6	// CVSID: $Id$
	7	// --------------------------------------------------------------------------
	8	#ifdef __GNUG__
	9	#pragma implementation "sndwav.cpp"
	10	#endif
	11
92a19c2e	12	#include "wx/wxprec.h"
e8482f24 GL	13
	14	#ifndef WX_PRECOMP
	15	#include "wx/defs.h"
	16	#endif
	17
	18	#ifdef __BORLANDC__
	19	#pragma hdrstop
	20	#endif
	21
	22	#include "wx/stream.h"
	23	#include "wx/datstrm.h"
	24	#include "wx/filefn.h"
	25	#include "wx/mstream.h"
	26
	27	#include "wx/mmedia/sndbase.h"
	28	#include "wx/mmedia/sndcodec.h"
	29	#include "wx/mmedia/sndfile.h"
	30	#include "wx/mmedia/sndpcm.h"
	31	#include "wx/mmedia/sndg72x.h"
c42b1de6	32	#include "wx/mmedia/sndmsad.h"
e8482f24 GL	33	#include "wx/mmedia/sndwav.h"
	34
	35	#define BUILD_SIGNATURE(a,b,c,d) (((wxUint32)a) \| (((wxUint32)b) << 8) \| (((wxUint32)c) << 16) \| (((wxUint32)d) << 24))
	36
	37	#define RIFF_SIGNATURE BUILD_SIGNATURE('R','I','F','F')
	38	#define WAVE_SIGNATURE BUILD_SIGNATURE('W','A','V','E')
	39	#define FMT_SIGNATURE BUILD_SIGNATURE('f','m','t',' ')
	40	#define DATA_SIGNATURE BUILD_SIGNATURE('d','a','t','a')
	41
	42	#define HEADER_SIZE 4+4 + 4+4+16 + 4+4
	43	// 4+4 => NAME + LEN
	44	// 16 => fmt size
	45
	46	wxSoundWave::wxSoundWave(wxInputStream& stream, wxSoundStream& io_sound)
	47	: wxSoundFileStream(stream, io_sound)
	48	{
	49	m_base_offset = wxInvalidOffset;
	50	}
	51
	52	wxSoundWave::wxSoundWave(wxOutputStream& stream, wxSoundStream& io_sound)
	53	: wxSoundFileStream(stream, io_sound)
	54	{
	55	m_base_offset = wxInvalidOffset;
	56	}
	57
	58	wxSoundWave::~wxSoundWave()
	59	{
	60	}
	61
	62	wxString wxSoundWave::GetCodecName() const
	63	{
	64	return wxString(wxT("wxSoundWave codec"));
	65	}
	66
	67	#define FAIL_WITH(condition, err) if (condition) { m_snderror = err; return FALSE; }
	68
	69	bool wxSoundWave::CanRead()
	70	{
	71	wxUint32 len, signature1, signature2;
	72	m_snderror = wxSOUND_NOERROR;
	73
	74	// Test the main signatures:
	75	// "RIFF"
	76	FAIL_WITH(m_input->Read(&signature1, 4).LastRead() != 4, wxSOUND_INVSTRM);
	77
	78	if (wxUINT32_SWAP_ON_BE(signature1) != RIFF_SIGNATURE) {
	79	m_input->Ungetch(&signature1, 4);
	80	return FALSE;
	81	}
	82
	83	// Pass the global length
	84	m_input->Read(&len, 4);
	85	FAIL_WITH(m_input->LastRead() != 4, wxSOUND_INVSTRM);
	86
	87	// Get the second signature
	88	FAIL_WITH(m_input->Read(&signature2, 4).LastRead() != 4, wxSOUND_INVSTRM);
	89	// Ungetch all
	90	m_input->Ungetch(&signature2, 4);
	91	m_input->Ungetch(&len, 4);
	92	m_input->Ungetch(&signature1, 4);
	93
	94	// Test the second signature
	95	if (wxUINT32_SWAP_ON_BE(signature2) != WAVE_SIGNATURE)
	96	return FALSE;
97
98	return TRUE;
99	}
100
42c37dec	101	bool wxSoundWave::HandleOutputPCM(wxDataInputStream& WXUNUSED(data), wxUint32 len,
c42b1de6	102	wxUint16 channels,
42c37dec VS	103	wxUint32 sample_fq, wxUint32 WXUNUSED(byte_p_sec),
42c37dec VS	104	wxUint16 WXUNUSED(byte_p_spl), wxUint16 bits_p_spl)
e8482f24 GL	105	{
	106	wxSoundFormatPcm sndformat;
	107
	108	sndformat.SetSampleRate(sample_fq);
	109	sndformat.SetBPS(bits_p_spl);
	110	sndformat.SetChannels(channels);
	111	sndformat.Signed(TRUE);
	112	sndformat.SetOrder(wxLITTLE_ENDIAN);
	113
	114	if (!SetSoundFormat(sndformat))
	115	return FALSE;
	116
c42b1de6 GL	117	m_input->SeekI(len, wxFromCurrent);
c42b1de6 GL	118
e8482f24 GL	119	return TRUE;
	120	}
	121
c42b1de6 GL	122	bool wxSoundWave::HandleOutputMSADPCM(wxDataInputStream& data, wxUint32 len,
c42b1de6 GL	123	wxUint16 channels,
42c37dec VS	124	wxUint32 sample_fq, wxUint32 WXUNUSED(byte_p_sec),
42c37dec VS	125	wxUint16 WXUNUSED(byte_p_spl), wxUint16 WXUNUSED(bits_p_spl))
c42b1de6 GL	126	{
	127	wxSoundFormatMSAdpcm sndformat;
	128	wxInt16 *coefs[2];
	129	wxUint16 coefs_len, i;
	130	wxUint16 block_size;
	131
	132	sndformat.SetSampleRate(sample_fq);
	133	sndformat.SetChannels(channels);
	134
	135	block_size = data.Read16();
	136	coefs_len = data.Read16();
	137
	138	coefs[0] = new wxInt16[coefs_len];
	139	coefs[1] = new wxInt16[coefs_len];
	140
	141	for (i=0;i<coefs_len;i++) {
	142	coefs[0][i] = data.Read16();
	143	coefs[1][i] = data.Read16();
	144	}
	145
	146	sndformat.SetCoefs(coefs, 2, coefs_len);
	147	sndformat.SetBlockSize(block_size);
	148
	149	delete[] coefs[0];
	150	delete[] coefs[1];
	151
	152	if (!SetSoundFormat(sndformat))
	153	return FALSE;
	154
	155	len -= coefs_len*4 + 4;
	156
	157	m_input->SeekI(len, wxFromCurrent);
	158
	159	return TRUE;
	160	}
	161
42c37dec VS	162	bool wxSoundWave::HandleOutputG721(wxDataInputStream& WXUNUSED(data), wxUint32 len,
	163	wxUint16 WXUNUSED(channels),
	164	wxUint32 sample_fq, wxUint32 WXUNUSED(byte_p_sec),
	165	wxUint16 WXUNUSED(byte_p_spl), wxUint16 WXUNUSED(bits_p_spl))
e8482f24 GL	166	{
	167	wxSoundFormatG72X sndformat;
	168
	169	sndformat.SetSampleRate(sample_fq);
	170	sndformat.SetG72XType(wxSOUND_G721);
	171
	172	if (!SetSoundFormat(sndformat))
	173	return FALSE;
	174
c42b1de6 GL	175	m_input->SeekI(len, wxFromCurrent);
c42b1de6 GL	176
e8482f24 GL	177	return TRUE;
	178	}
	179
	180	bool wxSoundWave::PrepareToPlay()
	181	{
	182	wxUint32 signature, len;
	183	bool end_headers;
	184
	185	if (!m_input) {
	186	m_snderror = wxSOUND_INVSTRM;
	187	return FALSE;
	188	}
	189
	190	wxDataInputStream data(*m_input);
	191	data.BigEndianOrdered(FALSE);
	192
	193	// Get the first signature
	194	FAIL_WITH(m_input->Read(&signature, 4).LastRead() != 4, wxSOUND_INVSTRM);
	195	FAIL_WITH(wxUINT32_SWAP_ON_BE(signature) != RIFF_SIGNATURE, wxSOUND_INVSTRM);
	196	// "RIFF"
	197
	198	len = data.Read32();
2b3644c7	199	wxUnusedVar(len);
e8482f24 GL	200	FAIL_WITH(m_input->LastRead() != 4, wxSOUND_INVSTRM);
	201	// dummy len
	202
	203	// Get the second signature
	204	FAIL_WITH(m_input->Read(&signature, 4).LastRead() != 4, wxSOUND_INVSTRM);
	205	FAIL_WITH(wxUINT32_SWAP_ON_BE(signature) != WAVE_SIGNATURE, wxSOUND_INVSTRM);
	206	// "WAVE"
	207
	208	end_headers = FALSE;
	209	// Chunk loop
	210	while (!end_headers) {
	211	FAIL_WITH(m_input->Read(&signature, 4).LastRead() != 4, wxSOUND_INVSTRM);
	212
	213	len = data.Read32();
	214	FAIL_WITH(m_input->LastRead() != 4, wxSOUND_INVSTRM);
	215
	216	switch (wxUINT32_SWAP_ON_BE(signature)) {
	217	case FMT_SIGNATURE: { // "fmt "
	218	wxUint16 format, channels, byte_p_spl, bits_p_spl;
	219	wxUint32 sample_fq, byte_p_sec;
	220
	221	// Get the common parameters
	222	data >> format >> channels >> sample_fq
	223	>> byte_p_sec >> byte_p_spl >> bits_p_spl;
c42b1de6	224	len -= 16;
e8482f24 GL	225
	226	switch (format) {
	227	case 0x01: // PCM
c42b1de6 GL	228	if (!HandleOutputPCM(data, len, channels, sample_fq,
	229	byte_p_sec, byte_p_spl,
	230	bits_p_spl))
	231	return FALSE;
	232	break;
	233	case 0x02: // MS ADPCM
	234	if (!HandleOutputMSADPCM(data, len,
	235	channels, sample_fq,
	236	byte_p_sec, byte_p_spl,
	237	bits_p_spl))
e8482f24 GL	238	return FALSE;
	239	break;
	240	case 0x40: // G721
c42b1de6 GL	241	if (!HandleOutputG721(data, len,
	242	channels, sample_fq,
	243	byte_p_sec, byte_p_spl,
	244	bits_p_spl))
e8482f24 GL	245	return FALSE;
	246	break;
	247	default:
	248	m_snderror = wxSOUND_NOCODEC;
	249	return FALSE;
	250	}
	251	break;
	252	}
	253	case DATA_SIGNATURE: // "data"
	254	m_base_offset = m_input->TellI();
	255	end_headers = TRUE;
	256	FinishPreparation(len);
	257	break;
	258	default:
	259	// We pass the chunk
	260	m_input->SeekI(len, wxFromCurrent);
	261	break;
	262	}
	263	}
	264	return TRUE;
	265	}
	266
	267	wxSoundFormatBase *wxSoundWave::HandleInputPCM(wxDataOutputStream& data)
	268	{
	269	wxUint16 format, channels, byte_p_spl, bits_p_spl;
	270	wxUint32 sample_fq, byte_p_sec;
	271	wxSoundFormatPcm *pcm;
	272
	273	pcm = (wxSoundFormatPcm *)(m_sndformat->Clone());
	274
	275	// Write block length
	276	data.Write32(16);
	277
	278	sample_fq = pcm->GetSampleRate();
	279	bits_p_spl = pcm->GetBPS();
	280	channels = pcm->GetChannels();
	281	byte_p_spl = pcm->GetBPS() / 8;
	282	byte_p_sec = pcm->GetBytesFromTime(1);
	283	format = 0x01;
	284
	285	pcm->Signed(TRUE);
	286	pcm->SetOrder(wxLITTLE_ENDIAN);
	287
	288	data << format << channels << sample_fq
	289	<< byte_p_sec << byte_p_spl << bits_p_spl;
	290
	291	return pcm;
	292	}
	293
	294	wxSoundFormatBase *wxSoundWave::HandleInputG72X(wxDataOutputStream& data)
	295	{
	296	wxUint16 format, channels, byte_p_spl, bits_p_spl;
	297	wxUint32 sample_fq, byte_p_sec;
	298	wxSoundFormatG72X *g72x;
	299
	300	// Write block length
	301	data.Write32(16);
	302
	303	g72x = (wxSoundFormatG72X *)(m_sndformat->Clone());
	304	if (g72x->GetG72XType() != wxSOUND_G721) {
	305	delete g72x;
	306	return NULL;
	307	}
	308
309	sample_fq = g72x->GetSampleRate();
310	bits_p_spl = 4;
311	channels = 1;
312	byte_p_spl = 0;
313	byte_p_sec = g72x->GetBytesFromTime(1);
314	format = 0x40;
315	data << format << channels << sample_fq
316	<< byte_p_sec << byte_p_spl << bits_p_spl;
317
318	return g72x;
319	}
320
321	bool wxSoundWave::PrepareToRecord(wxUint32 time)
322	{
323	#define WRITE_SIGNATURE(s,sig) \
324	signature = sig; \
325	signature = wxUINT32_SWAP_ON_BE(signature); \
326	FAIL_WITH(s->Write(&signature, 4).LastWrite() != 4, wxSOUND_INVSTRM);
327
328	wxUint32 signature;
329	wxMemoryOutputStream fmt_data;
330
331	if (!m_output) {
332	m_snderror = wxSOUND_INVSTRM;
333	return FALSE;
334	}
335
336	wxDataOutputStream data(*m_output);
337	wxDataOutputStream fmt_d_data(fmt_data);
338
339	data.BigEndianOrdered(FALSE);
340	fmt_d_data.BigEndianOrdered(FALSE);
341
342	WRITE_SIGNATURE(m_output, RIFF_SIGNATURE);
343
344	FAIL_WITH(m_output->LastWrite() != 4, wxSOUND_INVSTRM);
345
346	WRITE_SIGNATURE((&fmt_data), WAVE_SIGNATURE);
347
348	{
349	wxSoundFormatBase *frmt;
350
351	WRITE_SIGNATURE((&fmt_data), FMT_SIGNATURE);
352
353	switch (m_sndformat->GetType()) {
354	case wxSOUND_PCM:
355	frmt = HandleInputPCM(fmt_d_data);
356	break;
357	case wxSOUND_G72X:
358	frmt = HandleInputG72X(fmt_d_data);
359	break;
360	default:
361	m_snderror = wxSOUND_NOCODEC;
362	return FALSE;
363	}
364
365	FAIL_WITH(!frmt, wxSOUND_NOCODEC);
366
367	if (!SetSoundFormat(*frmt)) {
368	delete frmt;
369	return FALSE;
370	}
371
372	delete frmt;
373	}
374
375	data << (fmt_data.GetSize() + m_sndformat->GetBytesFromTime(time));
376
377	// We, finally, copy the header block to the output stream
378	{
379	char *out_buf;
380	out_buf = new char[fmt_data.GetSize()];
381
382	fmt_data.CopyTo(out_buf, fmt_data.GetSize());
383	m_output->Write(out_buf, fmt_data.GetSize());
384
385	delete[] out_buf;
386	}
387
388	WRITE_SIGNATURE(m_output, DATA_SIGNATURE);
389	data.Write32(m_sndformat->GetBytesFromTime(time));
390	return TRUE;
391	}
392
393	bool wxSoundWave::FinishRecording()
394	{
395	if (m_output->SeekO(0, wxFromStart) == wxInvalidOffset)
396	// We can't but there is no error.
397	return TRUE;
398
399	if (m_bytes_left == 0)
400	return TRUE;
401
402	// TODO: Update headers when we stop before the specified time (if possible)
403	return TRUE;
404	}
405
42c37dec	406	bool wxSoundWave::RepositionStream(wxUint32 WXUNUSED(position))
e8482f24 GL	407	{
	408	if (m_base_offset == wxInvalidOffset)
	409	return FALSE;
	410	m_input->SeekI(m_base_offset, wxFromStart);
	411	return TRUE;
	412	}
	413
	414	wxUint32 wxSoundWave::GetData(void *buffer, wxUint32 len)
	415	{
	416	return m_input->Read(buffer, len).LastRead();
	417	}
	418
	419	wxUint32 wxSoundWave::PutData(const void *buffer, wxUint32 len)
	420	{
	421	return m_output->Write(buffer, len).LastWrite();
	422	}