dahjah/hostile-takeover
1
0
Fork 0
mirror of https://github.com/spiffcode/hostile-takeover.git synced 2025-12-16 12:08:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
hostile-takeover/SpiffLib/AudioFormats.cs
Darrin Massena f4c0203914 initial commit
2014-07-06 17:47:28 -07:00

1476 lines
56 KiB
C#
Raw Permalink Blame History

using System;
using System.IO;
using System.Collections;
using System.Runtime.InteropServices;
using System.Diagnostics;
namespace SpiffLib
{
/// <summary>
/// Summary description for AudioFormats.
/// </summary>
public class AudioFormats
{
// Fibonacci
static int[] s_anFibonacci = { -34, -21, -13, -8, -5, -3, -2, -1, 0, 1, 2, 3, 5, 8, 13, 21 };
public static byte[] EncodeFibonacciDelta(byte[] abPcm) {
return Encode8BitDelta(abPcm, s_anFibonacci);
}
public static byte[] DecodeFibonacciDelta(byte[] abEncoded) {
return Decode8BitDelta(abEncoded, s_anFibonacci);
}
// Exponential
static int[] s_anExponential = { -128, -64, -32, -16, -8, -4, -2, -1, 0, 1, 2, 4, 8, 16, 32, 64 };
public static byte[] EncodeExponentialDelta(byte[] abPcm) {
return Encode8BitDelta(abPcm, s_anExponential);
}
public static byte[] DecodeExponentialDelta(byte[] abEncoded) {
return Decode8BitDelta(abEncoded, s_anExponential);
}
static byte[] Encode8BitDelta(byte[] abPcm, int[] anDelta) {
byte[] abEncoded = new byte[1 + (abPcm.Length + 1) / 2];
int nLast = (int)abPcm[0];
abEncoded[0] = abPcm[0];
for (int i = 1; i < abPcm.Length; i++) {
// Important - the shortest path to the next sample may be by overflowing or underflowing.
// If this isn't done, the results will be poor.
sbyte sbDelta = (sbyte)(abPcm[i] - nLast);
int iEntry = -1;
int nDiffSmallest = Int32.MaxValue;
for (int j = 0; j < anDelta.Length; j++) {
int nDiff = (anDelta[j] - sbDelta);
if (nDiff < 0)
nDiff = -nDiff;
if (nDiff < nDiffSmallest) {
nDiffSmallest = nDiff;
iEntry = j;
}
}
Debug.Assert(iEntry >= 0 && iEntry <= 15);
if ((i & 1) != 0) {
abEncoded[(i - 1) / 2 + 1] = (byte)((iEntry << 4) + 8);
} else {
abEncoded[(i - 1) / 2 + 1] = (byte)((byte)(abEncoded[(i - 1) / 2 + 1] & 0xf0) | (byte)iEntry);
}
nLast += anDelta[iEntry];
}
return abEncoded;
}
static byte[] Decode8BitDelta(byte[] abEncoded, int[] anDelta) {
byte[] abPcm = new byte[(abEncoded.Length - 1) * 2 + 1];
byte bSample = abEncoded[0];
abPcm[0] = bSample;
for (int i = 1; i < abEncoded.Length; i++) {
bSample += (byte)anDelta[abEncoded[i] >> 4];
abPcm[(i - 1) * 2 + 1] = bSample;
bSample += (byte)anDelta[abEncoded[i] & 0x0f];
abPcm[(i - 1) * 2 + 2] = bSample;
}
return abPcm;
}
// Wrappers
public unsafe static byte[] EncodeImaAdpcm(short[] ashPcm, int cBits, bool fPreClamp) {
byte[] abEncoded = new byte[ashPcm.Length / 2];
short *pshPcm = (short *)Marshal.UnsafeAddrOfPinnedArrayElement(ashPcm, 0);
byte *pbOut = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(abEncoded, 0);
adpcm_state state;
state.valprev = 0;
state.index = 0;
adpcm_coder(pshPcm, pbOut, ashPcm.Length, &state, cBits, fPreClamp);
return abEncoded;
}
public unsafe static short[] DecodeImaAdpcm(byte[] abEncoded, bool fPreClamp) {
short[] ashOut = new short[abEncoded.Length * 2];
byte *pbEncoded = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(abEncoded, 0);
short *pshOut = (short *)Marshal.UnsafeAddrOfPinnedArrayElement(ashOut, 0);
adpcm_state state;
state.valprev = 0;
state.index = 0;
adpcm_decoder(pbEncoded, pshOut, abEncoded.Length * 2, &state, fPreClamp);
return ashOut;
}
// IMD ADPCM
// This implementation Copyright 1992 by Stichting Mathematisch Centrum, Amsterdam, The
// Netherlands.
/* Intel ADPCM step variation table */
static int[] indexTable = new int[16] {
-1, -1, -1, -1, 2, 4, 6, 8,
-1, -1, -1, -1, 2, 4, 6, 8,
};
static int[] stepsizeTable = new int[89] {
7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
};
struct adpcm_state {
public int valprev;
public int index;
};
unsafe static void adpcm_coder(short *indata, byte *outdata, int len, adpcm_state *state, int cBits, bool fPreClamp)
{
short *inp; /* Input buffer pointer */
byte *outp; /* output buffer pointer */
int val; /* Current input sample value */
int sign; /* Current adpcm sign bit */
int delta; /* Current adpcm output value */
int diff; /* Difference between val and valprev */
int step; /* Stepsize */
int valpred; /* Predicted output value */
int vpdiff; /* Current change to valpred */
int index; /* Current step change index */
int outputbuffer; /* place to keep previous 4-bit value */
int bufferstep; /* toggle between outputbuffer/output */
outp = outdata;
inp = indata;
valpred = state->valprev;
index = state->index;
step = stepsizeTable[index];
outputbuffer = 0;
bufferstep = 1;
for ( ; len > 0 ; len-- ) {
val = *inp++;
/* Step 1 - compute difference with previous value */
diff = val - valpred;
sign = (diff < 0) ? 8 : 0;
if (sign != 0) diff = (-diff);
// If we preclamp, then at decode time we don't need to clamp
// at all. It results in some quantization error however, but
// it is so slight it fails the blind test.
int vpdiffMax = int.MaxValue;
if (fPreClamp) {
if (sign != 0) {
vpdiffMax = valpred - -32768;
} else {
vpdiffMax = 32767 - valpred;
}
}
/* Step 2 - Divide and clamp */
/* Note:
** This code *approximately* computes:
** delta = diff*4/step;
** vpdiff = (delta+0.5)*step/4;
** but in shift step bits are dropped. The net result of this is
** that even if you have fast mul/div hardware you cannot put it to
** good use since the fixup would be too expensive.
*/
delta = 0;
if (fPreClamp) {
vpdiff = 0;
} else {
vpdiff = (step >> 3);
}
if ( diff >= step ) {
delta = 4;
diff -= step;
vpdiff += step;
if (vpdiff > vpdiffMax) {
vpdiff -= step;
delta &= ~4;
}
}
if (cBits > 2) {
step >>= 1;
if ( diff >= step ) {
delta |= 2;
diff -= step;
vpdiff += step;
if (vpdiff > vpdiffMax) {
vpdiff -= step;
delta &= ~2;
}
}
}
if (cBits > 3) {
step >>= 1;
if ( diff >= step ) {
delta |= 1;
vpdiff += step;
if (vpdiff > vpdiffMax) {
vpdiff -= step;
delta &= ~1;
}
}
}
/* Step 3 - Update previous value */
if (sign != 0)
valpred -= vpdiff;
else
valpred += vpdiff;
/* Step 4 - Clamp previous value to 16 bits */
if ( valpred > 32767 ) {
valpred = 32767;
Debug.Assert(!fPreClamp);
} else if ( valpred < -32768 ) {
valpred = -32768;
Debug.Assert(!fPreClamp);
}
/* Step 5 - Assemble value, update index and step values */
delta |= sign;
index += indexTable[delta];
if ( index < 0 ) index = 0;
if ( index > 88 ) index = 88;
step = stepsizeTable[index];
/* Step 6 - Output value */
if (bufferstep != 0 ) {
outputbuffer = (delta << 4) & 0xf0;
} else {
*outp++ = (byte)((delta & 0x0f) | outputbuffer);
}
bufferstep ^= 1;
}
/* Output last step, if needed */
if (bufferstep == 0)
*outp++ = (byte)outputbuffer;
state->valprev = valpred;
state->index = index;
}
unsafe static void adpcm_decoder(byte *indata, short *outdata, int len, adpcm_state *state, bool fPreClamp)
{
byte *inp; /* Input buffer pointer */
short *outp; /* output buffer pointer */
int sign; /* Current adpcm sign bit */
int delta; /* Current adpcm output value */
int step; /* Stepsize */
int valpred; /* Predicted value */
int vpdiff; /* Current change to valpred */
int index; /* Current step change index */
int inputbuffer; /* place to keep next 4-bit value */
int bufferstep; /* toggle between inputbuffer/input */
outp = outdata;
inp = indata;
valpred = state->valprev;
index = state->index;
step = stepsizeTable[index];
inputbuffer = 0;
bufferstep = 0;
for ( ; len > 0 ; len-- ) {
/* Step 1 - get the delta value */
if (bufferstep != 0) {
delta = inputbuffer & 0xf;
} else {
inputbuffer = *inp++;
delta = (inputbuffer >> 4) & 0xf;
}
bufferstep ^= 1;
/* Step 2 - Find new index value (for later) */
index += indexTable[delta];
if ( index < 0 ) index = 0;
if ( index > 88 ) index = 88;
/* Step 3 - Separate sign and magnitude */
sign = delta & 8;
delta = delta & 7;
/* Step 4 - Compute difference and new predicted value */
/*
** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
** in adpcm_coder.
*/
if (fPreClamp) {
vpdiff = 0;
} else {
vpdiff = step >> 3;
}
if ((delta & 4) != 0) vpdiff += step;
if ((delta & 2) != 0) vpdiff += step>>1;
if ((delta & 1) != 0) vpdiff += step>>2;
if (sign != 0)
valpred -= vpdiff;
else
valpred += vpdiff;
/* Step 5 - clamp output value */
if (!fPreClamp) {
if ( valpred > 32767 )
valpred = 32767;
else if ( valpred < -32768 )
valpred = -32768;
}
/* Step 6 - Update step value */
step = stepsizeTable[index];
/* Step 7 - Output value */
*outp++ = (short)valpred;
}
state->valprev = valpred;
state->index = index;
}
static int[] s_anStepFractions = new int[] {
1,1,1,1,1,2,2,2,2,2,2,3,3,3,4,4,4,5,5,6,6,7,8,8,9,10,11,12,13,15,16,18,20,22,24,26,29,32,35,38,42,46,51,56,62,68,75,82,91,100,110,120,133,146,160,176,194,213,235,258,284,312,344,378,416,458,503,554,609,670,737,811,892,981,1079,1187,1305,1436,1579,1737,1911,2102,2313,2544,2798,3078,3386,3724,4096,
2,2,2,3,3,3,3,4,4,4,5,5,6,6,7,8,9,9,10,11,13,14,15,17,18,20,22,24,27,30,33,36,39,43,48,52,58,63,70,77,84,93,102,112,124,136,150,165,181,199,219,241,265,292,321,353,388,427,470,517,568,625,687,756,832,915,1007,1107,1218,1340,1474,1621,1783,1961,2158,2373,2611,2872,3159,3475,3822,4205,4625,5088,5596,6156,6772,7449,8192,
4,4,5,5,6,6,7,7,8,9,10,11,12,13,14,16,17,19,21,23,25,28,30,33,37,40,44,49,54,59,65,72,79,87,95,105,115,127,140,154,169,186,204,225,247,272,299,329,362,398,438,482,530,583,641,706,776,854,939,1033,1136,1250,1375,1512,1664,1830,2013,2214,2436,2679,2947,3242,3566,3923,4315,4747,5221,5744,6318,6950,7645,8409,9250,10175,11193,12312,13543,14897,16384,
5,6,7,8,8,9,10,11,12,13,14,16,17,19,21,23,26,28,31,34,38,41,45,50,55,60,66,73,80,89,98,107,118,130,143,157,173,190,209,230,253,278,306,337,371,408,449,494,543,597,657,722,795,875,962,1058,1164,1280,1409,1550,1704,1874,2062,2268,2495,2745,3020,3321,3653,4019,4421,4863,5349,5884,6473,7120,7832,8615,9476,10424,11467,12614,13875,15263,16789,18467,20315,22346,24575,
7,8,9,10,11,12,13,14,16,17,19,21,23,25,28,31,34,37,41,45,50,55,60,66,73,80,88,97,107,118,130,143,157,173,190,209,230,253,279,307,337,371,408,449,494,544,598,658,724,796,876,963,1060,1166,1282,1411,1552,1707,1878,2066,2272,2499,2749,3024,3327,3660,4026,4428,4871,5358,5894,6484,7132,7845,8630,9493,10442,11487,12635,13899,15289,16818,18500,20350,22385,24623,27086,29794,32767,
9,10,11,13,14,15,16,18,20,21,24,26,29,31,35,39,43,46,51,56,63,69,75,83,91,100,110,121,134,148,163,179,196,216,238,261,288,316,349,384,421,464,510,561,618,680,748,823,905,995,1095,1204,1325,1458,1603,1764,1940,2134,2348,2583,2840,3124,3436,3780,4159,4575,5033,5535,6089,6698,7368,8105,8915,9806,10788,11866,13053,14359,15794,17374,19111,21023,23125,25438,27981,30779,33858,37243,40959,
11,12,14,15,17,18,20,21,24,26,29,32,35,38,42,47,51,56,62,68,75,83,90,99,110,120,132,146,161,177,195,215,236,260,285,314,345,380,419,461,506,557,612,674,741,816,897,987,1086,1194,1314,1445,1590,1749,1923,2117,2328,2561,2817,3099,3408,3749,4124,4536,4991,5490,6039,6642,7307,8037,8841,9726,10698,11768,12945,14240,15663,17231,18953,20849,22934,25227,27750,30525,33578,36935,40629,44691,49151,
12,14,16,18,19,21,23,25,28,30,33,37,40,44,49,54,60,65,72,79,88,96,105,116,128,140,154,170,187,207,228,250,275,303,333,366,403,443,488,537,590,649,714,786,865,952,1047,1152,1267,1393,1533,1685,1855,2041,2244,2469,2716,2987,3287,3616,3976,4373,4811,5292,5822,6405,7046,7749,8524,9377,10315,11347,12481,13729,15103,16613,18274,20102,22111,24323,26756,29432,32375,35613,39174,43090,47401,52140,57342,
-1,-1,-1,-1,-1,-2,-2,-2,-2,-2,-2,-3,-3,-3,-4,-4,-4,-5,-5,-6,-6,-7,-8,-8,-9,-10,-11,-12,-13,-15,-16,-18,-20,-22,-24,-26,-29,-32,-35,-38,-42,-46,-51,-56,-62,-68,-75,-82,-91,-100,-110,-120,-133,-146,-160,-176,-194,-213,-235,-258,-284,-312,-344,-378,-416,-458,-503,-554,-609,-670,-737,-811,-892,-981,-1079,-1187,-1305,-1436,-1579,-1737,-1911,-2102,-2313,-2544,-2798,-3078,-3386,-3724,-4096,
-2,-2,-2,-3,-3,-3,-3,-4,-4,-4,-5,-5,-6,-6,-7,-8,-9,-9,-10,-11,-13,-14,-15,-17,-18,-20,-22,-24,-27,-30,-33,-36,-39,-43,-48,-52,-58,-63,-70,-77,-84,-93,-102,-112,-124,-136,-150,-165,-181,-199,-219,-241,-265,-292,-321,-353,-388,-427,-470,-517,-568,-625,-687,-756,-832,-915,-1007,-1107,-1218,-1340,-1474,-1621,-1783,-1961,-2158,-2373,-2611,-2872,-3159,-3475,-3822,-4205,-4625,-5088,-5596,-6156,-6772,-7449,-8192,
-4,-4,-5,-5,-6,-6,-7,-7,-8,-9,-10,-11,-12,-13,-14,-16,-17,-19,-21,-23,-25,-28,-30,-33,-37,-40,-44,-49,-54,-59,-65,-72,-79,-87,-95,-105,-115,-127,-140,-154,-169,-186,-204,-225,-247,-272,-299,-329,-362,-398,-438,-482,-530,-583,-641,-706,-776,-854,-939,-1033,-1136,-1250,-1375,-1512,-1664,-1830,-2013,-2214,-2436,-2679,-2947,-3242,-3566,-3923,-4315,-4747,-5221,-5744,-6318,-6950,-7645,-8409,-9250,-10175,-11193,-12312,-13543,-14897,-16384,
-5,-6,-7,-8,-8,-9,-10,-11,-12,-13,-14,-16,-17,-19,-21,-23,-26,-28,-31,-34,-38,-41,-45,-50,-55,-60,-66,-73,-80,-89,-98,-107,-118,-130,-143,-157,-173,-190,-209,-230,-253,-278,-306,-337,-371,-408,-449,-494,-543,-597,-657,-722,-795,-875,-962,-1058,-1164,-1280,-1409,-1550,-1704,-1874,-2062,-2268,-2495,-2745,-3020,-3321,-3653,-4019,-4421,-4863,-5349,-5884,-6473,-7120,-7832,-8615,-9476,-10424,-11467,-12614,-13875,-15263,-16789,-18467,-20315,-22346,-24575,
-7,-8,-9,-10,-11,-12,-13,-14,-16,-17,-19,-21,-23,-25,-28,-31,-34,-37,-41,-45,-50,-55,-60,-66,-73,-80,-88,-97,-107,-118,-130,-143,-157,-173,-190,-209,-230,-253,-279,-307,-337,-371,-408,-449,-494,-544,-598,-658,-724,-796,-876,-963,-1060,-1166,-1282,-1411,-1552,-1707,-1878,-2066,-2272,-2499,-2749,-3024,-3327,-3660,-4026,-4428,-4871,-5358,-5894,-6484,-7132,-7845,-8630,-9493,-10442,-11487,-12635,-13899,-15289,-16818,-18500,-20350,-22385,-24623,-27086,-29794,-32767,
-9,-10,-11,-13,-14,-15,-16,-18,-20,-21,-24,-26,-29,-31,-35,-39,-43,-46,-51,-56,-63,-69,-75,-83,-91,-100,-110,-121,-134,-148,-163,-179,-196,-216,-238,-261,-288,-316,-349,-384,-421,-464,-510,-561,-618,-680,-748,-823,-905,-995,-1095,-1204,-1325,-1458,-1603,-1764,-1940,-2134,-2348,-2583,-2840,-3124,-3436,-3780,-4159,-4575,-5033,-5535,-6089,-6698,-7368,-8105,-8915,-9806,-10788,-11866,-13053,-14359,-15794,-17374,-19111,-21023,-23125,-25438,-27981,-30779,-33858,-37243,-40959,
-11,-12,-14,-15,-17,-18,-20,-21,-24,-26,-29,-32,-35,-38,-42,-47,-51,-56,-62,-68,-75,-83,-90,-99,-110,-120,-132,-146,-161,-177,-195,-215,-236,-260,-285,-314,-345,-380,-419,-461,-506,-557,-612,-674,-741,-816,-897,-987,-1086,-1194,-1314,-1445,-1590,-1749,-1923,-2117,-2328,-2561,-2817,-3099,-3408,-3749,-4124,-4536,-4991,-5490,-6039,-6642,-7307,-8037,-8841,-9726,-10698,-11768,-12945,-14240,-15663,-17231,-18953,-20849,-22934,-25227,-27750,-30525,-33578,-36935,-40629,-44691,-49151,
-12,-14,-16,-18,-19,-21,-23,-25,-28,-30,-33,-37,-40,-44,-49,-54,-60,-65,-72,-79,-88,-96,-105,-116,-128,-140,-154,-170,-187,-207,-228,-250,-275,-303,-333,-366,-403,-443,-488,-537,-590,-649,-714,-786,-865,-952,-1047,-1152,-1267,-1393,-1533,-1685,-1855,-2041,-2244,-2469,-2716,-2987,-3287,-3616,-3976,-4373,-4811,-5292,-5822,-6405,-7046,-7749,-8524,-9377,-10315,-11347,-12481,-13729,-15103,-16613,-18274,-20102,-22111,-24323,-26756,-29432,-32375,-35613,-39174,-43090,-47401,-52140,-57342
};
static int[] s_anStepIndexMap = new int[] {
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,88,88,
4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,88,88,88,88,
6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,88,88,88,88,88,88,
8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,88,88,88,88,88,88,88,88,
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,
2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,88,88,
4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,88,88,88,88,
6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,88,88,88,88,88,88,
8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,88,88,88,88,88,88,88,88
};
public static byte[] EncodeImaAdpcmTableDriven(short[] ashPcm) {
ArrayList alsEncoded = new ArrayList();
short shPredicted = 0;
int nStepIndex = 0;
int[] anStep = new int[2];
for (int i = 0; i < ashPcm.Length; i += 2) {
// Encoded size is a nibble, so 2 per byte
for (int k = 0; k < 2; k++) {
anStep[k] = 0;
if (i + k == ashPcm.Length)
break;
int nDelta = ashPcm[i + k] - shPredicted;
int iStepSmallest = -1;
int nDiffSmallest = int.MaxValue;
for (int j = 0; j < 16; j++) {
int nStepFraction = s_anStepFractions[j * 89 + nStepIndex];
if (shPredicted + nStepFraction < -32768 || shPredicted + nStepFraction > 32767)
continue;
int nDiff = Math.Abs(nStepFraction - nDelta);
if (nDiff < nDiffSmallest) {
nDiffSmallest = nDiff;
iStepSmallest = j;
}
}
anStep[k] = iStepSmallest;
shPredicted += (short)s_anStepFractions[iStepSmallest * 89 + nStepIndex];
nStepIndex = s_anStepIndexMap[iStepSmallest * 89 + nStepIndex];
}
// Add 1 byte to output
alsEncoded.Add((byte)((anStep[0] << 4) | anStep[1]));
}
return (byte[])alsEncoded.ToArray(typeof(byte));
}
public static short[] DecodeImaAdpcmTableDriven(byte[] abIn) {
ArrayList alsPcm = new ArrayList();
short shPredicted = 0;
int nStepIndex = 0;
foreach (byte bT in abIn) {
int nDelta = bT >> 4;
shPredicted += (short)s_anStepFractions[nDelta * 89 + nStepIndex];
alsPcm.Add(shPredicted);
nStepIndex = s_anStepIndexMap[nDelta * 89 + nStepIndex];
nDelta = bT & 0xf;
shPredicted += (short)s_anStepFractions[nDelta * 89 + nStepIndex];
alsPcm.Add(shPredicted);
nStepIndex = s_anStepIndexMap[nDelta * 89 + nStepIndex];
}
return (short[])alsPcm.ToArray(typeof(short));
}
static int[] s_anStepFractions8BitEncode = new int[] {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,4,4,4,5,5,6,6,7,8,8,9,10,11,12,14,15,16,18,20,22,24,26,29,32,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,4,4,5,5,5,6,7,7,8,9,10,11,12,13,14,15,17,19,20,22,25,27,30,33,36,40,44,48,53,58,64,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,4,4,4,5,5,6,6,7,8,8,9,10,11,12,13,14,16,17,19,21,23,25,28,31,34,37,41,45,49,54,60,66,72,79,87,96,106,116,128,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,4,4,5,5,5,5,6,7,8,8,9,10,11,12,14,14,16,18,20,21,23,26,29,32,35,38,42,46,50,56,61,67,74,81,89,98,108,119,131,144,158,174,191,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,3,3,3,3,4,4,5,5,6,6,7,7,8,9,10,11,12,13,15,16,18,19,21,24,26,28,31,34,38,42,46,50,56,61,67,74,81,89,98,108,119,131,144,158,174,192,211,232,255,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,4,4,4,4,5,5,6,6,8,8,9,9,10,11,13,14,15,16,19,20,23,24,26,30,33,35,39,43,48,53,58,63,70,76,84,93,101,111,123,135,149,164,180,198,218,240,264,290,319,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,5,5,5,5,6,6,8,8,9,9,11,11,12,14,15,17,18,20,23,24,27,29,32,36,39,42,47,51,57,63,69,75,84,92,101,111,122,134,147,162,179,197,216,237,261,288,317,348,383,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,4,4,4,4,4,5,5,5,5,7,7,9,9,11,11,12,12,14,16,18,19,21,23,26,28,32,33,37,42,46,49,54,60,67,74,81,88,98,107,117,130,142,156,172,189,208,229,252,277,305,336,369,406,446,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2,-2,-2,-2,-2,-2,-3,-3,-3,-4,-4,-4,-5,-5,-6,-6,-7,-8,-8,-9,-10,-11,-12,-14,-15,-16,-18,-20,-22,-24,-26,-29,-32,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2,-2,-2,-2,-2,-2,-3,-3,-3,-3,-4,-4,-5,-5,-5,-6,-7,-7,-8,-9,-10,-11,-12,-13,-14,-15,-17,-19,-20,-22,-25,-27,-30,-33,-36,-40,-44,-48,-53,-58,-64,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2,-2,-2,-2,-2,-2,-3,-3,-3,-3,-4,-4,-4,-5,-5,-6,-6,-7,-8,-8,-9,-10,-11,-12,-13,-14,-16,-17,-19,-21,-23,-25,-28,-31,-34,-37,-41,-45,-49,-54,-60,-66,-72,-79,-87,-96,-106,-116,-128,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2,-2,-2,-2,-2,-2,-2,-2,-2,-3,-3,-4,-4,-5,-5,-5,-5,-6,-7,-8,-8,-9,-10,-11,-12,-14,-14,-16,-18,-20,-21,-23,-26,-29,-32,-35,-38,-42,-46,-50,-56,-61,-67,-74,-81,-89,-98,-108,-119,-131,-144,-158,-174,-191,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2,-2,-2,-2,-2,-3,-3,-3,-3,-4,-4,-5,-5,-6,-6,-7,-7,-8,-9,-10,-11,-12,-13,-15,-16,-18,-19,-21,-24,-26,-28,-31,-34,-38,-42,-46,-50,-56,-61,-67,-74,-81,-89,-98,-108,-119,-131,-144,-158,-174,-192,-211,-232,-255,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-3,-3,-3,-3,-3,-4,-4,-4,-4,-5,-5,-6,-6,-8,-8,-9,-9,-10,-11,-13,-14,-15,-16,-19,-20,-23,-24,-26,-30,-33,-35,-39,-43,-48,-53,-58,-63,-70,-76,-84,-93,-101,-111,-123,-135,-149,-164,-180,-198,-218,-240,-264,-290,-319,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-3,-3,-3,-3,-3,-5,-5,-5,-5,-6,-6,-8,-8,-9,-9,-11,-11,-12,-14,-15,-17,-18,-20,-23,-24,-27,-29,-32,-36,-39,-42,-47,-51,-57,-63,-69,-75,-84,-92,-101,-111,-122,-134,-147,-162,-179,-197,-216,-237,-261,-288,-317,-348,-383,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-4,-4,-4,-4,-4,-5,-5,-5,-5,-7,-7,-9,-9,-11,-11,-12,-12,-14,-16,-18,-19,-21,-23,-26,-28,-32,-33,-37,-42,-46,-49,-54,-60,-67,-74,-81,-88,-98,-107,-117,-130,-142,-156,-172,-189,-208,-229,-252,-277,-305,-336,-369,-406,-446
};
public static byte[] EncodeImaAdpcmTableDriven8Bit(byte[] abPcm) {
ArrayList alsEncoded = new ArrayList();
byte bPredicted = 128;
int nStepIndex = 0;
int[] anStep = new int[2];
for (int i = 0; i < abPcm.Length; i += 2) {
// Encoded size is a nibble, so 2 per byte
for (int k = 0; k < 2; k++) {
anStep[k] = 0;
if (i + k == abPcm.Length)
break;
int nDelta = abPcm[i + k] - bPredicted;
int iStepSmallest = -1;
int nDiffSmallest = int.MaxValue;
for (int j = 0; j < 16; j++) {
int nStepFraction = s_anStepFractions8BitEncode[j * 89 + nStepIndex];
if (bPredicted + nStepFraction < 0 || bPredicted + nStepFraction > 255)
continue;
int nDiff = Math.Abs(nStepFraction - nDelta);
if (nDiff <= nDiffSmallest) {
nDiffSmallest = nDiff;
iStepSmallest = j;
}
}
anStep[k] = iStepSmallest;
bPredicted += (byte)s_anStepFractions8BitEncode[iStepSmallest * 89 + nStepIndex];
nStepIndex = s_anStepIndexMap[iStepSmallest * 89 + nStepIndex];
}
// Add 1 byte to output
alsEncoded.Add((byte)((anStep[0] << 4) | anStep[1]));
}
return (byte[])alsEncoded.ToArray(typeof(byte));
}
static byte[] s_anStepFractions8BitDecode = new byte[] {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,4,4,4,5,5,6,6,7,8,8,9,10,11,12,14,15,16,18,20,22,24,26,29,32,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,4,4,5,5,5,6,7,7,8,9,10,11,12,13,14,15,17,19,20,22,25,27,30,33,36,40,44,48,53,58,64,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,4,4,4,5,5,6,6,7,8,8,9,10,11,12,13,14,16,17,19,21,23,25,28,31,34,37,41,45,49,54,60,66,72,79,87,96,106,116,128,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,4,4,5,5,5,5,6,7,8,8,9,10,11,12,14,14,16,18,20,21,23,26,29,32,35,38,42,46,50,56,61,67,74,81,89,98,108,119,131,144,158,174,191,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,3,3,3,3,4,4,5,5,6,6,7,7,8,9,10,11,12,13,15,16,18,19,21,24,26,28,31,34,38,42,46,50,56,61,67,74,81,89,98,108,119,131,144,158,174,192,211,232,255,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,4,4,4,4,5,5,6,6,8,8,9,9,10,11,13,14,15,16,19,20,23,24,26,30,33,35,39,43,48,53,58,63,70,76,84,93,101,111,123,135,149,164,180,198,218,240,255,255,255,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,5,5,5,5,6,6,8,8,9,9,11,11,12,14,15,17,18,20,23,24,27,29,32,36,39,42,47,51,57,63,69,75,84,92,101,111,122,134,147,162,179,197,216,237,255,255,255,255,255,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,4,4,4,4,4,5,5,5,5,7,7,9,9,11,11,12,12,14,16,18,19,21,23,26,28,32,33,37,42,46,49,54,60,67,74,81,88,98,107,117,130,142,156,172,189,208,229,252,255,255,255,255,255,255,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,254,254,254,254,254,254,253,253,253,252,252,252,251,251,250,250,249,248,248,247,246,245,244,242,241,240,238,236,234,232,230,227,224,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,254,254,254,254,254,254,253,253,253,253,252,252,251,251,251,250,249,249,248,247,246,245,244,243,242,241,239,237,236,234,231,229,226,223,220,216,212,208,203,198,192,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,254,254,254,254,254,253,253,253,253,252,252,252,251,251,250,250,249,248,248,247,246,245,244,243,242,240,239,237,235,233,231,228,225,222,219,215,211,207,202,196,190,184,177,169,160,150,140,128,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,254,254,254,254,254,254,254,254,254,253,253,252,252,251,251,251,251,250,249,248,248,247,246,245,244,242,242,240,238,236,235,233,230,227,224,221,218,214,210,206,200,195,189,182,175,167,158,148,137,125,112,98,82,65,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,254,254,254,254,254,253,253,253,253,252,252,251,251,250,250,249,249,248,247,246,245,244,243,241,240,238,237,235,232,230,228,225,222,218,214,210,206,200,195,189,182,175,167,158,148,137,125,112,98,82,64,45,24,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,253,253,253,253,253,252,252,252,252,251,251,250,250,248,248,247,247,246,245,243,242,241,240,237,236,233,232,230,226,223,221,217,213,208,203,198,193,186,180,172,163,155,145,133,121,107,92,76,58,38,16,1,1,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,254,254,254,254,254,254,254,254,254,254,254,253,253,253,253,253,251,251,251,251,250,250,248,248,247,247,245,245,244,242,241,239,238,236,233,232,229,227,224,220,217,214,209,205,199,193,187,181,172,164,155,145,134,122,109,94,77,59,40,19,1,1,1,1,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,254,254,254,254,254,254,254,254,254,254,254,252,252,252,252,252,251,251,251,251,249,249,247,247,245,245,244,244,242,240,238,237,235,233,230,228,224,223,219,214,210,207,202,196,189,182,175,168,158,149,139,126,114,100,84,67,48,27,4,1,1,1,1,1,1
};
public static byte[] DecodeImaAdpcmTableDriven8Bit(byte[] abIn) {
ArrayList alsPcm = new ArrayList();
byte bPredicted = 128;
int nStepIndex = 0;
foreach (byte bT in abIn) {
int nDelta = bT >> 4;
bPredicted += s_anStepFractions8BitDecode[nDelta * 89 + nStepIndex];
alsPcm.Add(bPredicted);
nStepIndex = s_anStepIndexMap[nDelta * 89 + nStepIndex];
nDelta = bT & 0xf;
bPredicted += s_anStepFractions8BitDecode[nDelta * 89 + nStepIndex];
alsPcm.Add(bPredicted);
nStepIndex = s_anStepIndexMap[nDelta * 89 + nStepIndex];
}
return (byte[])alsPcm.ToArray(typeof(byte));
}
public static byte[] EncodeYamahaAdpcm(short[] ashPcm) {
ArrayList alsEncoded = new ArrayList();
int nPcmPredicted = 0;
int nStep = 0x7f;
byte bOutput = 0;
for (int ish = 0; ish < ashPcm.Length; ish++) {
//Console.WriteLine("ish: " + ish + " nPcmPredicted: " + nPcmPredicted + " nStep: " + nStep);
//if (ish == 256)
// Debug.Assert(false);
int nPcm = ashPcm[ish];
int nDiff = nPcm - nPcmPredicted;
bool fNegative = false;
if (nDiff < 0) {
fNegative = true;
nDiff = -nDiff;
}
// Get fraction in multiples of 1/4ths. Note by first shifting down by two, resolution is lost.
// I.e. x / 4 * 2 != x / 2.
int cTimes = 0;
int nStep4th = nStep / 4;
int nFracT = nStep4th;
while (cTimes < 7) {
if (nDiff < nFracT)
break;
nFracT += nStep4th;
cTimes++;
}
// Interestingly this "rebuilding" from bits has more precision that the above
// because of the above nStep / 4. The nStep / 2 below has more precision than
// 2 * (nStep / 4). For example 23 / 4 * 2 == 10 vs. 23 / 2 == 11.
int nStepFraction = 0;
if ((cTimes & 1) != 0)
nStepFraction += nStep / 4;
if ((cTimes & 2) != 0)
nStepFraction += nStep / 2;
if ((cTimes & 4) != 0)
nStepFraction += nStep;
nStepFraction += nStep / 8;
// Add to predicted, do range check
byte b = (byte)cTimes;
if (fNegative) {
nPcmPredicted -= nStepFraction;
b |= 8;
} else {
nPcmPredicted += nStepFraction;
}
if (nPcmPredicted > 32767) {
nPcmPredicted = 32767;
} else if (nPcmPredicted < -32768) {
nPcmPredicted = -32768;
}
// Yamaha calcs the next step like this. Same as MS ADPCM in terms of constants used
switch (b & 7) {
case 0:
case 1:
case 2:
case 3:
nStep = nStep * 230 / 256;
break;
case 4:
nStep = nStep * 307 / 256;
break;
case 5:
nStep = nStep * 409 / 256;
break;
case 6:
nStep = nStep * 512 / 256;
break;
case 7:
nStep = nStep * 614 / 256;
break;
}
// Bounds check the step
if (nStep < 0x7f) {
nStep = 0x7f;
} else if (nStep > 0x6000) {
nStep = 0x6000;
}
// Output a byte. Yamaha uses "little endian" nibble order.
if ((ish & 1) == 0) {
bOutput = (byte)(b & 0x0f);
} else {
bOutput |= (byte)((b << 4) & 0xf0);
alsEncoded.Add(bOutput);
}
}
return (byte[])alsEncoded.ToArray(typeof(byte));
}
public static byte[] EncodeYamahaAdpcmFaster(short[] ashPcm) {
ArrayList alsEncoded = new ArrayList();
int nPcmPredicted = 0;
int nStep = 0x7f;
// Encoding test for "fastest" encoding. Essentially this unrolls the conditionals as much as possible.
// This is an algorithmic test before encoding this in assembly language
for (int ish = 0; ish < ashPcm.Length; ish += 2) {
//Console.WriteLine("ish: " + ish + " nPcmPredicted: " + nPcmPredicted + " nStep: " + nStep);
//if (ish == 256)
// Debug.Assert(false);
byte bOut;
int nDiff;
// Low nibble (first sample of byte)
nDiff = ashPcm[ish] - nPcmPredicted;
if (nDiff >= 0) {
// nDiff positive
int nStepT = nStep & ~3;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT = nStepT >> 1;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x07
nPcmPredicted += nStep + (nStep >> 1) + nStepT + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 614) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
bOut = 0x07;
} else {
// case 0x06
nPcmPredicted += nStep + (nStep >> 1) + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep <<= 1;
if (nStep > 0x6000)
nStep = 0x6000;
bOut = 0x06;
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x05
nPcmPredicted += nStep + nStepT + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 409) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
bOut = 0x05;
} else {
// case 0x04
nPcmPredicted += nStep + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 307) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
bOut = 0x04;
}
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x03
nPcmPredicted += (nStep >> 1) + nStepT + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
bOut = 0x03;
} else {
// case 0x02
nPcmPredicted += (nStep >> 1) + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
bOut = 0x02;
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x01
nPcmPredicted += nStepT + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
bOut = 0x01;
} else {
// case 0x00
nPcmPredicted += (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
bOut = 0x00;
}
}
}
} else {
// nDiff negative
nDiff = -nDiff;
int nStepT = nStep & ~3;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x0f
nPcmPredicted -= nStep + (nStep >> 1) + nStepT + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 614) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
bOut = 0x0f;
} else {
// case 0x0e
nPcmPredicted -= nStep + (nStep >> 1) + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep <<= 1;
if (nStep > 0x6000)
nStep = 0x6000;
bOut = 0x0e;
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x0d
nPcmPredicted -= nStep + nStepT + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 409) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
bOut = 0x0d;
} else {
// case 0x0c
nPcmPredicted -= nStep + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 307) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
bOut = 0x0c;
}
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x0b
nPcmPredicted -= (nStep >> 1) + nStepT + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
bOut = 0x0b;
} else {
// case 0x0a
nPcmPredicted -= (nStep >> 1) + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
bOut = 0x0a;
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x09
nPcmPredicted -= nStepT + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
bOut = 0x09;
} else {
// case 0x08
nPcmPredicted -= (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
bOut = 0x08;
}
}
}
}
// High nibble, second sample of byte
nDiff = ashPcm[ish + 1] - nPcmPredicted;
if (nDiff >= 0) {
// nDiff positive
int nStepT = nStep & ~3;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x07
nPcmPredicted += nStep + (nStep >> 1) + nStepT + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 614) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
alsEncoded.Add((byte)(0x70 + bOut));
} else {
// case 0x06
nPcmPredicted += nStep + (nStep >> 1) + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep <<= 1;
if (nStep > 0x6000)
nStep = 0x6000;
alsEncoded.Add((byte)(0x60 + bOut));
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x05
nPcmPredicted += nStep + nStepT + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 409) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
alsEncoded.Add((byte)(0x50 + bOut));
} else {
// case 0x04
nPcmPredicted += nStep + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 307) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
alsEncoded.Add((byte)(0x40 + bOut));
}
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x03
nPcmPredicted += (nStep >> 1) + nStepT + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
alsEncoded.Add((byte)(0x30 + bOut));
} else {
// case 0x02
nPcmPredicted += (nStep >> 1) + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
alsEncoded.Add((byte)(0x20 + bOut));
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x01
nPcmPredicted += nStepT + (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
alsEncoded.Add((byte)(0x10 + bOut));
} else {
// case 0x00
nPcmPredicted += (nStepT >> 1);
if (nPcmPredicted > 32767)
nPcmPredicted = 32767;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
alsEncoded.Add((byte)(0x00 + bOut));
}
}
}
} else {
// nDiff negative
nDiff = -nDiff;
int nStepT = nStep & ~3;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x0f
nPcmPredicted -= nStep + (nStep >> 1) + nStepT + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 614) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
alsEncoded.Add((byte)(0xf0 + bOut));
} else {
// case 0x0e
nPcmPredicted -= nStep + (nStep >> 1) + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep <<= 1;
if (nStep > 0x6000)
nStep = 0x6000;
alsEncoded.Add((byte)(0xe0 + bOut));
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x0d
nPcmPredicted -= nStep + nStepT + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 409) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
alsEncoded.Add((byte)(0xd0 + bOut));
} else {
// case 0x0c
nPcmPredicted -= nStep + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 307) >> 8;
if (nStep > 0x6000)
nStep = 0x6000;
alsEncoded.Add((byte)(0xc0 + bOut));
}
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
nDiff -= nStepT;
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x0b
nPcmPredicted -= (nStep >> 1) + nStepT + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
alsEncoded.Add((byte)(0xb0 + bOut));
} else {
// case 0x0a
nPcmPredicted -= (nStep >> 1) + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
alsEncoded.Add((byte)(0xa0 + bOut));
}
} else {
nStepT >>= 1;
if (nDiff >= nStepT) {
// case 0x09
nPcmPredicted -= nStepT + (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
alsEncoded.Add((byte)(0x90 + bOut));
} else {
// case 0x08
nPcmPredicted -= (nStepT >> 1);
if (nPcmPredicted < -32768)
nPcmPredicted = -32768;
nStep = (nStep * 230) >> 8;
if (nStep < 0x7f)
nStep = 0x7f;
alsEncoded.Add((byte)(0x80 + bOut));
}
}
}
}
}
return (byte[])alsEncoded.ToArray(typeof(byte));
}
public static void Write8BitAdpcmDecodeTable() {
TextWriter tw = new StreamWriter("decode.s");
tw.WriteLine("Decode8BitAdpcm:");
for (int nStepIndex = 0; nStepIndex < 89; nStepIndex++) {
tw.WriteLine("| Step Index " + nStepIndex);
tw.Write(".byte ");
for (int nDelta = 0; nDelta < 16; nDelta++)
tw.Write(s_anStepFractions8BitDecode[nDelta * 89 + nStepIndex] + (nDelta == 15 ? "\n" : ", "));
tw.Write(".word ");
for (int nDelta = 0; nDelta < 16; nDelta++) {
int offCurrentIndex = 48 * nStepIndex;
int nStepIndexNew = s_anStepIndexMap[nDelta * 89 + nStepIndex];
int offNewIndex = 48 * nStepIndexNew;
tw.Write("0x" + ((ushort)(offNewIndex - offCurrentIndex)).ToString("x") + (nDelta == 15 ? "\n" : ", "));
}
}
tw.Close();
}
public static void Write8BitAdpcmDecodeTableC() {
TextWriter tw = new StreamWriter("decode.cpp");
tw.WriteLine("byte gabAdpcmSteppings[89][16] = {");
for (int nStepIndex = 0; nStepIndex < 89; nStepIndex++) {
tw.Write(" ");
for (int nDelta = 0; nDelta < 16; nDelta++)
tw.Write(s_anStepFractions8BitDecode[nDelta * 89 + nStepIndex] + (nDelta == 15 ? ",\n" : ", "));
}
tw.WriteLine("};");
tw.WriteLine("char s_anStepIndexMap[89][16] = {");
for (int nStepIndex = 0; nStepIndex < 89; nStepIndex++) {
tw.Write(" ");
for (int nDelta = 0; nDelta < 16; nDelta++)
tw.Write(s_anStepIndexMap[nDelta * 89 + nStepIndex] + (nDelta == 15 ? ",\n" : ", "));
}
tw.WriteLine("};");
tw.Close();
}
}
class Pcm {
int m_cBits;
int m_hz;
byte[] m_ab;
short[] m_ash;
// See http://www.intersrv.com/~dcross/wavio.html for format info, or
// http://ccrma-www.stanford.edu/courses/422/projects/WaveFormat/
[StructLayout(LayoutKind.Sequential)]
struct FourCC {
public byte b0;
public byte b1;
public byte b2;
public byte b3;
public FourCC(string str) {
b0 = (byte)str[0];
b1 = (byte)str[1];
b2 = (byte)str[2];
b3 = (byte)str[3];
}
};
[StructLayout(LayoutKind.Sequential)]
struct WavFileHeader {
public FourCC fccRIFF;
public uint cbRiffBytes;
public FourCC fccWAVE;
public FourCC fccfmt;
public uint cbfmtBytes;
public ushort wFormatTag;
public ushort nChannels;
public uint nSamplesPerSec;
public uint nAvgBytesPerSec;
public ushort nBlockAlign;
public ushort nBitsPerSample;
public FourCC fccdata;
public uint cbdataBytes;
};
unsafe public Pcm (string strWav) {
if (strWav.EndsWith(".wav") || strWav.EndsWith(".WAV")) {
LoadWavFile(strWav);
}
if (strWav.EndsWith(".snd")) {
LoadSndFile(strWav);
}
}
unsafe void LoadWavFile(string strWav) {
BinaryReader brdr = new BinaryReader(new FileStream(strWav, FileMode.Open, FileAccess.Read, FileShare.Read));
byte[] ab = brdr.ReadBytes((int)brdr.BaseStream.Length);
brdr.Close();
WavFileHeader *pwavhdr = (WavFileHeader *)Marshal.UnsafeAddrOfPinnedArrayElement(ab, 0);
bool fOk = true;
if (pwavhdr->wFormatTag != 1)
fOk = false;
if (pwavhdr->nBitsPerSample != 8 && pwavhdr->nBitsPerSample != 16)
fOk = false;
if (!fOk)
throw new Exception("Only support reading 8 / 16 bit raw pcm!");
m_cBits = pwavhdr->nBitsPerSample;
m_hz = (int)pwavhdr->nSamplesPerSec;
int cbSizeType = Marshal.SizeOf(pwavhdr->GetType());
switch (m_cBits) {
case 8:
m_ab = new byte[pwavhdr->cbdataBytes];
for (int i = 0; i < m_ab.Length; i++)
m_ab[i] = ab[i + cbSizeType];
break;
case 16:
m_ash = new short[pwavhdr->cbdataBytes / 2];
for (int i = 0; i < pwavhdr->cbdataBytes; i += 2)
m_ash[i / 2] = (short)(ab[i + cbSizeType] + ab[1 + i + cbSizeType] * 256);
break;
}
}
void LoadSndFile(string strSnd) {
BinaryReader brdr = new BinaryReader(new FileStream(strSnd, FileMode.Open, FileAccess.Read, FileShare.Read));
byte[] ab = brdr.ReadBytes((int)brdr.BaseStream.Length);
brdr.Close();
m_cBits = 8;
m_hz = 8000;
m_ab = new byte[ab.Length - 6];
for (int i = 0; i < m_ab.Length; i++)
m_ab[i] = ab[i + 6];
}
public Pcm(int hz, byte[] ab) {
m_cBits = 8;
m_hz = hz;
m_ab = ab;
}
public Pcm(int hz, short[] ash) {
m_cBits = 16;
m_hz = hz;
m_ash = ash;
}
public int BitsPerSample {
get {
return m_cBits;
}
}
public int Hertz {
get {
return m_hz;
}
}
public byte[] Data8Bit {
get {
return (byte[])m_ab.Clone();
}
set {
m_cBits = 8;
m_ash = null;
m_ab = (byte[])value.Clone();
}
}
public short[] Data16Bit {
get {
return (short[])m_ash.Clone();
}
set {
m_cBits = 16;
m_ab = null;
m_ash = (short[])value.Clone();
}
}
public void ConvertTo16Bit() {
if (m_cBits == 16)
return;
// 8 bit unsigned (0,127==-128,-1 and 128,255==0,127) to
// 16 bit signed (-32768 -> 32767)
short[] ash = new short[m_ab.Length];
for (int i = 0; i < ash.Length; i++) {
ash[i] = (short)((short)m_ab[i] * 256);
ash[i] = (short)(ash[i] ^ 0x8000);
}
Data16Bit = ash;
}
public void ConvertTo8Bit() {
if (m_cBits == 8)
return;
// 16 bit signed (-32768 -> 32767) to
// 8 bit unsigned (0,127==-128,-1 and 128,255==0,127)
byte[] ab = new byte[m_ash.Length];
for (int i = 0; i < ab.Length; i++)
ab[i] = (byte)((m_ash[i] ^ 0x8000) / 256);
Data8Bit = ab;
}
public void SetMaxSize(int cbMax) {
if (m_cBits == 8) {
if (m_ab.Length > cbMax) {
byte[] abT = new byte[32700];
Array.Copy(m_ab, 0, abT, 0, abT.Length);
m_ab = abT;
}
} else {
if (m_ash.Length * 2 > cbMax) {
short[] ashT = new short[cbMax / 2];
Array.Copy(m_ash, 0, ashT, 0, ashT.Length);
m_ash = ashT;
}
}
}
[DllImportAttribute("winmm.dll")]
private static extern int PlaySoundW(IntPtr pbSound, IntPtr hModule, uint fdwSound);
const UInt32 SND_SYNC = 0x0000; // play synchronously (default)
const UInt32 SND_ASYNC = 0x0001; // play asynchronously
const UInt32 SND_NODEFAULT = 0x0002; // silence (!default) if sound not found
const UInt32 SND_MEMORY = 0x0004; // pszSound points to a memory file
const UInt32 SND_LOOP = 0x0008; // loop the sound until next sndPlaySound
const UInt32 SND_NOSTOP = 0x0010; // don't stop any currently playing sound
const UInt32 SND_NOWAIT = 0x00002000; // don't wait if the driver is busy
const UInt32 SND_ALIAS = 0x00010000; // name is a registry alias
const UInt32 SND_ALIAS_ID = 0x00110000; // alias is a predefined ID
const UInt32 SND_FILENAME = 0x00020000; // name is file name
const UInt32 SND_RESOURCE = 0x00040004; // name is resource name or atom
const UInt32 SND_PURGE = 0x0040;
const UInt32 SND_APPLICATION = 0x0080; // look for application specific association
unsafe public void Play() {
// Fill in the header
if (m_ab == null && m_ash == null)
return;
int cbData = m_cBits == 8 ? m_ab.Length : m_ash.Length * 2;
WavFileHeader wavhdr;
wavhdr.fccRIFF = new FourCC("RIFF");
wavhdr.cbRiffBytes = (uint)(Marshal.SizeOf(typeof(WavFileHeader)) - 8 + cbData);
wavhdr.fccWAVE = new FourCC("WAVE");
wavhdr.fccfmt = new FourCC("fmt ");
wavhdr.cbfmtBytes = 16;
wavhdr.wFormatTag = 1;
wavhdr.nChannels = 1;
wavhdr.nSamplesPerSec = (uint)m_hz;
wavhdr.nAvgBytesPerSec = (uint)(m_cBits / 8 * m_hz);
wavhdr.nBlockAlign = (ushort)(m_cBits / 8);
wavhdr.nBitsPerSample = (ushort)m_cBits;
wavhdr.fccdata = new FourCC("data");
wavhdr.cbdataBytes = (uint)cbData;
// Serialize the data
byte[] ab = SerializeStructure(null, &wavhdr, Marshal.SizeOf(wavhdr.GetType()));
switch (m_cBits) {
case 8:
ab = SerializeStructure(ab, (void *)Marshal.UnsafeAddrOfPinnedArrayElement(m_ab, 0), m_ab.Length);
break;
case 16:
ab = SerializeStructure(ab, (void *)Marshal.UnsafeAddrOfPinnedArrayElement(m_ash, 0), m_ash.Length * 2);
break;
}
// Play the sound
IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(ab, 0);
int nSuccess = PlaySoundW(ptr, IntPtr.Zero, SND_ASYNC | SND_MEMORY);
Debug.Assert(nSuccess != 0);
}
unsafe static byte[] SerializeStructure(byte[] ab, void *pv, int cb) {
byte *pb = (byte *)pv;
byte[] abNew = null;
if (ab == null) {
abNew = new byte[cb];
for (int i = 0; i < cb; i++)
abNew[i] = pb[i];
} else {
abNew = new byte[ab.Length + cb];
for (int i = 0; i < ab.Length; i++)
abNew[i] = ab[i];
for (int i = 0; i < cb; i++)
abNew[i + ab.Length] = pb[i];
}
return abNew;
}
unsafe public static void PlayWavFile(string strWav) {
// Get the bytes
BinaryReader brdr = new BinaryReader(new FileStream(strWav, FileMode.Open));
byte[] ab = brdr.ReadBytes((int)brdr.BaseStream.Length);
brdr.Close();
// Play the wav
IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(ab, 0);
int nSuccess = PlaySoundW(ptr, IntPtr.Zero, SND_ASYNC | SND_MEMORY);
Debug.Assert(nSuccess != 0);
}
public byte[] GetSndEncoding() {
ConvertTo8Bit();
SetMaxSize(32700 * 2);
return AudioFormats.EncodeImaAdpcmTableDriven8Bit(Data8Bit);
}
#if false
static byte[] MassageSample(byte[] abPcm) {
// Need to make sure that the encoded size is a multiple of 2 bytes in size, which means the
// raw size needs to be a multiple of 4 in size, and need to trail the amplitude to 128 to
// reduce click sounds.
byte[] abPcmNew = new byte[(abPcm.Length + 7) & ~3];
// Copy in the existing pcm
Array.Copy(abPcm, 0, abPcmNew, 0, abPcm.Length);
// Perform fade
int cSamplesFade = abPcmNew.Length - abPcm.Length;
int nSampleLast = (int)abPcm[abPcm.Length - 1];
int nStep = -((nSampleLast - 128) / cSamplesFade);
for (int iSample = abPcm.Length; iSample < abPcmNew.Length; iSample++) {
if (iSample == abPcmNew.Length - 1) {
nSampleLast = 0;
} else {
nSampleLast += nStep;
}
abPcmNew[iSample] = (byte)nSampleLast;
}
return abPcmNew;
}
#endif
}
}
Reference in New Issue View Git Blame Copy Permalink