namespace NSpeex
|
{
|
using System;
|
|
internal class SbEncoder : SbCodec, IEncoder
|
{
|
protected internal float abr_count;
|
protected internal float abr_drift;
|
protected internal float abr_drift2;
|
protected internal int abr_enabled;
|
private float[] autocorr;
|
private float[] buf;
|
private float[] bw_lpc1;
|
private float[] bw_lpc2;
|
protected internal int complexity;
|
private float[] h0_mem;
|
private float[] interp_lpc;
|
private float[] interp_lsp;
|
private float[] lagWindow;
|
protected internal IEncoder lowenc;
|
private float[] lsp;
|
private float[] mem_sp2;
|
private float[] mem_sw;
|
protected internal int nb_modes;
|
private static readonly int[] NB_QUALITY_MAP = new int[] { 1, 8, 2, 3, 4, 5, 5, 6, 6, 7, 7 };
|
private float[] old_lsp;
|
private float[] rc;
|
protected internal float relative_quality;
|
private float[] res;
|
protected internal int sampling_rate;
|
protected internal int submodeSelect;
|
private float[] swBuf;
|
private float[] target;
|
private bool uwb;
|
private static readonly int[] UWB_QUALITY_MAP = new int[] { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
|
protected internal int vad_enabled;
|
protected internal int vbr_enabled;
|
protected internal float vbr_quality;
|
private static readonly int[] WB_QUALITY_MAP = new int[] { 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 4 };
|
private float[] window;
|
private float[] x1d;
|
|
public SbEncoder(bool ultraWide) : base(ultraWide)
|
{
|
if (ultraWide)
|
{
|
this.Uwbinit();
|
}
|
else
|
{
|
this.Wbinit();
|
}
|
}
|
|
public virtual int Encode(Bits bits, float[] ins0)
|
{
|
int num;
|
int num2;
|
Filters.Qmf_decomp(ins0, Codebook_Constants.h0, base.x0d, this.x1d, base.fullFrameSize, 0x40, this.h0_mem);
|
this.lowenc.Encode(bits, base.x0d);
|
for (num = 0; num < (base.windowSize - base.frameSize); num++)
|
{
|
base.high[num] = base.high[base.frameSize + num];
|
}
|
for (num = 0; num < base.frameSize; num++)
|
{
|
base.high[(base.windowSize - base.frameSize) + num] = this.x1d[num];
|
}
|
Array.Copy(base.excBuf, base.frameSize, base.excBuf, 0, base.bufSize - base.frameSize);
|
float[] piGain = this.lowenc.PiGain;
|
float[] exc = this.lowenc.Exc;
|
float[] innov = this.lowenc.Innov;
|
if (this.lowenc.Mode == 0)
|
{
|
num2 = 1;
|
}
|
else
|
{
|
num2 = 0;
|
}
|
num = 0;
|
while (num < base.windowSize)
|
{
|
this.buf[num] = base.high[num] * this.window[num];
|
num++;
|
}
|
Lpc.Autocorr(this.buf, this.autocorr, base.lpcSize + 1, base.windowSize);
|
this.autocorr[0]++;
|
this.autocorr[0] *= base.lpc_floor;
|
for (num = 0; num < (base.lpcSize + 1); num++)
|
{
|
this.autocorr[num] *= this.lagWindow[num];
|
}
|
Lpc.Wld(base.lpc, this.autocorr, this.rc, base.lpcSize);
|
Array.Copy(base.lpc, 0, base.lpc, 1, base.lpcSize);
|
base.lpc[0] = 1f;
|
if ((Lsp.Lpc2lsp(base.lpc, base.lpcSize, this.lsp, 15, 0.2f) != base.lpcSize) && (Lsp.Lpc2lsp(base.lpc, base.lpcSize, this.lsp, 11, 0.02f) != base.lpcSize))
|
{
|
for (num = 0; num < base.lpcSize; num++)
|
{
|
this.lsp[num] = (float)Math.Cos((3.1415926535897931 * (num + 1)) / ((double)(base.lpcSize + 1)));
|
}
|
}
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
this.lsp[num] = (float)Math.Acos((double)this.lsp[num]);
|
num++;
|
}
|
float num5 = 0f;
|
for (num = 0; num < base.lpcSize; num++)
|
{
|
num5 += (this.old_lsp[num] - this.lsp[num]) * (this.old_lsp[num] - this.lsp[num]);
|
}
|
if (((this.vbr_enabled != 0) || (this.vad_enabled != 0)) && (num2 == 0))
|
{
|
float num6 = 0f;
|
float num7 = 0f;
|
if (this.abr_enabled != 0)
|
{
|
float num9 = 0f;
|
if ((this.abr_drift2 * this.abr_drift) > 0f)
|
{
|
num9 = (-1E-05f * this.abr_drift) / (1f + this.abr_count);
|
if (num9 > 0.1f)
|
{
|
num9 = 0.1f;
|
}
|
if (num9 < -0.1f)
|
{
|
num9 = -0.1f;
|
}
|
}
|
this.vbr_quality += num9;
|
if (this.vbr_quality > 10f)
|
{
|
this.vbr_quality = 10f;
|
}
|
if (this.vbr_quality < 0f)
|
{
|
this.vbr_quality = 0f;
|
}
|
}
|
num = 0;
|
while (num < base.frameSize)
|
{
|
num6 += base.x0d[num] * base.x0d[num];
|
num7 += base.high[num] * base.high[num];
|
num++;
|
}
|
float num8 = (float)Math.Log((double)((1f + num7) / (1f + num6)));
|
this.relative_quality = this.lowenc.RelativeQuality;
|
if (num8 < -4f)
|
{
|
num8 = -4f;
|
}
|
if (num8 > 2f)
|
{
|
num8 = 2f;
|
}
|
if (this.vbr_enabled == 0)
|
{
|
int submodeSelect;
|
if (this.relative_quality < 2.0)
|
{
|
submodeSelect = 1;
|
}
|
else
|
{
|
submodeSelect = this.submodeSelect;
|
}
|
base.submodeID = submodeSelect;
|
}
|
else
|
{
|
int index = this.nb_modes - 1;
|
this.relative_quality += 1f * (num8 + 2f);
|
if (this.relative_quality < -1f)
|
{
|
this.relative_quality = -1f;
|
}
|
while (index != 0)
|
{
|
float num12;
|
int num11 = (int)Math.Floor((double)this.vbr_quality);
|
if (num11 == 10)
|
{
|
num12 = NSpeex.Vbr.hb_thresh[index][num11];
|
}
|
else
|
{
|
num12 = ((this.vbr_quality - num11) * NSpeex.Vbr.hb_thresh[index][num11 + 1]) + (((1 + num11) - this.vbr_quality) * NSpeex.Vbr.hb_thresh[index][num11]);
|
}
|
if (this.relative_quality >= num12)
|
{
|
break;
|
}
|
index--;
|
}
|
this.Mode = index;
|
if (this.abr_enabled != 0)
|
{
|
int bitRate = this.BitRate;
|
this.abr_drift += bitRate - this.abr_enabled;
|
this.abr_drift2 = (0.95f * this.abr_drift2) + (0.05f * (bitRate - this.abr_enabled));
|
this.abr_count++;
|
}
|
}
|
}
|
bits.Pack(1, 1);
|
if (num2 != 0)
|
{
|
bits.Pack(0, 3);
|
}
|
else
|
{
|
bits.Pack(base.submodeID, 3);
|
}
|
if ((num2 != 0) || (base.submodes[base.submodeID] == null))
|
{
|
for (num = 0; num < base.frameSize; num++)
|
{
|
base.excBuf[base.excIdx + num] = this.swBuf[num] = 0f;
|
}
|
for (num = 0; num < base.lpcSize; num++)
|
{
|
this.mem_sw[num] = 0f;
|
}
|
base.first = 1;
|
Filters.Iir_mem2(base.excBuf, base.excIdx, base.interp_qlpc, base.high, 0, base.subframeSize, base.lpcSize, base.mem_sp);
|
base.filters.Fir_mem_up(base.x0d, Codebook_Constants.h0, base.y0, base.fullFrameSize, 0x40, base.g0_mem);
|
base.filters.Fir_mem_up(base.high, Codebook_Constants.h1, base.y1, base.fullFrameSize, 0x40, base.g1_mem);
|
for (num = 0; num < base.fullFrameSize; num++)
|
{
|
ins0[num] = 2f * (base.y0[num] - base.y1[num]);
|
}
|
if (num2 != 0)
|
{
|
return 0;
|
}
|
return 1;
|
}
|
base.submodes[base.submodeID].LsqQuant.Quant(this.lsp, base.qlsp, base.lpcSize, bits);
|
if (base.first != 0)
|
{
|
for (num = 0; num < base.lpcSize; num++)
|
{
|
this.old_lsp[num] = this.lsp[num];
|
}
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
base.old_qlsp[num] = base.qlsp[num];
|
num++;
|
}
|
}
|
float[] mem = new float[base.lpcSize];
|
float[] y = new float[base.subframeSize];
|
float[] numArray2 = new float[base.subframeSize];
|
for (int i = 0; i < base.nbSubframes; i++)
|
{
|
float num24;
|
float num25 = 0f;
|
float num26 = 0f;
|
int num22 = base.subframeSize * i;
|
int xs = num22;
|
int ys = base.excIdx + num22;
|
int num21 = num22;
|
int num20 = num22;
|
float num16 = (1f + i) / ((float)base.nbSubframes);
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
this.interp_lsp[num] = ((1f - num16) * this.old_lsp[num]) + (num16 * this.lsp[num]);
|
num++;
|
}
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
base.interp_qlsp[num] = ((1f - num16) * base.old_qlsp[num]) + (num16 * base.qlsp[num]);
|
num++;
|
}
|
Lsp.Enforce_margin(this.interp_lsp, base.lpcSize, 0.05f);
|
Lsp.Enforce_margin(base.interp_qlsp, base.lpcSize, 0.05f);
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
this.interp_lsp[num] = (float)Math.Cos((double)this.interp_lsp[num]);
|
num++;
|
}
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
base.interp_qlsp[num] = (float)Math.Cos((double)base.interp_qlsp[num]);
|
num++;
|
}
|
base.m_lsp.Lsp2lpc(this.interp_lsp, this.interp_lpc, base.lpcSize);
|
base.m_lsp.Lsp2lpc(base.interp_qlsp, base.interp_qlpc, base.lpcSize);
|
Filters.Bw_lpc(base.gamma1, this.interp_lpc, this.bw_lpc1, base.lpcSize);
|
Filters.Bw_lpc(base.gamma2, this.interp_lpc, this.bw_lpc2, base.lpcSize);
|
float num23 = num24 = 0f;
|
num16 = 1f;
|
base.pi_gain[i] = 0f;
|
num = 0;
|
while (num <= base.lpcSize)
|
{
|
num24 += num16 * base.interp_qlpc[num];
|
num16 = -num16;
|
base.pi_gain[i] += base.interp_qlpc[num];
|
num++;
|
}
|
num23 = piGain[i];
|
num23 = 1f / (Math.Abs(num23) + 0.01f);
|
num24 = 1f / (Math.Abs(num24) + 0.01f);
|
float num17 = Math.Abs((float)(0.01f + num24)) / (0.01f + Math.Abs(num23));
|
Filters.Fir_mem2(base.high, xs, base.interp_qlpc, base.excBuf, ys, base.subframeSize, base.lpcSize, this.mem_sp2);
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
num25 += base.excBuf[ys + num] * base.excBuf[ys + num];
|
num++;
|
}
|
if (base.submodes[base.submodeID].Innovation == null)
|
{
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
num26 += innov[num22 + num] * innov[num22 + num];
|
num++;
|
}
|
float num27 = num25 / (0.01f + num26);
|
num27 = (float)Math.Sqrt((double)num27);
|
num27 *= num17;
|
int data = (int)Math.Floor((double)(10.5 + (8.0 * Math.Log(num27 + 0.0001))));
|
if (data < 0)
|
{
|
data = 0;
|
}
|
if (data > 0x1f)
|
{
|
data = 0x1f;
|
}
|
bits.Pack(data, 5);
|
num27 = (float)(0.1 * Math.Exp(((double)data) / 9.4));
|
num27 /= num17;
|
}
|
else
|
{
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
num26 += exc[num22 + num] * exc[num22 + num];
|
num++;
|
}
|
float num29 = (float)((Math.Sqrt((double)(1f + num25)) * num17) / Math.Sqrt((double)((1f + num26) * base.subframeSize)));
|
int num32 = (int)Math.Floor((double)(0.5 + (3.7 * (Math.Log((double)num29) + 2.0))));
|
if (num32 < 0)
|
{
|
num32 = 0;
|
}
|
if (num32 > 15)
|
{
|
num32 = 15;
|
}
|
bits.Pack(num32, 4);
|
num29 = (float)Math.Exp((0.27027027027027023 * num32) - 2.0);
|
float num30 = (num29 * ((float)Math.Sqrt((double)(1f + num26)))) / num17;
|
float num31 = 1f / num30;
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
base.excBuf[ys + num] = 0f;
|
num++;
|
}
|
base.excBuf[ys] = 1f;
|
Filters.Syn_percep_zero(base.excBuf, ys, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, y, base.subframeSize, base.lpcSize);
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
base.excBuf[ys + num] = 0f;
|
num++;
|
}
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
mem[num] = base.mem_sp[num];
|
num++;
|
}
|
Filters.Iir_mem2(base.excBuf, ys, base.interp_qlpc, base.excBuf, ys, base.subframeSize, base.lpcSize, mem);
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
mem[num] = this.mem_sw[num];
|
num++;
|
}
|
Filters.Filter_mem2(base.excBuf, ys, this.bw_lpc1, this.bw_lpc2, this.res, num21, base.subframeSize, base.lpcSize, mem, 0);
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
mem[num] = this.mem_sw[num];
|
num++;
|
}
|
Filters.Filter_mem2(base.high, xs, this.bw_lpc1, this.bw_lpc2, this.swBuf, num20, base.subframeSize, base.lpcSize, mem, 0);
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
this.target[num] = this.swBuf[num20 + num] - this.res[num21 + num];
|
num++;
|
}
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
base.excBuf[ys + num] = 0f;
|
num++;
|
}
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
this.target[num] *= num31;
|
num++;
|
}
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
numArray2[num] = 0f;
|
num++;
|
}
|
base.submodes[base.submodeID].Innovation.Quantify(this.target, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, base.lpcSize, base.subframeSize, numArray2, 0, y, bits, (this.complexity + 1) >> 1);
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
base.excBuf[ys + num] += numArray2[num] * num30;
|
num++;
|
}
|
if (base.submodes[base.submodeID].DoubleCodebook != 0)
|
{
|
float[] numArray7 = new float[base.subframeSize];
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
numArray7[num] = 0f;
|
num++;
|
}
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
this.target[num] *= 2.5f;
|
num++;
|
}
|
base.submodes[base.submodeID].Innovation.Quantify(this.target, base.interp_qlpc, this.bw_lpc1, this.bw_lpc2, base.lpcSize, base.subframeSize, numArray7, 0, y, bits, (this.complexity + 1) >> 1);
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
numArray7[num] *= (float)(num30 * 0.4);
|
num++;
|
}
|
num = 0;
|
while (num < base.subframeSize)
|
{
|
base.excBuf[ys + num] += numArray7[num];
|
num++;
|
}
|
}
|
}
|
num = 0;
|
while (num < base.lpcSize)
|
{
|
mem[num] = base.mem_sp[num];
|
num++;
|
}
|
Filters.Iir_mem2(base.excBuf, ys, base.interp_qlpc, base.high, xs, base.subframeSize, base.lpcSize, base.mem_sp);
|
Filters.Filter_mem2(base.high, xs, this.bw_lpc1, this.bw_lpc2, this.swBuf, num20, base.subframeSize, base.lpcSize, this.mem_sw, 0);
|
}
|
base.filters.Fir_mem_up(base.x0d, Codebook_Constants.h0, base.y0, base.fullFrameSize, 0x40, base.g0_mem);
|
base.filters.Fir_mem_up(base.high, Codebook_Constants.h1, base.y1, base.fullFrameSize, 0x40, base.g1_mem);
|
for (num = 0; num < base.fullFrameSize; num++)
|
{
|
ins0[num] = 2f * (base.y0[num] - base.y1[num]);
|
}
|
for (num = 0; num < base.lpcSize; num++)
|
{
|
this.old_lsp[num] = this.lsp[num];
|
}
|
for (num = 0; num < base.lpcSize; num++)
|
{
|
base.old_qlsp[num] = base.qlsp[num];
|
}
|
base.first = 0;
|
return 1;
|
}
|
|
protected override void Init(int frameSize, int subframeSize, int lpcSize, int bufSize, float foldingGain)
|
{
|
base.Init(frameSize, subframeSize, lpcSize, bufSize, foldingGain);
|
this.complexity = 3;
|
this.vbr_enabled = 0;
|
this.vad_enabled = 0;
|
this.abr_enabled = 0;
|
this.vbr_quality = 8f;
|
this.submodeSelect = base.submodeID;
|
this.x1d = new float[frameSize];
|
this.h0_mem = new float[0x40];
|
this.buf = new float[base.windowSize];
|
this.swBuf = new float[frameSize];
|
this.res = new float[frameSize];
|
this.target = new float[subframeSize];
|
this.window = Misc.Window(base.windowSize, subframeSize);
|
this.lagWindow = Misc.LagWindow(lpcSize, base.lag_factor);
|
this.rc = new float[lpcSize];
|
this.autocorr = new float[lpcSize + 1];
|
this.lsp = new float[lpcSize];
|
this.old_lsp = new float[lpcSize];
|
this.interp_lsp = new float[lpcSize];
|
this.interp_lpc = new float[lpcSize + 1];
|
this.bw_lpc1 = new float[lpcSize + 1];
|
this.bw_lpc2 = new float[lpcSize + 1];
|
this.mem_sp2 = new float[lpcSize];
|
this.mem_sw = new float[lpcSize];
|
this.abr_count = 0f;
|
}
|
|
private void Uwbinit()
|
{
|
this.lowenc = new SbEncoder(false);
|
this.Init(320, 80, 8, 0x500, 0.7f);
|
this.uwb = true;
|
this.nb_modes = 2;
|
this.sampling_rate = 0x7d00;
|
}
|
|
private void Wbinit()
|
{
|
this.lowenc = new NbEncoder();
|
this.Init(160, 40, 8, 640, 0.9f);
|
this.uwb = false;
|
this.nb_modes = 5;
|
this.sampling_rate = 0x3e80;
|
}
|
|
public virtual int Abr {
|
get { return this.abr_enabled; }
|
set {
|
this.lowenc.Vbr = true;
|
this.abr_enabled = (value != 0) ? 1 : 0;
|
this.vbr_enabled = 1;
|
int num = 10;
|
int num3 = value;
|
while (num >= 0)
|
{
|
this.Quality = num;
|
if (this.BitRate <= num3)
|
{
|
break;
|
}
|
num--;
|
}
|
float num4 = num;
|
if (num4 < 0f)
|
{
|
num4 = 0f;
|
}
|
this.VbrQuality = num4;
|
this.abr_count = 0f;
|
this.abr_drift = 0f;
|
this.abr_drift2 = 0f;
|
}
|
}
|
|
public virtual int BitRate {
|
get {
|
if (base.submodes[base.submodeID] != null)
|
{
|
return (this.lowenc.BitRate + ((this.sampling_rate * base.submodes[base.submodeID].BitsPerFrame) / base.frameSize));
|
}
|
return (this.lowenc.BitRate + ((this.sampling_rate * 4) / base.frameSize));
|
}
|
set {
|
for (int i = 10; i >= 0; i--)
|
{
|
this.Quality = i;
|
if (this.BitRate <= value)
|
{
|
return;
|
}
|
}
|
}
|
}
|
|
public virtual int Complexity {
|
get { return this.complexity; }
|
set {
|
if (value < 0)
|
{
|
value = 0;
|
}
|
if (value > 10)
|
{
|
value = 10;
|
}
|
this.complexity = value;
|
}
|
}
|
|
public bool Dtx {
|
get { return (base.dtx_enabled == 1); }
|
set {
|
base.dtx_enabled = value ? 1 : 0;
|
}
|
}
|
|
public virtual int EncodedFrameSize {
|
get {
|
int num = SbCodec.SB_FRAME_SIZE[base.submodeID];
|
return (num + this.lowenc.EncodedFrameSize);
|
}
|
}
|
|
public virtual int LookAhead { get { return (((2 * this.lowenc.LookAhead) + 0x40) - 1); } }
|
|
public virtual int Mode {
|
get { return base.submodeID; }
|
set {
|
if (value < 0)
|
{
|
value = 0;
|
}
|
base.submodeID = this.submodeSelect = value;
|
}
|
}
|
|
public virtual int Quality {
|
set {
|
if (value < 0)
|
{
|
value = 0;
|
}
|
if (value > 10)
|
{
|
value = 10;
|
}
|
if (this.uwb)
|
{
|
this.lowenc.Quality = value;
|
this.Mode = UWB_QUALITY_MAP[value];
|
}
|
else
|
{
|
this.lowenc.Mode = NB_QUALITY_MAP[value];
|
this.Mode = WB_QUALITY_MAP[value];
|
}
|
}
|
}
|
|
public virtual float RelativeQuality { get { return this.relative_quality; } }
|
|
public virtual int SamplingRate {
|
get { return this.sampling_rate; }
|
set {
|
this.sampling_rate = value;
|
this.lowenc.SamplingRate = value;
|
}
|
}
|
|
public virtual bool Vad {
|
get { return (this.vad_enabled != 0); }
|
set {
|
this.vad_enabled = value ? 1 : 0;
|
}
|
}
|
|
public virtual bool Vbr {
|
get { return (this.vbr_enabled != 0); }
|
set {
|
this.vbr_enabled = value ? 1 : 0;
|
this.lowenc.Vbr = value;
|
}
|
}
|
|
public virtual float VbrQuality {
|
get { return this.vbr_quality; }
|
set {
|
this.vbr_quality = value;
|
float num = value + 0.6f;
|
if (num > 10f)
|
{
|
num = 10f;
|
}
|
this.lowenc.VbrQuality = num;
|
int num2 = (int)Math.Floor((double)(0.5 + value));
|
if (num2 > 10)
|
{
|
num2 = 10;
|
}
|
this.Quality = num2;
|
}
|
}
|
}
|
}
|
