]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/mmedia/sndg72x.cpp
Defaults in wxWinCE documented.
[wxWidgets.git] / contrib / src / mmedia / sndg72x.cpp
1 // --------------------------------------------------------------------------
2 // Name: sndg72x.cpp
3 // Purpose:
4 // Date: 08/26/1999
5 // Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 1999
6 // CVSID: $Id$
7 // wxWindows licence
8 // --------------------------------------------------------------------------
9 #ifdef __GNUG__
10 #pragma implementation "sndg72x.cpp"
11 #endif
12
13 #include "wx/wxprec.h"
14
15 #ifndef WX_PRECOMP
16 #include "wx/defs.h"
17 #endif
18
19 #include "wx/mmedia/sndbase.h"
20 #include "wx/mmedia/sndfile.h"
21 #include "wx/mmedia/sndpcm.h"
22 #include "wx/mmedia/sndg72x.h"
23 #include "wx/mmedia/internal/g72x.h"
24
25 // --------------------------------------------------------------------------
26 // wxSoundFormatG72X
27 // --------------------------------------------------------------------------
28
29 wxSoundFormatG72X::wxSoundFormatG72X()
30 : m_srate(22050)
31 {
32 }
33
34 wxSoundFormatG72X::~wxSoundFormatG72X()
35 {
36 }
37
38 void wxSoundFormatG72X::SetSampleRate(wxUint32 srate)
39 {
40 m_srate = srate;
41 }
42
43 wxUint32 wxSoundFormatG72X::GetSampleRate() const
44 {
45 return m_srate;
46 }
47
48 void wxSoundFormatG72X::SetG72XType(wxSoundG72XType type)
49 {
50 m_g72x_type = type;
51 }
52
53 wxSoundFormatBase *wxSoundFormatG72X::Clone() const
54 {
55 wxSoundFormatG72X *g72x = new wxSoundFormatG72X();
56
57 g72x->m_srate = m_srate;
58 g72x->m_g72x_type = m_g72x_type;
59 return g72x;
60 }
61
62 wxUint32 wxSoundFormatG72X::GetTimeFromBytes(wxUint32 bytes) const
63 {
64 int n_bits;
65
66 switch (m_g72x_type) {
67 case wxSOUND_G721:
68 n_bits = 4;
69 break;
70 case wxSOUND_G723_24:
71 n_bits = 3;
72 break;
73 case wxSOUND_G723_40:
74 n_bits = 5;
75 break;
76 default:
77 n_bits = 0;
78 break;
79 }
80 return (wxUint32)((bytes / m_srate) * n_bits) / 8;
81 }
82
83 wxUint32 wxSoundFormatG72X::GetBytesFromTime(wxUint32 time) const
84 {
85 int n_bits;
86
87 switch (m_g72x_type) {
88 case wxSOUND_G721:
89 n_bits = 4;
90 break;
91 case wxSOUND_G723_24:
92 n_bits = 3;
93 break;
94 case wxSOUND_G723_40:
95 n_bits = 5;
96 break;
97 default:
98 n_bits = 0;
99 }
100 return (wxUint32)((time * m_srate * n_bits) / 8);
101 }
102
103 bool wxSoundFormatG72X::operator !=(const wxSoundFormatBase& frmt2) const
104 {
105 wxSoundFormatG72X *g72x = (wxSoundFormatG72X *)&frmt2;
106
107 if (frmt2.GetType() != wxSOUND_G72X)
108 return true;
109
110 return (g72x->m_srate != m_srate || g72x->m_g72x_type != m_g72x_type);
111 }
112
113 // --------------------------------------------------------------------------
114 // wxSoundStreamG72X
115 // --------------------------------------------------------------------------
116
117 wxSoundStreamG72X::wxSoundStreamG72X(wxSoundStream& sndio)
118 : wxSoundStreamCodec(sndio)
119 {
120 // PCM converter
121 m_router = new wxSoundRouterStream(sndio);
122 m_state = new g72state;
123 g72x_init_state(m_state);
124 }
125
126 wxSoundStreamG72X::~wxSoundStreamG72X()
127 {
128 delete m_router;
129 }
130
131 wxSoundStream& wxSoundStreamG72X::Read(void *buffer, wxUint32 len)
132 {
133 wxUint16 *old_linear;
134 register wxUint16 *linear_buffer;
135 register wxUint32 real_len;
136 register wxUint32 countdown = len;
137
138 real_len = (len * 8 / m_n_bits);
139
140 old_linear = linear_buffer = new wxUint16[real_len];
141
142 m_router->Read(linear_buffer, real_len);
143
144 real_len = (wxUint32)(m_router->GetLastAccess() * ((float)m_n_bits / 8));
145 if (!real_len)
146 return *m_router;
147
148 m_io_buffer = (wxUint8 *)buffer;
149 m_current_b_pos = 0;
150
151 while (countdown != 0) {
152 PutBits(m_coder(*linear_buffer++, AUDIO_ENCODING_LINEAR, m_state));
153 countdown--;
154 }
155 m_lastcount = real_len;
156 m_snderror = m_router->GetError();
157
158 delete[] old_linear;
159
160 return *this;
161 }
162
163 wxSoundStream& wxSoundStreamG72X::Write(const void *buffer, wxUint32 len)
164 {
165 wxUint16 *old_linear;
166 register wxUint16 *linear_buffer;
167 register wxUint32 countdown = len;
168 register wxUint32 real_len;
169
170 // Compute the real length (PCM format) to sendt to the sound card
171 real_len = (len * m_n_bits / 8);
172
173 // Allocate a temporary buffer
174 old_linear = linear_buffer = new wxUint16[real_len];
175
176 // Bad, we override the const
177 m_io_buffer = (wxUint8 *)buffer;
178 m_current_b_pos = 0;
179
180 // Decode the datas
181 while (countdown != 0) {
182 *linear_buffer++ = m_decoder(GetBits(), AUDIO_ENCODING_LINEAR, m_state);
183 countdown--;
184 }
185 m_lastcount = len;
186
187 // Send them to the sound card
188 m_router->Write(old_linear, real_len);
189
190 // Destroy the temporary buffer
191 delete[] old_linear;
192
193 return *m_router;
194 }
195
196 bool wxSoundStreamG72X::SetSoundFormat(const wxSoundFormatBase& format)
197 {
198 if (format.GetType() != wxSOUND_G72X) {
199 m_snderror = wxSOUND_INVFRMT;
200 return false;
201 }
202
203 wxSoundFormatPcm pcm;
204 wxSoundFormatG72X *g72x;
205
206 wxSoundStreamCodec::SetSoundFormat(format);
207
208 g72x = (wxSoundFormatG72X *)m_sndformat;
209
210 // Set PCM as the output format of the codec
211 pcm.SetSampleRate(g72x->GetSampleRate());
212 pcm.SetBPS(16);
213 pcm.SetChannels(1); // Only mono supported
214 pcm.Signed(true);
215 pcm.SetOrder(wxBYTE_ORDER);
216
217 // Look for the correct codec to use and set its bit width
218 switch (g72x->GetG72XType()) {
219 case wxSOUND_G721:
220 m_n_bits = 4;
221 m_coder = g721_encoder;
222 m_decoder = g721_decoder;
223 break;
224 case wxSOUND_G723_24:
225 m_n_bits = 3;
226 m_coder = g723_24_encoder;
227 m_decoder = g723_24_decoder;
228 break;
229 case wxSOUND_G723_40:
230 m_n_bits = 5;
231 m_coder = g723_40_encoder;
232 m_decoder = g723_40_decoder;
233 break;
234 }
235
236 // Let the router finish the work
237 m_router->SetSoundFormat(pcm);
238
239 return true;
240 }
241
242 #define BYTE_SIZE 8
243
244 wxUint8 wxSoundStreamG72X::GetBits()
245 {
246 register wxUint8 bits;
247
248 // We have two bytes to compute
249 if (m_current_b_pos < m_n_bits) {
250 register wxUint8 b_left;
251
252 // TRANSLATE the mask
253 m_current_mask >>= m_current_b_pos;
254
255 // GET the last bits: 0001..1
256 bits = (m_current_byte & m_current_mask) << (m_n_bits - m_current_b_pos);
257
258 // GEN: 1. n times .1000
259 b_left = BYTE_SIZE-m_n_bits;
260 m_current_mask = ((1 << m_n_bits) - 1) << b_left;
261
262 // GET the next byte
263 m_current_byte = *m_io_buffer++;
264
265 register wxUint8 tmp_mask;
266
267 // COMPUTE a new temporary mask to get the last bits
268 b_left = m_n_bits - b_left;
269 tmp_mask = (1 << b_left) - 1;
270 // TRANSLATE the old mask to get ready for the next time
271 m_current_mask >>= b_left;
272
273 // COMPUTE the new bit position
274 b_left = BYTE_SIZE - b_left;
275 m_current_b_pos = b_left;
276 tmp_mask <<= b_left;
277
278 // GET the last bits
279 bits |= (m_current_byte & tmp_mask) >> b_left;
280 } else {
281 m_current_mask >>= m_n_bits;
282 m_current_b_pos -= m_n_bits;
283 bits = (m_current_byte & m_current_mask) >> m_current_b_pos;
284 }
285 return bits;
286 }
287
288 void wxSoundStreamG72X::PutBits(wxUint8 bits)
289 {
290 if (m_current_b_pos < m_n_bits) {
291 register wxUint8 tmp_mask;
292 register wxUint8 diff;
293
294 diff = m_n_bits - m_current_b_pos;
295 // Pack bits and put the byte in the buffer
296 m_current_byte |= bits >> diff;
297 *m_io_buffer++ = m_current_byte;
298
299 // Gen a mask
300 tmp_mask = ~((1 << diff) - 1);
301
302 m_current_b_pos = BYTE_SIZE - (m_n_bits - m_current_b_pos);
303
304 m_current_byte = (bits & (tmp_mask)) << m_current_b_pos;
305 } else {
306 m_current_b_pos -= m_n_bits;
307 bits <<= m_current_b_pos;
308 m_current_byte |= bits;
309 }
310 }