3 // Contains C-style-C++ implementation of VoiCTech (Voice Communications
4 // Technology) voice encoder/decoder.
6 // Written by Matthew F. Storch, Ph.D., copyright (c) 1998 Volition Inc.
15 //////////////////////////////////////////////////////////////////////////////
17 // Introduction to the VoiCTech encoder
18 // ------------------------------------
19 // The VoiCTech (short for Voice Communication Technology, pronounced
20 // "voice-tech") audio codec uses two separate algorithm suites: Codec1
21 // and LPC-10. Codec1 does compression without using traditional signal
22 // processing algorithms (expcept for a simple FIR low-pass filter). As
23 // a result, it is extremely fast, and yields moderate-quality voice at a
24 // compression ratio of between 4-to-1 and 10-to-1, assuming 11KHz sampled
25 // data. LPC-10 does significantly more analysis and is therefore slower
26 // (approximately 3 times slower than Codec1), but achieves substantially
27 // better compression (25-1) at a comparable quality.
29 // The externally-callable interface for both algorithm suites is through
30 // a simple, generic front-end that is prototyped in codec1.h.
32 // This file contains the implementions of both the generic interface and
33 // Codec1. LPC-10 is implemented in a set of files in the LPC10 subdirectory.
35 //////////////////////////////////////////////////////////////////////////////
38 //////////////////////////////////////////////////////////////////////////////
39 // Low pass filter stuff.
41 // Number of points to convolve with. Larger number means a better but
42 // slower low-pass filter. Number should always be odd. Useful range is
44 const int LPF_NUM_POINTS = 11;
45 double Encoder_LPF_Coef[LPF_NUM_POINTS]; // convolution coefficents (weights)
46 // lookup table for coefficents * every possible sample value
47 char Encoder_LPF_CoefTimesSample[LPF_NUM_POINTS][256];
48 double Decoder_LPF_Coef[LPF_NUM_POINTS]; // convolution coefficents (weights)
49 // lookup table for coefficents * every possible sample value
50 char Decoder_LPF_CoefTimesSample[LPF_NUM_POINTS][256];
51 //////////////////////////////////////////////////////////////////////////////
54 //////////////////////////////////////////////////////////////////////////////
55 // Function prototypes for functions internal to Codec1
57 static void InitEncoder1(int QoS);
58 static void Smooth1(t_Sample* bufIn, t_Sample* bufOut, int size);
59 static double AutoGain1(t_Sample* bufIn, t_Sample* bufOut, int size);
60 static void UnAutoGain1(t_Sample* bufIn, t_Sample* bufOut, int size,
62 static void Decode1(t_Sample* bufIn, t_Sample* bufOut, int size, int sizeOut);
64 #if defined(CODEC_DEMO)
65 static int Encode1(t_Sample* bufIn, t_Sample* bufOut, int sizeIn, int sizeOut,
66 t_Sample* levels, int* modes, int samples[9], int storage[9]);
68 static int Encode1(t_Sample* bufIn, t_Sample* bufOut, int sizeIn, int sizeOut);
71 static void SkipEveryOther(t_Sample* bufIn, t_Sample* bufOut, int size);
72 static void InterpolateEveryOther(t_Sample* bufIn, t_Sample* bufOut, int size);
74 #if defined(CODEC_DEMO)
75 static int DoEncode(int mode, int& packetPos, t_Sample*& in, t_Sample*& out,
76 int& level, t_Sample*& levels, int*& modes,
77 int samples[9], int storage[9]);
79 static int DoEncode(int mode, int& packetPos, t_Sample*& in, t_Sample*& out,
83 static void DecodeRL(int packetPos, t_Sample*& p, t_Sample*& q,
84 t_Sample* bufEnd, t_Sample* bufOutEnd);
85 static void DecodeHF(int packetPos, t_Sample*& p, t_Sample*& q,
87 static void DecodeNom(int packetPos, t_Sample*& p, t_Sample*& q,
88 unsigned int mode, t_Sample* bufOutEnd);
89 static void DecodeMF(int packetPos, t_Sample*& p, t_Sample*& q,
91 static void InitLowPassFilter(int QoS, double LPF_Coef[LPF_NUM_POINTS],
92 char LPF_CoefTimesSample[LPF_NUM_POINTS][256]);
93 static void LowPassFilter(t_Sample* bufIn, t_Sample* bufOut, int size,
94 char LPF_CoefTimesSample[LPF_NUM_POINTS][256]);
96 #if defined(USE_LPC10)
97 static void ConvertToLPC10(t_Sample* bufIn, t_Sample* bufOut, int size);
98 static void ConvertFromLPC10(t_Sample* bufIn, t_Sample* bufOut, int size);
101 // the following three functions are defined in lpc10\lpc10.c
103 int lpc10encode(unsigned char *in, unsigned char *out, int inlen);
104 int lpc10decode(unsigned char *in, unsigned char *out, int inlen);
106 #define AssertLPC10Available()
108 #define ConvertToLPC10(bufIn, bufOut, size)
109 #define ConvertFromLPC10(bufIn, bufOut, size)
111 #define lpc10encode(in, out, inlen) 0
112 #define lpc10decode(in, out, inlen) { out = 0; }
113 #define AssertLPC10Available() SDL_assert(0)
114 #endif // defined(USE_LPC10)
117 ///////////////////////////////////////////////////////////////////////////////
120 ///////////////////////////////////////////////////////////////////////////////
121 // Generic high-level codec interface.
123 t_Code EncodeMode = e_cLPC10;
125 t_Sample* TempDecoderBuf = NULL;
126 t_Sample* TempEncoderBuf1 = NULL;
127 t_Sample* TempEncoderBuf2 = NULL;
129 ///////////////////////////////
130 // The following compile-time switches are applicable to Codec1 only.
132 // If SKIP_EVERY_OTHER is defined, every other sample will be thrown out
133 // after the low-pass filter has massaged the data but before the encoder
134 // goes at it. The missing samples are then interpolated after decoding.
135 #define SKIP_EVERY_OTHER
137 // Don't define this ;)
138 //#define REMOVE_DC_BIAS
140 // Define this to use logarithmic gain (but linear gain works better).
141 //#define LOGARITHMIC_GAIN
143 // Define this to enable the low-pass filter.
144 #define USE_LOWPASS_FILTER
146 // End of compile-time switches
147 ///////////////////////////////
149 #if defined(SKIP_EVERY_OTHER)
150 const int SKIP_FACTOR = 2;
152 const int SKIP_FACTOR = 1;
156 void InitDecoder(int QoS, t_Sample* tempBuf)
158 TempDecoderBuf = tempBuf;
159 lpc10init(); // call unconditionally because we don't know what kind of
160 // coded packets we might receive
161 InitLowPassFilter(8, Decoder_LPF_Coef, Decoder_LPF_CoefTimesSample);
164 void Decode(t_CodeInfo* ci, t_Sample* bufIn, t_Sample* bufOut,
165 int encodeSize, int decodeSize)
167 if (ci->Code == e_cCodec1)
169 Decode1(bufIn, TempDecoderBuf, encodeSize, decodeSize/SKIP_FACTOR);
170 #if defined(SKIP_EVERY_OTHER)
171 UnAutoGain1(TempDecoderBuf, TempDecoderBuf, decodeSize/SKIP_FACTOR, ci->Gain);
172 InterpolateEveryOther(TempDecoderBuf, bufOut, decodeSize/SKIP_FACTOR);
174 UnAutoGain1(TempDecoderBuf, bufOut, decodeSize, ci->Gain);
176 LowPassFilter(bufOut, bufOut, decodeSize,Decoder_LPF_CoefTimesSample);
180 AssertLPC10Available();
181 lpc10decode(bufIn, bufOut, encodeSize);
182 ConvertFromLPC10(bufOut, bufOut, decodeSize);
186 void InitEncoder(t_Code code, int QoS, t_Sample* tempBuf1, t_Sample* tempBuf2)
188 TempEncoderBuf1 = tempBuf1;
189 TempEncoderBuf2 = tempBuf2;
191 if (code == e_cCodec1)
194 InitLowPassFilter(QoS, Encoder_LPF_Coef, Encoder_LPF_CoefTimesSample);
198 #if defined(CODEC_DEMO)
199 #define EXTRA_CODEC_DEMO_ARGS4 , levels, modes, samples, storage
200 int Encode(t_Sample* bufIn, t_Sample* bufOut, int sizeIn, int sizeOut,
201 t_CodeInfo* codeInfo,
202 t_Sample* levels, int* modes, int samples[9], int storage[9])
204 #define EXTRA_CODEC_DEMO_ARGS4
205 int Encode(t_Sample* bufIn, t_Sample* bufOut, int sizeIn, int sizeOut,
206 t_CodeInfo* codeInfo)
210 codeInfo->Code = EncodeMode;
211 if (EncodeMode == e_cCodec1)
213 #if defined(SKIP_EVERY_OTHER)
214 LowPassFilter(bufIn, TempEncoderBuf1, sizeIn,
216 Encoder_LPF_CoefTimesSample);
217 SkipEveryOther(TempEncoderBuf1, TempEncoderBuf1, sizeIn);
219 LowPassFilter(bufIn, TempEncoderBuf1, sizeIn,
220 Encoder_LPF_CoefTimesSample);
223 Smooth1(TempEncoderBuf1, TempEncoderBuf2, sizeIn/SKIP_FACTOR);
224 codeInfo->Gain = AutoGain1(TempEncoderBuf2, TempEncoderBuf2,
226 #if defined(CODEC_DEMO)
227 encodeSize = Encode1(TempEncoderBuf2, bufOut, sizeIn/SKIP_FACTOR,
228 sizeOut, levels, modes, samples, storage);
230 encodeSize = Encode1(TempEncoderBuf2, bufOut, sizeIn/SKIP_FACTOR,
236 AssertLPC10Available();
237 ConvertToLPC10(bufIn, TempEncoderBuf2, sizeIn);
238 encodeSize = lpc10encode(TempEncoderBuf2, bufOut, sizeIn);
244 //////////////////////////////////////////////////////////////////////////////
248 // ********* EVERYTHING FROM THIS POINT ON IS SPECIFIC TO CODEC1. ************
251 //////////////////////////////////////////////////////////////////////////////
253 // Introduction to Codec1
254 // ----------------------
255 // Codec1 uses multiple encoders, including a highly modal primary
256 // encoder, to achieve a substantial degree of compression while
257 // accurately preserving the low-to-mid frequency components of human
258 // voice. Higher frequency components are preserved less well, but
259 // usually acceptably. The encoder works best with samples taken at
260 // low-to-moderate microphone volumes, though an additonal logarithmic
261 // compression pass has been added to give better performance at high
264 // The interface is very simple. The externally-visible functions are:
265 // InitEncoder1 -- initialize the encoder
266 // LowPassFilter -- get rid of unwanted high frequency data
267 // SkipEveryOther -- throw out every other sample (optional)
268 // Smooth1 -- smooth little bumps so run-length encoding works better
269 // AutoGain1 -- reduce problematic high-volume samples
270 // Encode1 -- primary encoder
271 // ~~~~~~ transmission to remote machine ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
272 // Decode1 -- primary decoder
273 // UnAutoGain1 -- restore true volume
274 // InterpolateEveryOther -- bring back missing samples
276 // All encoder and decoder algorithms have O(N) running time with
277 // respect to the number of samples (otherwise it would be hopelessly
278 // slow). Decoding is extremely fast and should not have a
279 // significant impact on a modern computer. The C implementation is
280 // most likely fine for production code. The encoding is quite fast
281 // compared with other voice encoders, but it is of course substantially
282 // slower than the decoding. Because of the "bit twiddling" nature of
283 // the algorithms, I would expect that a good assembly language
284 // implementation could easily provide 2X-3X the execution time performance
285 // of this C implementation. As of 12/97, I have implemented one key
286 // routine in assembly that increased performance substantially.
288 // The encoded format is novel and somewhat complex because of the
289 // desire for very high degrees of compression (4:1 to 10:1, nominally
290 // 8:1) with respectable sound quality. In order to achieve such
291 // extraordinarily high compression rates, the exact format is
292 // (unfortunately) specific to 8-bit samples. Ideas very similar to
293 // those used for the 8-bit codec could be used to develop 16 or
294 // 24-bit codecs, but the details would differ enough to require a
295 // mostly new implementation.
297 // A sequence of samples in the original data is encoded as a
298 // "packet". A single packet may describe anywhere from a few samples
299 // to several thousand samples depending on the type of packet. There
300 // are currently 4 major categories of packets: nominal packets,
301 // run-length packets, high-frequency packets, and medium-frequency
302 // packets. An additional category, low-frequency packets, may be
305 // The centerpiece of the encoding strategy is the category of nominal
306 // packets. Nominal packets encode 9 contiguous 8-bit samples in 12
307 // bits, for a compression ratio of 6:1 and very high fidelity. The
308 // encoded value of each sample is relative to the value of the
309 // previous sample, so this technique can only be effectively applied
310 // when contiguous samples have values that are not too different
311 // (i.e. for samples that contain only low-to-medium frequency
312 // components). Detailed examination of actual voice samples revealed
313 // that monotonic upward (or downward) runs of several samples were
314 // common, so I decided that the encoding strategy would be as
315 // follows. Each bit in a nominal packet corresponds to one sample,
316 // and the value of the bit determines what offset is added to the
317 // previous sample value to define the current sample value. The
318 // actual offset values depend on the mode of the packet. For
319 // example, in a mode 3 packet, a data bit of 0 means the offset is
320 // +1, while a data bit of 1 means the offset is +3. On the other
321 // hand, in a mode 5 packet, a data bit of 0 means the offset is -1
322 // and a data bit of 1 means the offset is +1.
324 // The 12-bit packet size presents some challenges given that the
325 // natural data sizes of 80x86 processors are 8, 16, and 32 bits.
326 // However, the challenge is justified because none of the natural
327 // data sizes provided encoding opportunites as good. The
328 // alternatives to the scheme I chose were to either encode 6 samples
329 // in 8 bits, or 12 samples in 16 bits. 6 samples in 8 bits leaves
330 // only 2 bits to assign the mode, which is inadequate. 12 bits in 16
331 // samples leaves plenty of mode bits (4) but then we are committed to
332 // the same mode for 12 bits, which I felt is too long for the voice
333 // data I examined. So I chose the 9-in-12 "sweet spot" granularity
334 // as the basis for the encoding strategy.
336 // The 12-bit packets are encoded in pairs; each pair occupies 3
337 // bytes. If all packets were nominal packets, a single 3-byte
338 // "packet pair" data structure could be used, and such a structure is
339 // in fact used when nominal packets are back-to-back. However, all
340 // the samples in a typical voice sample buffer cannot be encoded
341 // using nominal packets, so other encoding schemes are used. The
342 // 3 mode bits available in the 9-in-12 scheme allow us 8 modes.
343 // Modes 1 through 6 are used for nominal packets, while mode 0 is an
344 // escape to either run-length or high-frequency mode, and mode 7 is an
345 // escape to medium-frequency mode.
347 // The data structures used for run-length (RL), high-frequency (HF),
348 // and medium-frequency (MF) modes are different depending on whether
349 // the previous packet is the first packet in a nominal packet pair
350 // (case 0), or is any of the following (case 1):
351 // - the second packet in a nominal packet pair
352 // - a run-length, high-frequency, or medium-frequency packet
353 // - the first packet in the buffer
354 // In case 0, the RL, HF, or MF packet is 12 bits, while in case 1 it
355 // is 16 bits (that is, we don't use 12 bit encoding for these modes
356 // unless we are forced to, because 16 bit packets are better all the
357 // way around for RL, HF, and MF modes. Both the encoder and decoder
358 // maintain knowlege of case 0 vs. case 1 as a state variable called
361 // The only identical-value runs that occur frequently enough to be
362 // worth worrying about have a value of 0 (silence), so run length
363 // encoding uses 0 as the implicit data value.
365 // In high-frequency mode each sample is *not* relative to the
366 // previous sample (as it is in the nominal modes). Instead it is an
367 // absolute value that is multiplied by a multiplier that is part of
370 // In medium-frequency mode, a sequence of 4 samples in the original
371 // data is approximated by a straight line. This mode can also encode
372 // low-frequency data reasonably well, but not as well as the nominal
373 // modes, so the latter are used where possible. However, medium
374 // frequency mode can be used when the total rise (or fall) of 4
375 // samples is up to 32, whereas the best total rise (or fall) the
376 // nominal modes can achieve over 4 samples is 3*4 = 12.
378 // Finally, there is a special "literal" mode that is used only for
379 // the very first sample in the buffer (which is implicitly literal
380 // mode) and the last few samples (signaled by a special "run length"
381 // packet that has a length of 0). It adds a very slight inefficiency
382 // (since it does no compression) but it greatly simplifies dealing
383 // with the edge cases, which would otherwise be problematic.
385 //////////////////////////////////////////////////////////////////////////////
387 // Some details of the encoding scheme are summarized below:
391 // Mode number Description
392 // 0 run-length or high-frequency mode
399 // 7 medium-frequency mode
403 // Run-length/high-frequency in first packet of packet pair (case 1)
404 // 0000 nnnn nnnn nnnn -- run length, n = length of run (1st nibble low-order)
405 // 0001 mmmm xxxx yyyy -- high frequency, m = multiplier
406 // x, y and succeeding nibbles until 0 byte
407 // = absolute sample values
409 // Run-length/high-frequency in second packet of packet pair (case 0)
410 // ---- ---- ---- 0000 nnnn nnnn -- run length, n = length of run
411 // ---- ---- ---- 0001 mmmm xxxx -- high frequency, m = multiplier
412 // x, y and succeeding nibbles until 0 byte
413 // = absolute sample values
415 // mmmm = 0 is not a useful value so we can use it as an escape indicator for
418 //////////////////////////////////////////////////////////////////////////////
424 // CODEC_DEMO is a compile-time flag that adds/alters code for use with the demo/
425 // experiment program. If CODEC_DEMO is not defined, the codec routines will be
426 // compiled for general-purpose use outside of the demo/experiment program.
427 // (Like in a GAME maybe...what a NOVEL concept!)
431 // Even with #pragma pack(1), sizeof returns 4 for 3 byte structures. In
432 // some places in the code, structure sizes had to be hardwired to get around
436 ///////////////////////////////////////////////////////////////////////////////
439 // Not sure if there is a point in using unions somehow to make one big struct;
440 // for now just forget it and cast to totally different structs which is
441 // theoretically evil but is not really all that dangerous in practice...
443 // disable compiler padding of structures
444 #if !defined(PLAT_UNIX) || defined(__INTEL_COMPILER)
445 #pragma pack(push, packet_declarations)
449 #define PACKED __attribute__((packed, aligned(2)))
452 // most general notion of a packet pair
455 unsigned int Mode1 : 3;
456 unsigned int Mode1Ex : 1;
457 unsigned int Data1 : 8;
458 unsigned int Mode0 : 3;
459 unsigned int Mode0Ex : 1;
460 unsigned int Data0 : 8;
463 // nominal packet pair
464 struct t_PacketPairNom
466 unsigned int Mode1 : 3;
467 unsigned int Data1 : 9;
468 unsigned int Mode0 : 3;
469 unsigned int Data0 : 9;
472 // run-length packet, case 1
475 unsigned short Mode : 3;
476 unsigned short ModeEx : 1; // extra mode bit to distinguish RL & HF
477 unsigned short Length : 12;
480 // high-frequency packet, case 1
483 unsigned short Mode : 3;
484 unsigned short ModeEx : 1; // extra mode bit to distinguish RL & HF
485 unsigned short Table : 3; // lookup table number
486 unsigned short Data2 : 3; // absolute sample data
487 unsigned short Data1 : 3; // absolute sample data
488 unsigned short Data0 : 3; // absolute sample data
491 // high-frequency data packet, only used immediately after an HF packet, or
492 // after another HF data packet
493 struct t_PacketHFData
495 unsigned short Table : 1; // 1 ==> DataT is lookup table number
496 unsigned short Data3 : 3; // absolute sample data
497 unsigned short Data2 : 3; // absolute sample data
498 unsigned short Data1 : 3; // absolute sample data
499 unsigned short Data0 : 3; // absolute sample data
500 unsigned short DataT : 3; // absolute sample data or lookup table number
503 // run-length packet, case 0
506 unsigned int Mode1 : 3; // mode of previous packet in pair
507 unsigned int Data1 : 9; // data of previous packet in pair
508 unsigned int Mode0 : 3; // mode of this packet (always 0)
509 unsigned int Mode0Ex : 1; // extra bit to distinguish RL & HF (always 0)
510 unsigned int Length : 8; // length of run
513 // high-frequency packet, case 0
516 unsigned int Mode1 : 3; // mode of previous packet in pair
517 unsigned int Data1 : 9; // data of previous packet in pair
518 unsigned int Mode0 : 3; // mode of this packet (always 0)
519 unsigned int Mode0Ex : 1; // extra bit to distinguish RL & HF (always 1)
520 unsigned int Table : 1; // 1 ==> DataT is lookup table number
521 unsigned int Data0 : 3; // absolute sample data
522 unsigned int DataT : 3; // absolute sample data or lookup table number
523 unsigned int Unused : 1;
526 // medium-frequency packet, case 1
529 unsigned short Mode : 3; // mode of this packet (always 7)
530 unsigned short Mult : 1; // 0 ==> mult data by 1, 1 ==> mult data by 2
531 short Data1 : 6; // total rise or fall over current 4 samples
532 short Data0 : 6; // total rise or fall over next 4 samples
535 // medium-frequency packet, case 0
538 unsigned int Mode1 : 3; // mode of previous packet in pair
539 unsigned int Data1 : 9; // data of previous packet in pair
540 unsigned int Mode0 : 3; // mode of this packet (always 7)
541 unsigned int Mult : 1; // 0 ==> mult data by 1, 1 ==> mult data by 2
542 int DataX : 2; // not currently used
543 int Data0 : 6; // total rise or fall over next 4 samples
546 // restore state of compiler padding of structures
547 #if !defined(PLAT_UNIX) || defined(__INTEL_COMPILER)
548 #pragma pack(pop, packet_declarations)
554 ////////////////////////////////////////////////////////////////////////////////
555 // Constants, enums, and data tables
557 // These are not all delclared "const", but all are constant after the code is
560 // For the second packet of a packet pair, the breakeven point for run length
561 // vs. normal encoding is 9 bits, because in that case we are using exactly
562 // the packet in both cases (we resolve the tie in favor of RL because it's
563 // encoding and decoding is faster). For the first packet, RL uses a minimum
564 // of 16 bits whereas normal encoding commits us to 12 bits, so the breakeven
565 // point is with somewhat longer runs. Using the compression ratio as the
566 // figure of merit, breakeven is at x/16 = 9/12, or x = 12 bits.
567 const int MIN_RUN_LEN[2] = { 9, 12 };
569 const int ZERO = 128; // the value of silence ;)
571 // some quality-of-service tuning parameters
572 int BIG_MOVE2; // useful values 4..32
573 int FUDGE; // useful values 1..5
575 // some tuning parameters to help decide which mode to use when
576 const int BIG_MOVE = 8;
577 const int SMALL_MOVE1 = 2;
578 const int SMALL_MOVE2 = 2;
579 const int SMALL_MOVE3 = 2;
581 // enum DecodeState { e_dsFirst, e_dsSecond };
584 e_emRL_HF = 0, // run-length/high-frequency
585 e_emZ_P1 = 1, // nominal: 0 or +1
586 e_em0_N1 = 2, // nominal: 0 or -1
587 e_emP1_P3 = 3, // nominal: +1 or +3
588 e_emN1_N3 = 4, // nominal: -1 or -3
589 e_emP1_N1 = 5, // nominal: +1 or -1
590 e_emP2_N2 = 6, // nominal: +2 or -2
591 e_emMF = 7 // medium-frequency
594 // offsets for modes 1 through 6 (bogus first entry)
595 const int Deltas[7][2] =
606 double Log2[256]; // lookup table for log-base-2 (i.e. log(x) / log(2))
611 unsigned int EncTable[8][256] =
614 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
615 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
616 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
617 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
618 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
619 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
620 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
621 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
623 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5,
624 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,
625 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
626 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
627 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
628 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
629 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
630 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
633 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
634 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
635 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
636 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
637 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
638 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
639 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
640 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
642 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
643 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
644 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
645 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
646 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
647 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
648 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
649 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
653 unsigned int EncTable[8][256];
659 { -12, -6, -3, -1, 1, 3, 6, 12 },
660 { -24, -12, -6, -3, 3, 6, 12, 24 },
661 { -36, -18, -9, -5, 5, 9, 18, 36 },
662 { -48, -24, -12, -6, 6, 12, 24, 48 },
663 { -60, -30, -15, -7, 7, 15, 30, 60 },
664 { -72, -36, -18, -9, 9, 18, 36, 72 },
665 { -84, -42, -21, -10, 10, 21, 42, 84 },
666 { -96, -48, -24, -12, 12, 24, 48, 96 }
670 ///////////////////////////////////////////////////////////////////////////////
673 // Decode1 is the main decoder entry point.
675 // bufIn - encoded data to decode
676 // bufOut - empty buffer in which to place decoded data
677 // size - size of bufIn in bytes
678 // sizeOut - size of bufOut in bytes
680 // bufOut - decoded data written here
683 static void Decode1(t_Sample* bufIn, t_Sample* bufOut, int size, int sizeOut)
685 unsigned int mode, modeEx;
686 int packetPos = 1; // 1 = first packet of packet pair, 0 = second
687 t_Sample* bufEnd = bufIn + size - 1;
688 t_Sample* bufOutEnd = bufOut + sizeOut - 1;
689 t_Sample* p = bufIn; // current position in input buffer
690 t_Sample* q = bufOut; // current position in output buffer
692 *q++ = *p++; // first sample is in literal mode
694 // Main decoding loop. Look at the mode of the packet and call the
695 // appropriate decoder.
696 while (p <= bufEnd && q <= bufOutEnd)
700 mode = ((t_PacketPair*)p)->Mode1;
701 modeEx = ((t_PacketPair*)p)->Mode1Ex;
705 mode = ((t_PacketPair*)p)->Mode0;
706 modeEx = ((t_PacketPair*)p)->Mode0Ex;
711 if (modeEx) // modeEx differentiates HF vs RL modes
712 DecodeHF(packetPos, p, q, bufOutEnd);
714 DecodeRL(packetPos, p, q, bufEnd, bufOutEnd);
718 case e_emZ_P1: case e_em0_N1: case e_emP1_P3: case e_emN1_N3:
719 case e_emP1_N1: case e_emP2_N2:
720 DecodeNom(packetPos, p, q, mode, bufOutEnd);
721 packetPos = !packetPos;
725 DecodeMF(packetPos, p, q, bufOutEnd);
731 //assert(p == bufEnd && q == bufOutEnd);
733 #if defined(CODEC_DEMO)
734 // Do some extra error checking in CODEC_DEMO mode.
735 if (abs(bufEnd - p) > 1 || abs(bufOutEnd - q) > 1)
737 int leftIn = bufEnd - p,
738 leftOut = bufOutEnd - q;
740 SDL_snprintf(str, sizeof(str), "%d bytes left in source, %d bytes left in dest",
748 // Run-length decoder. Very straightforward.
749 static void DecodeRL(int packetPos, t_Sample*& p, t_Sample*& q,
750 t_Sample* bufEnd, t_Sample* bufOutEnd)
755 len = ((t_PacketRL1*)p)->Length;
756 p += sizeof(t_PacketRL1);
760 len = ((t_PacketRL0*)p)->Length;
761 p += 3; //sizeof(t_PacketRL0); // see "Packing Problems" comment above
764 // q + len-1 is where the last sample in this run will be written
765 if (q + len-1 > bufOutEnd)
767 q = bufOutEnd + 1; // cause decoder to immediately abort
771 for (int i = 0; i < len; i++)
774 if (len == 0) // check for literal-mode marker near end of data
776 // remaining data is in literal mode
777 for (int remaining = *p++; remaining > 0 && q<=bufOutEnd; remaining--)
779 // assert(p == bufEnd+1);
783 // High-frequency decoder. Each sample is the data value for that sample
784 // multiplied by the current multiplier.
785 static void DecodeHF(int packetPos, t_Sample*& p, t_Sample*& q,
788 static unsigned int table = 1;
790 // t_Sample* pstart = p;
792 if (q > bufOutEnd - 3)
794 q = bufOutEnd + 1; // cause decoder to immediately abort
800 table = ((t_PacketHF1*)p)->Table;
801 data = ((t_PacketHF1*)p)->Data2;
802 *q++ = t_Sample(DecTable[table][data] + ZERO);
803 data = ((t_PacketHF1*)p)->Data1;
804 *q++ = t_Sample(DecTable[table][data] + ZERO);
805 data = ((t_PacketHF1*)p)->Data0;
806 *q++ = t_Sample(DecTable[table][data] + ZERO);
807 p += sizeof(t_PacketHF1);
811 if (((t_PacketHF0*)p)->Table == 1)
812 table = ((t_PacketHF0*)p)->DataT;
813 data = ((t_PacketHF0*)p)->Data0;
814 *q++ = t_Sample(DecTable[table][data] + ZERO);
815 if (((t_PacketHF0*)p)->Table == 0)
817 data = ((t_PacketHF0*)p)->DataT;
818 *q++ = t_Sample(DecTable[table][data] + ZERO);
820 p += 3; //sizeof(t_PacketHF0); // see "Packing Problems" comment above
823 while (*(char*)p != 0)
825 if (q > bufOutEnd - 5)
827 q = bufOutEnd + 1; // cause decoder to immediately abort
830 if (((t_PacketHFData*)p)->Table == 1)
831 table = ((t_PacketHFData*)p)->DataT;
832 data = ((t_PacketHFData*)p)->Data3;
833 *q++ = t_Sample(DecTable[table][data] + ZERO);
834 data = ((t_PacketHFData*)p)->Data2;
835 *q++ = t_Sample(DecTable[table][data] + ZERO);
836 data = ((t_PacketHFData*)p)->Data1;
837 *q++ = t_Sample(DecTable[table][data] + ZERO);
838 data = ((t_PacketHFData*)p)->Data0;
839 *q++ = t_Sample(DecTable[table][data] + ZERO);
840 if (((t_PacketHFData*)p)->Table == 0)
842 data = ((t_PacketHFData*)p)->DataT;
843 *q++ = t_Sample(DecTable[table][data] + ZERO);
845 p += sizeof(t_PacketHFData);
848 p += sizeof(char); //sizeof(t_PacketHFData); // to cover final "0" packet
851 // Nominal packet decoder. Each sample is equal to the previous sample
853 static void DecodeNom(int packetPos, t_Sample*& p, t_Sample*& q,
854 unsigned int mode, t_Sample* bufOutEnd)
857 t_Sample delta0 = t_Sample(Deltas[mode][0]), // offset for "0" bits
858 delta1 = t_Sample(Deltas[mode][1]), // offset for "1" bits
861 if (q > bufOutEnd - 9)
869 data = ((t_PacketPairNom*)p)->Data1;
873 data = ((t_PacketPairNom*)p)->Data0;
874 p += 3; // sizeof(t_PacketPairNom);
877 for (int i = 0; i < 9; i++)
881 last = t_Sample(last + delta1); // using += causes level 4 warning
886 last = t_Sample(last + delta0); // using += causes level 4 warning
893 // Medium-frequency decoder. Uses a straight line to approximate 4
894 // consecutive samples.
895 static void DecodeMF(int packetPos, t_Sample*& p, t_Sample*& q,
898 unsigned int data; //, mult;
899 t_Sample level = *(q-1);
901 if (q > bufOutEnd - 4)
909 //mult = ((t_PacketMF1*)p)->Mult; // currently unused
910 data = ((t_PacketMF1*)p)->Data1;
911 // Make each of the 4 points is computed in a way equivalent to that
912 // used in the encoder.
913 level = t_Sample(level + data / 4); *q++ = level;
914 data -= data / 4; level = t_Sample(level + data / 3); *q++ = level;
915 data -= data / 3; level = t_Sample(level + data / 2); *q++ = level;
916 data -= data / 2; level = t_Sample(level + data ); *q++ = level;
918 data = ((t_PacketMF1*)p)->Data0;
920 p += sizeof(t_PacketMF1);
924 //mult = ((t_PacketMF0*)p)->Mult; // currently unused
925 data = ((t_PacketMF0*)p)->Data0;
927 p += sizeof(t_PacketMF0);
929 level = t_Sample(level + data / 4); *q++ = level;
930 data -= data / 4; level = t_Sample(level + data / 3); *q++ = level;
931 data -= data / 3; level = t_Sample(level + data / 2); *q++ = level;
932 data -= data / 2; level = t_Sample(level + data ); *q++ = level;
937 ///////////////////////////////////////////////////////////////////////////////
940 int QualityOfService;
942 // InitEncoder1 must be called once to initialize the encoder. May safely be
943 // called again to change tuning parameters.
945 // QoS - Quality of Service: 1..10, 1 = highest compression/lowest
946 // quality, 10 = worst compression/best quality
948 // initializes global variables
950 static void InitEncoder1(int QoS)
952 int i, j, table, in, ip, vn, vp;
953 QualityOfService = QoS;
954 // There is nothing magic about the folowing 2 formulas, they're just one
955 // way to translate from a semantic notion of "quality of service" to
956 // reasonable values of the tuning parameters. Each parameter is
957 // orthogonal to the others, so the only reason to tie them to a single
958 // input parameter is simplicity.
959 BIG_MOVE2 = 8 + (10 - QoS) * 2;
960 FUDGE = (12 - QoS) / 2;
962 // initilize log-base-2 lookup table
963 for (i = 1; i < 256; i++)
964 Log2[i] = log((double)i) / log(2.0);
966 for (table = 7; table >= 0; table--)
969 in = ZERO-1, ip = ZERO;
970 for (i = 0; i < 16 * (table+1)/8.0; i++)
971 EncTable[table][in--] = vn, EncTable[table][ip++] = vp;
973 for (j = 1; j < 4; j++)
976 for (i = 0; i < pow(2.0, 3.0+j) * (table+1)/8.0; i++)
977 EncTable[table][in--] = vn, EncTable[table][ip++] = vp;
980 EncTable[table][in--] = vn, EncTable[table][ip++] = vp;
984 for (table = 0; table < 8; table++)
985 for (i = 0; i < 256; i++)
988 if (s < 128*(table+1)/8.0)
989 EncTable[table][i] = (unsigned int)log(s*8.0/(table+1))
992 EncTable[table][i] = (unsigned int)log(128*8.0/(table+1));
995 for (table = 0; table < 8; table++)
996 for (i = 0; i < 8; i++)
997 DecTable[table][i] = pow(2.0, i);
1005 // Encode1 is the main Encoder entry point.
1007 // bufIn - encoded data to decode
1008 // bufOut - empty buffer in which to place decoded data
1009 // size - size of bufIn in bytes
1010 // sizeOut - size of bufOut in bytes
1012 // bufOut - encoded data written here
1013 // returns - number of bytes written to bufOut
1015 #if defined(CODEC_DEMO)
1016 #define EXTRA_CODEC_DEMO_ARGS4 , levels, modes, samples, storage
1017 static int Encode1(t_Sample* bufIn, t_Sample* bufOut, int size, int sizeOut,
1018 t_Sample* levels, int* modes, int samples[9], int storage[9])
1020 #define EXTRA_CODEC_DEMO_ARGS4
1021 static int Encode1(t_Sample* bufIn, t_Sample* bufOut, int size, int sizeOut)
1024 const int CUTOFF = 4;
1025 t_Sample *in = bufIn, // current position in input buffer
1026 *out = bufOut, // current position in output buffer
1027 *p, // temporary pointer
1028 *end = bufIn + size, // end of input buffer
1029 *endOut = bufOut + sizeOut; // end of output buffer
1030 int i, // loop counter
1031 level, // current "true" sample value
1032 s0, // first of two samples
1033 s1, // second of two samples
1034 smin, smax, // min and max of current set of samples
1035 hist[CUTOFF*2 + 1], // histogram of sample-to-sample deltas
1036 upMove, downMove; // total up/down deltas
1037 int packetPos = 1; // 1 = first packet of packet pair, 0 = second
1041 SDL_assert(sizeof(t_PacketRL1) == 2);
1042 SDL_assert(sizeof(t_PacketHF1) == 2);
1043 SDL_assert(sizeof(t_PacketHFData) == 2);
1044 SDL_assert(sizeof(t_PacketHF0) == 4);
1046 // First byte in encoded data is unencoded (literal mode) initial level.
1047 level = *out++ = *in++;
1049 #if defined(CODEC_DEMO)
1050 // Remove *levels++ to make level 1 pixel offset.
1051 *levels++ = t_Sample(level);
1052 // For statistics, pretend that literal mode is high-frequency mode.
1054 samples[8] += 1; storage[8] += 2*sizeof(t_Sample);
1057 // Main encoding loop. General strategy is to compute a histogram and
1058 // some other stats about the next 9 samples, then decide which is the
1059 // best encoding mode (that's the hard part), and finally encode the
1060 // data. Note that if we decide on run-length or high-frequency mode,
1061 // we may encode more than 9 samples before going around this loop
1063 while (in < end && out < endOut)
1065 // Use current level rather than last sample for histogram etc.
1066 // because level is where we are really starting from. In the case
1067 // where we are starting with significant error (e.g. just coming out
1068 // of HF mode), we may very well pick a different mode starting from
1069 // level than we would starting from the last sample.
1070 //smin = smax = s0 = *(in-1);
1071 smin = smax = s0 = level;
1073 //int sstart = (s0 + *in) / 2,
1074 // send = (in[7] + in[8]) / 2;
1076 // Compute histogram.
1077 // Do 9 bits at a time, ensuring we don't go off end of bufIn.
1078 for (i = 0; i < CUTOFF*2 + 1; i++)
1080 upMove = downMove = 0;
1081 for (i = 0; i < 9 && in+i < end; i++)
1084 if (s1 < smin) smin = s1;
1085 if (s1 > smax) smax = s1;
1087 if (diff < 0) downMove -= diff;
1088 if (diff > 0) upMove += diff;
1089 if (diff > CUTOFF) diff = CUTOFF;
1090 if (diff < -CUTOFF) diff = -CUTOFF;
1091 hist[diff+CUTOFF]++;
1095 // it's faster to do this in the loop above...
1096 //for (i = 0, downMove = 0; i < CUTOFF; i++)
1097 // downMove += hist[i] * (CUTOFF-i);
1098 //for (i = CUTOFF+1, upMove = 0; i < CUTOFF*2 + 1; i++)
1099 // upMove += hist[i] * (i-CUTOFF);
1102 short delta = short(in[3] - level); // for medium-frequency mode
1104 // First check if we need to switch to literal mode.
1107 // We are near the end of the data. Put marker indicating
1108 // the final mode switch to literal mode. The marker is a
1109 // run-length mode packet of length 0. Literal mode
1110 // encoding is a single byte indicating the number of
1111 // literal mode samples followed by the original samples.
1115 packet.Mode = e_emRL_HF;
1118 *(t_PacketRL1*)out = packet;
1119 out += sizeof(t_PacketRL1);
1123 t_PacketRL0 packet = *(t_PacketRL0*)out;
1124 packet.Mode0 = e_emRL_HF;
1127 *(t_PacketRL0*)out = packet;
1128 out += 3; //sizeof(t_PacketRL0); // see "Packing Problems"
1131 i = *out++ = t_Sample(end - in);
1133 #if defined(CODEC_DEMO)
1136 *levels++ = *out++ = *in++;
1138 // For statistical purposes, pretend that literal mode is high-
1139 // frequency mode since high frequency mode is the most similar
1140 // in terms of bits per sample. In any case, literal mode will
1141 // have very little impact on any of the statistics.
1142 for (i = remaining; i > 0; i--) *modes++ = 8;
1143 samples[8] += remaining; storage[8] += 2*remaining;
1149 // Check if low frequency mode applies; if so, use it because it
1150 // is the most efficient.
1151 else if (upMove <= SMALL_MOVE3 && downMove <= SMALL_MOVE3)
1152 { // low frequency mode
1153 int runLengthMode = FALSE;
1154 if (hist[CUTOFF] == 9)
1155 { // possible 0-run starting; check ahead
1157 // packet1 can handle runs of 2^12-1 = 4095 samples
1158 // packet0 can handle runs of 2^8-1 = 255 samples
1159 int len, maxLen = packetPos ? 4095 : 255;
1160 for (p = &in[9], len = 9; p < end && len < maxLen; p++, len++)
1164 if (len > MIN_RUN_LEN[packetPos])
1165 { // encode region in-to-p as run-length
1166 runLengthMode = TRUE;
1170 packet.Mode = e_emRL_HF;
1172 packet.Length = (unsigned short)len;
1173 *(t_PacketRL1*)out = packet;
1174 out += sizeof(packet);
1175 // packetPos remains at 1
1176 #if defined(CODEC_DEMO)
1177 samples[0] += len; storage[0] += 2*sizeof(packet);
1182 t_PacketRL0 packet = *(t_PacketRL0*)out;
1183 packet.Mode0 = e_emRL_HF;
1185 packet.Length = len;
1186 *(t_PacketRL0*)out = packet;
1187 out += 3; // sizeof(packet);
1189 #if defined(CODEC_DEMO)
1190 samples[0] += len; storage[0] += 3; // sizeof(packet};
1195 #if defined(CODEC_DEMO)
1196 for (int j = 0; j < len; j++)
1197 *levels++ = ZERO, *modes++ = 0;
1202 { // normal low-frequency mode
1203 //!!! Need to implement a low-frequency mode for real. In the
1204 // meantime, use the appropriate nominal mode in its place.
1205 if (upMove > 0 && downMove > 0)
1207 out += DoEncode(e_emP1_N1, packetPos, in, out, level
1208 EXTRA_CODEC_DEMO_ARGS4);
1210 else if (upMove > 0)
1212 out += DoEncode(e_emZ_P1, packetPos, in, out, level
1213 EXTRA_CODEC_DEMO_ARGS4);
1217 out += DoEncode(e_em0_N1, packetPos, in, out, level
1218 EXTRA_CODEC_DEMO_ARGS4);
1222 // Check if nominal modes apply; if so, use one of them.
1223 // Given 9 bits with a maximum per-bit delta of 3, we can keep up
1224 // with an end-to-end delta of 3 * 9 in nominal mode, plus we add
1225 // in a little fudge factor because we would really rather avoid
1226 // medium or high-frequency modes if possible.
1227 //else if (hist[CUTOFF*2] <= 2 && hist[0] <= 2 &&
1228 // upMove < 3 * 9 + 5 && downMove < 3 * 9 + 5)
1229 else if (hist[CUTOFF*2] + hist[0] <= 2 &&
1230 upMove < 3 * 9 + FUDGE && downMove < 3 * 9 + FUDGE)
1232 if (upMove >= BIG_MOVE)
1233 { // lot of up movement, use mode 3 or 6
1234 // mode 3 unless nontrivial down move
1235 if (downMove <= SMALL_MOVE1)
1236 out += DoEncode(e_emP1_P3, packetPos, in, out, level
1237 EXTRA_CODEC_DEMO_ARGS4);
1239 out += DoEncode(e_emP2_N2, packetPos, in, out,
1240 level EXTRA_CODEC_DEMO_ARGS4);
1242 else if (downMove >= BIG_MOVE)
1243 { // lot of down movement, use mode 4 or 6
1244 if (upMove <= SMALL_MOVE1) // mode 4 unless nontrivial up move
1245 out += DoEncode(e_emN1_N3, packetPos, in, out, level
1246 EXTRA_CODEC_DEMO_ARGS4);
1248 out += DoEncode(e_emP2_N2, packetPos, in, out, level
1249 EXTRA_CODEC_DEMO_ARGS4);
1251 else if (upMove >= SMALL_MOVE2 && downMove >= SMALL_MOVE2)
1253 out += DoEncode(e_emP1_N1, packetPos, in, out, level
1254 EXTRA_CODEC_DEMO_ARGS4);
1256 else if (upMove >= SMALL_MOVE2)
1258 out += DoEncode(e_emZ_P1, packetPos, in, out, level
1259 EXTRA_CODEC_DEMO_ARGS4);
1263 out += DoEncode(e_em0_N1, packetPos, in, out, level
1264 EXTRA_CODEC_DEMO_ARGS4);
1267 // Last chance to avoid dreaded high-frequency mode. In medium-
1268 // frequency mode, a sequence of 4 samples is encoded as a straight-
1269 // line approximation. There are 6 bits available to encode the
1270 // total rise/fall of the line, so we can track a total rise of
1271 // +(2^5-1) = +31 and a total fall of -(2^5) = -32.
1272 //else if (delta <= 31 && delta >= -32)
1273 else if ((upMove < BIG_MOVE2 || downMove < BIG_MOVE2)
1274 && delta <= 31 && delta >= -32)
1275 { // medium frequency mode
1276 #if defined(CODEC_DEMO)
1284 packet.Mode = e_emMF;
1285 packet.Mult = 0; //!!! should implement .Mult
1286 packet.Data1 = delta;
1287 #if defined(CODEC_DEMO)
1290 level += packet.Data1;
1291 delta = short(in[3] - level);
1292 if (delta > 31) packet.Data0 = 31;
1293 else if (delta < -32) packet.Data0 = -32;
1294 else packet.Data0 = delta;
1295 *(t_PacketMF1*)out = packet;
1296 out += sizeof(packet);
1299 #if defined(CODEC_DEMO)
1300 temp1 = packet.Data1; *levels++ = t_Sample(temp2 += temp1 / 4);
1301 temp1 -= temp1 / 4; *levels++ = t_Sample(temp2 += temp1 / 3);
1302 temp1 -= temp1 / 3; *levels++ = t_Sample(temp2 += temp1 / 2);
1303 temp1 -= temp1 / 2; *levels++ = t_Sample(temp2 += temp1);
1304 assert(temp2 == level);
1305 temp1 = packet.Data0; *levels++ = t_Sample(temp2 += temp1 / 4);
1306 temp1 -= temp1 / 4; *levels++ = t_Sample(temp2 += temp1 / 3);
1307 temp1 -= temp1 / 3; *levels++ = t_Sample(temp2 += temp1 / 2);
1308 temp1 -= temp1 / 2; *levels++ = t_Sample(temp2 += temp1);
1309 assert(temp2 == level + packet.Data0);
1311 for (i = 0; i < 8; i++) *modes++ = 7;
1312 samples[7] += 8; storage[7] += 2*sizeof(packet);
1315 level += packet.Data0;
1319 t_PacketMF0 packet = *(t_PacketMF0*)out;
1320 packet.Mode0 = e_emMF;
1322 packet.Data0 = delta;
1323 *(t_PacketMF0*)out = packet;
1324 out += sizeof(packet);
1326 #if defined(CODEC_DEMO)
1328 temp1 = packet.Data0; *levels++ = t_Sample(temp2 += temp1 / 4);
1329 temp1 -= temp1 / 4; *levels++ = t_Sample(temp2 += temp1 / 3);
1330 temp1 -= temp1 / 3; *levels++ = t_Sample(temp2 += temp1 / 2);
1331 temp1 -= temp1 / 2; *levels++ = t_Sample(temp2 += temp1);
1332 assert(temp2 == level + packet.Data0);
1334 for (i = 0; i < 4; i++) *modes++ = 7;
1335 samples[7] += 4; storage[7] += 3; // sizeof(packet);
1338 level += packet.Data0;
1342 else // No choice but to use bit-gobbling high frequency mode.
1343 { // high frequency mode
1344 // need abs because smax is not guaranteed to be > ZERO and smin
1345 // is not guaranteed to be < ZERO
1346 int temp1 = abs((smax - ZERO) / 16),
1347 temp2 = abs((ZERO - smin - 1) / 16);
1348 // "table" is our new preferred table
1349 int table = temp1 > temp2 ? temp1 : temp2;
1350 int data4, data3, data2, data1, data0, datat, val3, val2, val1, val0;
1352 int finalPacketData;
1357 packet.Mode = e_emRL_HF;
1359 // HF1 packets include table number unconditionally
1360 packet.Table = (unsigned short)(tableNum = table);
1361 packet.Data2 = (unsigned short)(EncTable[table][*in++]);
1362 packet.Data1 = (unsigned short)(EncTable[table][*in++]);
1364 packet.Data0 = (unsigned short)(EncTable[table][*in]);
1366 *(t_PacketHF1*)out = packet;
1367 out += sizeof(packet);
1369 #if defined(CODEC_DEMO)
1370 *levels++ = t_Sample(DecTable[table][packet.Data2] + ZERO);
1371 *levels++ = t_Sample(DecTable[table][packet.Data1] + ZERO);
1372 *levels++ = t_Sample(DecTable[table][packet.Data0] + ZERO);
1376 samples[8] += 3; storage[8] += 2*sizeof(packet);
1381 t_PacketHF0 packet = *(t_PacketHF0*)out;
1382 packet.Mode0 = e_emRL_HF;
1385 finalPacketData = packet.Data0 = EncTable[table][*in++];
1386 // "tableNum-1" in order to introduce a little hysteresis in
1387 // going to a smaller table. No such trick in the other
1388 // direction since the consequences of using a table that is
1389 // too small is worse than using one that is to large.
1390 if (table > tableNum || table < tableNum-1)
1393 packet.DataT = tableNum = table;
1395 else // use previous table
1398 finalPacketData = packet.DataT = EncTable[table = tableNum][*in++];
1400 *(t_PacketHF0*)out = packet;
1401 out += 3; // sizeof(packet);
1403 #if defined(CODEC_DEMO)
1404 *levels++ = t_Sample(DecTable[table][packet.Data0] + ZERO);
1406 samples[8] += 1; storage[8] += 3; // sizeof(packet);
1407 if (packet.Table == 0)
1409 *levels++ = t_Sample(DecTable[table][packet.DataT] + ZERO);
1416 t_PacketHFData packet;
1422 out += sizeof(char);
1423 #if defined(CODEC_DEMO)
1424 storage[8] += 2*sizeof(char);
1427 data4 = *(in-1) - ZERO;
1428 data3 = *in++ - ZERO;
1429 data2 = *in++ - ZERO;
1430 data1 = *in++ - ZERO;
1431 data0 = *in++ - ZERO;
1433 max = abs(data3) > abs(data2) ? abs(data3) : abs(data2);
1434 max = abs(data1) > max ? abs(data1) : max;
1435 max = abs(data0) > max ? abs(data0) : max;
1436 max = abs(datat) > max ? abs(datat) : max;
1437 table = (max-1) / 16;
1439 if (table > tableNum || table < tableNum-1)
1442 packet.DataT = (unsigned short)(table);
1444 else // use previous table
1448 packet.DataT = (unsigned short)(EncTable[table][datat+ZERO]);
1452 packet.Data3 = (unsigned short)(val3 = EncTable[table][data3+ZERO]);
1453 packet.Data2 = (unsigned short)(val2 = EncTable[table][data2+ZERO]);
1454 packet.Data1 = (unsigned short)(val1 = EncTable[table][data1+ZERO]);
1455 packet.Data0 = (unsigned short)(val0 = EncTable[table][data0+ZERO]);
1457 // break if the data is relatively smooth or if we encounter
1458 // data (two 0's) that would cause us to encode a packet that
1459 // looks like a HF termination byte
1460 if ((abs(data2 - data3) + abs(data1 - data2) +
1461 abs(data0 - data1) + abs(data3 - data4) <= 12) ||
1462 (val3 == 0 && val2 == 0))
1465 out += sizeof(char);
1466 #if defined(CODEC_DEMO)
1467 storage[8] += 2*sizeof(char);
1469 if (packet.Table == 1)
1476 // now that we know for certain that this packet, will be
1477 // used, set persistent state to indicate the last used
1478 // table & last encoded data value
1479 finalPacketData = packet.Table ? packet.Data0 : packet.DataT;
1482 *(t_PacketHFData*)out = packet;
1483 out += sizeof(packet);
1485 #if defined(CODEC_DEMO)
1486 *levels++ = t_Sample(DecTable[table][packet.Data3] + ZERO);
1487 *levels++ = t_Sample(DecTable[table][packet.Data2] + ZERO);
1488 *levels++ = t_Sample(DecTable[table][packet.Data1] + ZERO);
1489 *levels++ = t_Sample(DecTable[table][packet.Data0] + ZERO);
1490 *modes++ = 8; *modes++ = 8; *modes++ = 8; *modes++ = 8;
1491 samples[8] += 4; storage[8] += 2*sizeof(packet);
1492 if (packet.Table == 0)
1494 *levels++ = t_Sample(DecTable[table][packet.DataT] + ZERO);
1500 // be sure to set level here so it stays in sync
1501 level = DecTable[tableNum][finalPacketData] + ZERO;
1506 return out - bufOut;
1510 #if defined(CODEC_DEMO)
1511 static int ComputeNomData(t_Sample*& in, const int deltas[], int& level,
1514 static int ComputeNomData(t_Sample*& in, const int deltas[], int& level)
1519 for (int i = 0; i < 9; i++, in++)
1521 if (level+deltas[0] < *in)
1523 data = (data << 1) | 1;
1531 #if defined(CODEC_DEMO)
1532 *levels++ = t_Sample(level);
1547 //#define CODEC1_USE_ASM
1549 #if defined(CODEC_DEMO)
1550 static int ComputeNomDataF(t_Sample*& inp, const int deltas[], int& level,
1553 static int ComputeNomDataF(t_Sample*& inp, const int deltas[], int& level)
1556 #ifdef CODEC1_USE_ASM
1561 mov esi, [inp] // esi = &inp
1562 mov esi, [esi] // esi = inp
1563 mov ebx, deltas[0] // ebx = &deltas[0]
1564 mov edi, [ebx+4] // edi = deltas[1]
1565 mov ebx, [ebx] // ebx = deltas[0]
1566 mov edx, [level] // edx = &level
1567 mov edx, [edx] // edx = level
1570 mov eax, edx // temp = level
1571 mov ecx, 9 // loop count = 9
1574 add eax, ebx // temp += deltas[0]
1575 cmp al, byte ptr [esi] // level+deltas[0] < *in ?
1576 rcl ebp, 1 // shift right bit into data
1577 jge SUM_GE_IN // if (level+deltas[0] >= *in) goto SUM_GE_IN
1578 add edx, edi // level+deltas[0] < *in -> level += deltas[1]
1579 mov eax, edx // temp = level (for next iteration)
1582 mov edx, eax // level = temp
1585 #if defined(CODEC_DEMO)
1586 push eax // ran out of registers
1587 push ebp // we will need the real ebp to get at levels
1588 mov ebp,[esp+8] // get real (frame ptr) value of ebp
1589 mov eax, levels // eax = &levels (implicitly uses ebp)
1590 //mov al, byte ptr ss:[levels]
1592 mov ebp, eax // ebp = &levels
1593 mov eax, [eax] // eax = levels
1594 mov [eax], dl // *levels = level
1595 inc eax // eax = levels + 1
1596 mov [ebp], eax // levels = eax
1605 mov eax, [level] // eax = &level
1606 mov [eax], edx // level = edx
1607 mov eax, [inp] // eax = &inp
1608 mov [eax], esi // inp = esi
1615 for (int i = 0; i < 9; i++, inp++)
1617 if (level+deltas[0] < *inp)
1619 data = (data << 1) | 1;
1627 #if defined(CODEC_DEMO)
1628 *levels++ = t_Sample(level);
1638 // Nominal packet encoder. Each encoded sample is equal to the previous sample
1639 // +/- an offset. The mode has been decided by the routine that calls DoEncode
1640 // so the mode is passed in.
1641 #if defined(CODEC_DEMO)
1642 #define EXTRA_CODEC_DEMO_ARGS1 , levels
1643 static int DoEncode(int mode, int& packetPos, t_Sample*& in, t_Sample*& out,
1644 int& level, t_Sample*& levels, int*& modes,
1645 int samples[9], int storage[9])
1647 #define EXTRA_CODEC_DEMO_ARGS1
1648 static int DoEncode(int mode, int& packetPos, t_Sample*& in, t_Sample*& out,
1652 t_PacketPairNom packet;
1653 int advanceOutput = 0;
1657 #if defined(VERIFY_ASM) && defined(CODEC_DEMO)
1658 t_Sample *inT1 = in, *inT2 = in, *levelsT = levels;
1659 int levelT1 = level, levelT2 = level;
1661 packet.Mode1 = mode;
1662 packet.Data1 = ComputeNomDataF(in,Deltas[mode], level EXTRA_CODEC_DEMO_ARGS1);
1663 #if defined(VERIFY_ASM) && defined(CODEC_DEMO)
1665 unsigned int dataT = ComputeNomData(inT1, Deltas[mode], levelT1 EXTRA_CODEC_DEMO_ARGS1);
1666 if (dataT != packet.Data1)
1668 inT1 = inT2, levelT1 = levelT2;
1670 dataT = ComputeNomData(inT1, Deltas[mode], levelT1 EXTRA_CODEC_DEMO_ARGS1);
1672 dataT = ComputeNomDataF(inT2, Deltas[mode], levelT2 EXTRA_CODEC_DEMO_ARGS1);
1678 packet = *(t_PacketPairNom*)out;
1679 packet.Mode0 = mode;
1680 packet.Data0 = ComputeNomDataF(in,Deltas[mode], level EXTRA_CODEC_DEMO_ARGS1);
1681 advanceOutput = 3; // sizeof(packet);
1683 *(t_PacketPairNom*)out = packet;
1684 packetPos = !packetPos;
1686 #if defined(CODEC_DEMO)
1687 for (int i = 0; i < 9; i++) *modes++ = mode;
1688 samples[mode] += 9; storage[mode] += 3; // sizeof(packet);
1691 return advanceOutput;
1695 static void Smooth1(t_Sample* bufIn, t_Sample* bufOut, int size)
1698 bufOut[0] = bufIn[0];
1699 bufOut[size-1] = bufIn[size-1];
1700 for (i = 2; i < size; i++)
1702 int s0 = bufIn[i-2], s1 = bufIn[i-1], s2 = bufIn[i];
1703 if (s0 == s2 && abs(s1 - s0) < 3)
1704 bufOut[i-1] = bufIn[i];
1706 bufOut[i-1] = bufIn[i-1];
1707 if (abs(s0 - ZERO) < 2 && abs(s1 - ZERO) < 3)
1712 // can operate in place
1713 static double AutoGain1(t_Sample* bufIn, t_Sample* bufOut, int size)
1716 int hist[17], sum, silenceSize = 0;
1717 const int TARGET_MAX = 32, BUCKET_SIZE = 3;
1720 for (i = 0; i < 17; i++)
1722 for (i = 0; i < size; i++)
1724 s = abs(bufIn[i] - ZERO);
1725 hist[s >> BUCKET_SIZE]++;
1726 if (s == 0 || s == 1 || s == -1)
1729 // ignore silence data when computing significant_data_above_this
1730 for (i = 15, sum = hist[16]; i >= 0 && sum < ((size - silenceSize) >> 4);
1734 int significant_data_above_this = i << BUCKET_SIZE;
1736 #if LOGARITHMIC_GAIN
1737 if (significant_data_above_this > TARGET_MAX)
1739 x = ((double)Log2[significant_data_above_this]) / TARGET_MAX;
1741 for (i = 0; i < size; i++)
1743 s = abs(bufIn[i] - ZERO);
1744 s = int(Log2[s] / x);
1745 bufOut[i] = bufIn[i] < ZERO ? t_Sample(ZERO - s) : t_Sample(s + ZERO);
1752 // linearly scale data such that a value of significant_data_above_this
1753 // will become a value of TARGET_MAX
1754 if (significant_data_above_this > TARGET_MAX)
1756 x = ((double)TARGET_MAX) / significant_data_above_this;
1757 for (i = 0; i < size; i++)
1759 s = abs(bufIn[i] - ZERO);
1760 s = int(((double)s) * x + .5);
1761 bufOut[i] = bufIn[i] < ZERO ? t_Sample(ZERO - s) : t_Sample(s + ZERO);
1763 x = 1 / x; // inverse for UnAutoGain() (no danger of x being 0)
1765 else if (significant_data_above_this > 0)
1766 x = ((double)TARGET_MAX) / significant_data_above_this;
1770 // Do a little extra volume boost for low QoS situations. There is
1771 // nothing magic about the constants in the following, they're just
1772 // reasonable heuristic values.
1773 if (QualityOfService <= 3)
1774 x = (x * 6) / (QualityOfService+2);
1775 if (QualityOfService == 1)
1781 // can operate in place
1782 static void UnAutoGain1(t_Sample* bufIn, t_Sample* bufOut, int size,
1788 if (bufIn != bufOut)
1789 for (i = 0; i < size; i++)
1790 bufOut[i] = bufIn[i];
1794 for (i = 0; i < size; i++)
1796 int s = abs(bufIn[i] - ZERO);
1797 #if defined(LOGARITHMIC_GAIN)
1798 s = int(pow(2.0, s * gain)); //!!! could use some optimization
1800 s = int(((double)s) * gain + .5);
1802 if (s > 127) s = 127;
1803 bufOut[i] = bufIn[i] < ZERO ? t_Sample(ZERO - s) : t_Sample(s + ZERO);
1807 static void InitLowPassFilter(int QoS, double LPF_Coef[],
1808 char LPF_CoefTimesSample[LPF_NUM_POINTS][256])
1810 // QoS==10 ==> cutoff frequency is 5500Hz (filter is a noop)
1811 // QoS==1 ==> cutoff frequency is 550Hz
1812 int N = 19, K = 2 * QoS - 1, kshift = LPF_NUM_POINTS/2, k;
1813 for (k = 0; k < LPF_NUM_POINTS; k++)
1816 LPF_Coef[k] = sin(PI * (k-kshift) * K / (double)N) /
1817 ( sin(PI * (k-kshift) / (double)N) * N );
1819 LPF_Coef[k] = ((double)K) / N;
1820 for (int i = 0; i < 256; i++)
1821 LPF_CoefTimesSample[k][i] = (char)(LPF_Coef[k] * i + .5);
1825 // can now operate in place
1826 static void LowPassFilter(t_Sample* bufIn, t_Sample* bufOut, int size,
1827 char LPF_CoefTimesSample[LPF_NUM_POINTS][256])
1831 #if !defined(USE_LOWPASS_FILTER)
1832 if (bufIn != bufOut)
1833 for (j = 0; j < size; j++)
1834 bufOut[j] = bufIn[j];
1838 for (j = LPF_NUM_POINTS-1; j < size; j++)
1840 register int i, sum = 0;
1841 for (i = 0; i < LPF_NUM_POINTS; i++)
1843 int temp1 = bufIn[ i + (j-(LPF_NUM_POINTS-1)) ]; // 0 -> 255
1844 temp1 -= ZERO; // -128 -> 127
1845 // lookup based on abs value
1846 int temp2 = LPF_CoefTimesSample[i][abs(temp1)];
1853 // depending on the exact values of the coefficients, there is a
1854 // chance that sum may become slightly larger (or smaller) than the
1855 // maximum (mimimum) allowable values, so truncate it before it does
1857 if (sum > 127) sum = 127;
1858 if (sum < -128) sum = -128;
1860 bufOut[j-(LPF_NUM_POINTS-1)] = t_Sample(sum + ZERO);
1864 //for (j = 0; j < LPF_NUM_POINTS-1; j++)
1865 // bufOut[j] = 0; // clear unused buffer entries
1867 // fade in the samples to avoid pops & clicks
1868 int level = bufOut[LPF_NUM_POINTS-1];
1869 for (j = LPF_NUM_POINTS-2; j >= 0; j--)
1870 bufOut[j] = level = ((level-ZERO) >> 1) + ZERO;
1872 // fade out the samples to avoid pops & clicks
1873 int level = bufOut[size - LPF_NUM_POINTS];
1874 for (j = size-(LPF_NUM_POINTS+1); j < size; j++)
1875 bufOut[j] = t_Sample(level = ((level-ZERO) >> 1) + ZERO);
1877 #if defined(REMOVE_DC_BIAS)
1880 for (j = 0, sum = 0; j < size; j++)
1881 sum += bufOut[j] - ZERO;
1883 for (j = 0; j < size; j++)
1888 // can operate in place (i.e. bufIn == bufOut is ok)
1889 static void SkipEveryOther(t_Sample* bufIn, t_Sample* bufOut, int size)
1891 for (int i = 0; i < size; i += 2)
1892 bufOut[i/2] = bufIn[i];
1895 static void InterpolateEveryOther(t_Sample* bufIn, t_Sample* bufOut, int size)
1897 for (int i = 0; i < size; i++)
1900 *bufOut++ = t_Sample((*bufIn + *(bufIn+1)) / 2);
1906 #if defined(USE_LPC10)
1909 #include "lpc10\ulaw.h" // it's the LAW
1911 // can operate in place
1912 static void ConvertToLPC10(t_Sample* bufIn, t_Sample* bufOut, int size)
1916 for (int i = 0; i < size; i++)
1925 for (int i = 0; i < size; i++)
1926 bufOut[i] = audio_c2u(bufIn[i]);
1930 // can operate in place
1931 static void ConvertFromLPC10(t_Sample* bufIn, t_Sample* bufOut, int size)
1933 for (int i = 0; i < size; i++)
1934 bufOut[i] = t_Sample(audio_u2c(bufIn[i]));
1936 #endif // defined(USE_LPC10)
1939 //////////////////////////////////////////////////////////////////////////////
1940 // Only unused junk below. Being kept around for reference only.
1943 for (i = 0; i < 256; i++)
1947 s = (log((double)s) / log(2.0)) * 5 + .5;
1948 s = i < ZERO ? ZERO - s : s + ZERO;
1949 unsigned char junk = s;
1950 if (junk > ZERO+35 || junk < ZERO-36)
1954 static void Log1(t_Sample* bufIn, t_Sample* bufOut, int size)
1957 for (i = 0; i < size; i++)
1959 s = abs(bufIn[i] - ZERO);
1961 s = Log2[s] * 5.0 + .5;
1962 bufOut[i] = bufIn[i] < ZERO ? ZERO - s : s + ZERO;
1963 if (bufOut[i] > ZERO+35 || bufOut[i] < ZERO-36)
1968 static void UnLog1(t_Sample* bufIn, t_Sample* bufOut, int size)
1971 for (i = 0; i < size; i++)
1973 int s = abs(bufIn[i] - ZERO);
1976 s = pow(2.0, s / 5.0); //!!! could use some optimization
1977 bufOut[i] = bufIn[i] < ZERO ? ZERO - s : s + ZERO;
1981 // from InitLowPassFilter():
1982 //int K = LPF_NUM_POINTS;
1983 //double cutoffFrequency = 1100.0*QoS,
1984 // bandwidthPerBucket = cutoffFrequency / (K/2);
1985 //int N = (int)(11000.0 / bandwidthPerBucket), k,
1988 // cutoff fraction = cutoff freq / sample freq
1989 // ==> cutoff fraction = LPF_NUM_POINTS / N
1990 // ==> N = LPF_NUM_POINTS / cutoff fraction
1991 //int i, k, N = (int)(LPF_NUM_POINTS / ((1100.0*QoS) / 11000.0)),
1992 // kshift = LPF_NUM_POINTS/2;