Main
Current News
Archived News
Search News
Forums
Discussion Forum


Old Forum
Programs
Install Programs
Downloads
More Downloads...
Troubleshooting
Other Sections
Source Code
Format Specs.
Misc. Information
Non-SF Stuff
Links



projects / SComp.git / blame
? search:
summary | graphiclog | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
Fix a couple of warnings
[SComp.git] / wave.cpp
CommitLineData
3e09a0ee 1/*****************************************************************************/
2/* wave.cpp Copyright (c) Ladislav Zezula 2003 */
3/*---------------------------------------------------------------------------*/
4/* This module contains decompression methods used by Storm.dll to decompress*/
5/* WAVe files. Thanks to Tom Amigo for releasing his sources. */
6/*---------------------------------------------------------------------------*/
7/* Date Ver Who Comment */
8/* -------- ---- --- ------- */
9/* 11.03.03 1.00 Lad Splitted from Pkware.cpp */
10/* 20.05.03 2.00 Lad Added compression */
11/*****************************************************************************/
12
13#include "wave.h"
14
15//------------------------------------------------------------------------------
16// Structures
17
18union TByteAndWordPtr
19{
20 unsigned short * pw;
21 unsigned char * pb;
22};
23
24//-----------------------------------------------------------------------------
25// Tables necessary dor decompression
26
27static unsigned long Table1503F120[] =
28{
29 0xFFFFFFFF, 0x00000000, 0xFFFFFFFF, 0x00000004, 0xFFFFFFFF, 0x00000002, 0xFFFFFFFF, 0x00000006,
30 0xFFFFFFFF, 0x00000001, 0xFFFFFFFF, 0x00000005, 0xFFFFFFFF, 0x00000003, 0xFFFFFFFF, 0x00000007,
31 0xFFFFFFFF, 0x00000001, 0xFFFFFFFF, 0x00000005, 0xFFFFFFFF, 0x00000003, 0xFFFFFFFF, 0x00000007,
32 0xFFFFFFFF, 0x00000002, 0xFFFFFFFF, 0x00000004, 0xFFFFFFFF, 0x00000006, 0xFFFFFFFF, 0x00000008
33};
34
35static unsigned long Table1503F1A0[] =
36{
37 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E,
38 0x00000010, 0x00000011, 0x00000013, 0x00000015, 0x00000017, 0x00000019, 0x0000001C, 0x0000001F,
39 0x00000022, 0x00000025, 0x00000029, 0x0000002D, 0x00000032, 0x00000037, 0x0000003C, 0x00000042,
40 0x00000049, 0x00000050, 0x00000058, 0x00000061, 0x0000006B, 0x00000076, 0x00000082, 0x0000008F,
41 0x0000009D, 0x000000AD, 0x000000BE, 0x000000D1, 0x000000E6, 0x000000FD, 0x00000117, 0x00000133,
42 0x00000151, 0x00000173, 0x00000198, 0x000001C1, 0x000001EE, 0x00000220, 0x00000256, 0x00000292,
43 0x000002D4, 0x0000031C, 0x0000036C, 0x000003C3, 0x00000424, 0x0000048E, 0x00000502, 0x00000583,
44 0x00000610, 0x000006AB, 0x00000756, 0x00000812, 0x000008E0, 0x000009C3, 0x00000ABD, 0x00000BD0,
45 0x00000CFF, 0x00000E4C, 0x00000FBA, 0x0000114C, 0x00001307, 0x000014EE, 0x00001706, 0x00001954,
46 0x00001BDC, 0x00001EA5, 0x000021B6, 0x00002515, 0x000028CA, 0x00002CDF, 0x0000315B, 0x0000364B,
47 0x00003BB9, 0x000041B2, 0x00004844, 0x00004F7E, 0x00005771, 0x0000602F, 0x000069CE, 0x00007462,
48 0x00007FFF
49};
50
51//----------------------------------------------------------------------------
52// CompressWave
53
54int CompressWave(unsigned char * pbOutBuffer, int dwOutLength, short * pwInBuffer, int dwInLength, int nChannels, int nCmpLevel)
55{
56 TByteAndWordPtr out; // Output buffer
57 long nArray3[2]; // EBP-48
58 long nArray2[2]; // EBP-40
59 long nArray1[2]; // EBP-38
60 long nWords; // EBP-30
61 unsigned EBP2C; // EBP-2C
62 long nRemains = dwOutLength; // EBP-28 : Number of bytes remaining
63 long nCmpType2; // EBP-24
64 unsigned dwStopBit; // EBP-20
65 long EBP1C; // EBP-1C
66 unsigned dwBitBuff; // EBP-18
67// char * pbOutPos = pbOutBuffer; // EBP-14 : Saved pointer to the output buffer
68 long nLength; // EBP-10 :
69 long nIndex; // EBP-0C :
70// short * pwOutPos = pwInBuffer; // EBP-08 : Current output pointer
71 // EBP-04 :
72 unsigned short wCmp; // EBP-02 :
73 unsigned dwBit; // EBP+08 : A Bit
74 long nTableValue;
75 long nOneWord;
76 long nValue;
77
78 if(dwInLength < 2)
79 return 2;
80
81 // ebx = nChannels;
82 wCmp = (unsigned char)(nCmpLevel - 1);
83 out.pb = pbOutBuffer;
84 *out.pb++ = 0;
85 *out.pb++ = (unsigned char)wCmp;
86
87 if((out.pb - pbOutBuffer + nChannels * 2) > nRemains)
88 return out.pb - pbOutBuffer + nChannels * 2;
89
90 nArray1[0] = nArray1[1] = 0x2C;
91
92 if(nChannels > 0)
93 {
94 for(int i = 0; i < nChannels; i++)
95 {
96 nOneWord = *pwInBuffer++;
97 *out.pw++ = (unsigned short)nOneWord;
98 nArray2[i] = nOneWord;
99 }
100 }
101
102 nLength = dwInLength;
103 if(nLength < 0) // mov eax, dwInLength; cdq; sub eax, edx;
104 nLength++;
105 nLength = (nLength / 2) - (out.pb - pbOutBuffer);
106 nLength = (nLength < 0) ? 0 : nLength;
107 nCmpType2 = nChannels;
108
109 nIndex = nChannels - 1; // edi
110 nWords = dwInLength / 2; // eax
111 if(nWords <= nChannels)
112 return out.pb - pbOutBuffer;
113
114 // ebx - nChannels
115 // ecx - pwOutPos
116 do // 1500F02D
117 {
118 if((out.pb - pbOutBuffer + 2) > nRemains)
119 return out.pb - pbOutBuffer + 2;
120
121 if(nChannels == 2)
122 nIndex = (nIndex == 0) ? 1 : 0;
123
124 nOneWord = *pwInBuffer++; // ecx - nOneWord
125 // esi - nArray2[nIndex]
126 nValue = nOneWord - nArray2[nIndex];
127 if(nValue < 0)
128 nValue = ~nValue + 1; // eax
129
130 unsigned ebx = (nOneWord >= nArray2[nIndex]) ? 1 : 0;
131 // esi - nArray1[nIndex]
132 // edx - Table1503F1A0[nArray1[nIndex]]
133 nArray3[nIndex] = nOneWord;
134
135 // edi - Table1503F1A0[nArray1[nIndex]] >> nCmpLevel
136 ebx = (ebx - 1) & 0x40;
137 dwStopBit = nCmpLevel;
138
139 // edi - nIndex;
140 nTableValue = Table1503F1A0[nArray1[nIndex]];
141 if(nValue < (nTableValue >> nCmpLevel))
142 {
143 if(nArray1[nIndex] != 0)
144 nArray1[nIndex]--;
145 *out.pb++ = 0x80;
146 }
147 else
148 {
149 while(nValue > nTableValue * 2)
150 { // 1500F0C0
151 if(nArray1[nIndex] >= 0x58 || nLength == 0)
152 break;
153
154 nArray1[nIndex] += 8;
155 if(nArray1[nIndex] > 0x58)
156 nArray1[nIndex] = 0x58;
157
158 nTableValue = Table1503F1A0[nArray1[nIndex]];
159 *out.pb++ = 0x81;
160 nLength--;
161 }
162
163 dwBitBuff = 0;
164 EBP2C = nTableValue >> wCmp;
165 unsigned esi = 1 << (dwStopBit - 2);
166 EBP1C = 0;
167 dwBit = 1;
168 dwStopBit = 0x20;
169
170 if(esi <= 0x20)
171 dwStopBit = esi;
172 for(;;)
173 {
174// esi = EBP1C + nTableValue;
175 if((EBP1C + nTableValue) <= nValue)
176 {
177 EBP1C += nTableValue;
178 dwBitBuff |= dwBit;
179 }
180 if(dwBit == dwStopBit)
181 break;
182
183 nTableValue >>= 1;
184 dwBit <<= 1;
185 }
186
187 nValue = nArray2[nIndex];
188 if(ebx != 0)
189 {
190 nValue -= (EBP1C + EBP2C);
191 if(nValue < (int)0xFFFF8000)
192 nValue = (int)0xFFFF8000;
193 }
194 else
195 {
196 nValue += (EBP1C + EBP2C);
197 if(nValue > 0x00007FFF)
198 nValue = 0x00007FFF;
199 }
200
201 nArray2[nIndex] = nValue;
202 *out.pb++ = (unsigned char)(dwBitBuff | ebx);
203 nTableValue = Table1503F120[dwBitBuff & 0x1F];
204 nArray1[nIndex] += nTableValue;
205 if(nArray1[nIndex] < 0)
206 nArray1[nIndex] = 0;
207 else if(nArray1[nIndex] > 0x58)
208 nArray1[nIndex] = 0x58;
209 }
210 // 1500F1D8
211 }
212 while(++nCmpType2 < nWords);
213
214 return out.pb - pbOutBuffer;
215}
216
217//----------------------------------------------------------------------------
218// DecompressWave
219
220// 1500F230
221int DecompressWave(unsigned char * pbOutBuffer, int dwOutLength, unsigned char * pbInBuffer, int dwInLength, int nChannels)
222{
223 TByteAndWordPtr out;
224 TByteAndWordPtr in;
225 unsigned char * pbInEnd = pbInBuffer + dwInLength; // End on input buffer
226 unsigned long index;
227 long nArray1[2];
228 long nArray2[2];
229
230 out.pb = pbOutBuffer;
231 in.pb = pbInBuffer;
232 nArray1[0] = 0x2C;
233 nArray1[1] = 0x2C;
234 in.pw++;
235
236 // 15007AD7
237 if(nChannels > 0)
238 {
239 for(int count = 0; count < nChannels; count++)
240 {
241 long temp;
242
243 temp = *(short *)in.pw++;
244 nArray2[count] = temp;
245
246 if(dwOutLength < 2)
247 return out.pb - pbOutBuffer;
248
249 *out.pw++ = (unsigned short)temp;
250 dwOutLength -= 2;
251 }
252 }
253
254 index = nChannels - 1;
255 while(in.pb < pbInEnd)
256 {
257 unsigned char oneByte = *in.pb++;
258
259 if(nChannels == 2)
260 index = (index == 0) ? 1 : 0;
261
262 // Get one byte from input buffer
263 // 15007B25
264 if(oneByte & 0x80)
265 {
266 // 15007B32
267 switch(oneByte & 0x7F)
268 {
269 case 0: // 15007B8E
270 if(nArray1[index] != 0)
271 nArray1[index]--;
272
273 if(dwOutLength < 2)
274 break;
275
276 *out.pw++ = (unsigned short)nArray2[index];
277 dwOutLength -= 2;
278 continue;
279
280 case 1: // 15007B72
281 nArray1[index] += 8; // EBX also
282 if(nArray1[index] > 0x58)
283 nArray1[index] = 0x58;
284 if(nChannels == 2)
285 index = (index == 0) ? 1 : 0;
286 continue;
287
288 case 2:
289 continue;
290
291 default:
292 nArray1[index] -= 8;
293 if(nArray1[index] < 0)
294 nArray1[index] = 0;
295
296 if(nChannels != 2)
297 continue;
298
299 index = (index == 0) ? 1 : 0;
300 continue;
301 }
302 }
303 else
304 {
305 unsigned long temp1 = Table1503F1A0[nArray1[index]]; // EDI
306 unsigned long temp2 = temp1 >> pbInBuffer[1]; // ESI
307 long temp3 = nArray2[index]; // ECX
308
309 if(oneByte & 0x01) // EBX = oneByte
310 temp2 += (temp1 >> 0);
311
312 if(oneByte & 0x02)
313 temp2 += (temp1 >> 1);
314
315 if(oneByte & 0x04)
316 temp2 += (temp1 >> 2);
317
318 if(oneByte & 0x08)
319 temp2 += (temp1 >> 3);
320
321 if(oneByte & 0x10)
322 temp2 += (temp1 >> 4);
323
324 if(oneByte & 0x20)
325 temp2 += (temp1 >> 5);
326
327 if(oneByte & 0x40)
328 {
329 temp3 -= temp2;
330 if(temp3 <= (long)0xFFFF8000)
331 temp3 = (long)0xFFFF8000;
332 }
333 else
334 {
335 temp3 += temp2;
336 if(temp3 >= 0x7FFF)
337 temp3 = 0x7FFF;
338 }
339 nArray2[index] = temp3;
340 if(dwOutLength < 2)
341 break;
342
343 temp2 = nArray1[index];
344 oneByte &= 0x1F;
345
346 *out.pw++ = (unsigned short)temp3;
347 dwOutLength -= 2;
348
349 temp2 += Table1503F120[oneByte];
350 nArray1[index] = temp2;
351
352 if(nArray1[index] < 0)
353 nArray1[index] = 0;
354 else if(nArray1[index] > 0x58)
355 nArray1[index] = 0x58;
356 }
357 }
358 return (out.pb - pbOutBuffer);
359}
360
Storm-compatible (de)compression