@core-workspace/infoflow-openclaw-plugin 2026.3.9 → 2026.3.27-beta.0

package/src/utils/audio/g722/decoder.ts

@@ -0,0 +1,919 @@
+/**
+ * G.722.1 / G.722.1 Annex C Decoder Implementation
+ * 基于 ITU-T G.722.1 Annex C 浮点源码移植到 TypeScript
+ */
+
+import {
+  G722Type,
+  G722Decoder,
+  DecInfo,
+  MAX_DCT_SIZE,
+  MAX_FRAME_SIZE,
+  FRAME_SIZE,
+  MAX_NUM_REGIONS,
+  NUM_REGIONS,
+  NUM_RATE_CONTROL_BITS,
+  NUM_RATE_CONTROL_POSSIBILITIES,
+  MAX_NUM_RATE_CONTROL_BITS,
+  MAX_NUM_RATE_CONTROL_POSSIBILITIES,
+  INTEROP_RMLT_SCALE_FACTOR_7,
+  INTEROP_RMLT_SCALE_FACTOR_14,
+  ESF_ADJUSTMENT_TO_RMS_INDEX,
+  NUM_CATEGORIES,
+  REGION_POWER_TABLE_NUM_NEGATIVES,
+  MAX_VECTOR_DIMENSION
+} from './defs.js';
+
+import {
+  g722Window7kHz,
+  g722Window14kHz,
+  regionStandardDeviationTable,
+  vectorDimension,
+  numberOfVectors,
+  maxBin,
+  maxBinPlusOneInverse,
+  expectedBitsTable,
+  regionSize,
+  mltQuantCentroid
+} from './tables.js';
+
+import { differentialRegionPowerDecoderTree, tableOfDecoderTables } from './huff_tables.js';
+import { dctCore320, dctCore640, cosMsinTables } from './dct_tables.js';
+
+/**
+ * 打开/创建解码器
+ */
+export function g722DecOpen(codecType: G722Type): G722Decoder | null {
+  const decoder: G722Decoder = {
+    frameCnt: 0,
+    bitRate: 0,
+    frameSize: 0,
+    bandwidth: 0,
+    numberOfRegions: 0,
+    numberOfBitsPerFrame: 0,
+    numberOfWords16PerFrame: 0,
+    rmltScaleFactor: 0,
+    window: new Float32Array(0),
+    oldSamples: new Float32Array(MAX_DCT_SIZE >> 1),
+    oldDecoderMltCoefs: new Float32Array(MAX_DCT_SIZE),
+    decoderMltCoefs: new Float32Array(MAX_DCT_SIZE),
+    floatOutSamples: new Float32Array(MAX_DCT_SIZE),
+    numRateControlBits: 0,
+    numRateControlPossibilities: 0,
+    decInfo: {
+      numberOfBitsLeft: 0,
+      nextBit: 0,
+      codeWord: 0,
+      codeBitCount: 0,
+      codeWordIndex: 0,
+      codeWords: new Int16Array(0)
+    },
+    random: { b0: 1, b1: 1, b2: 1, b3: 1 },
+    bufferA: new Float32Array(MAX_DCT_SIZE),
+    bufferB: new Float32Array(MAX_DCT_SIZE),
+    maxRateCategories: new Int32Array(MAX_NUM_REGIONS),
+    minRateCategories: new Int32Array(MAX_NUM_REGIONS),
+    tempCategoryBalances: new Int32Array(2 * MAX_NUM_RATE_CONTROL_POSSIBILITIES)
+  };
+
+  // 根据编解码器类型设置参数
+  switch (codecType) {
+    case G722Type.G722_1C_24:
+      decoder.bandwidth = 14000;
+      decoder.bitRate = 24000;
+      break;
+    case G722Type.G722_1C_32:
+      decoder.bandwidth = 14000;
+      decoder.bitRate = 32000;
+      break;
+    case G722Type.G722_1C_48:
+      decoder.bandwidth = 14000;
+      decoder.bitRate = 48000;
+      break;
+    case G722Type.G722_1_16:
+      decoder.bandwidth = 7000;
+      decoder.bitRate = 16000;
+      break;
+    case G722Type.G722_1_24:
+      decoder.bandwidth = 7000;
+      decoder.bitRate = 24000;
+      break;
+    case G722Type.G722_1_32:
+      decoder.bandwidth = 7000;
+      decoder.bitRate = 32000;
+      break;
+    default:
+      console.error('Unknown G722 decoder type!');
+      return null;
+  }
+
+  // 设置帧大小和区域数量
+  if (decoder.bandwidth === 7000) {
+    decoder.frameSize = FRAME_SIZE;
+    decoder.numberOfRegions = NUM_REGIONS;
+    decoder.numRateControlBits = NUM_RATE_CONTROL_BITS;
+    decoder.numRateControlPossibilities = NUM_RATE_CONTROL_POSSIBILITIES;
+    decoder.rmltScaleFactor = Math.floor(INTEROP_RMLT_SCALE_FACTOR_7);
+    decoder.window = g722Window7kHz;
+  } else {
+    decoder.frameSize = MAX_FRAME_SIZE;
+    decoder.numberOfRegions = MAX_NUM_REGIONS;
+    decoder.numRateControlBits = MAX_NUM_RATE_CONTROL_BITS;
+    decoder.numRateControlPossibilities = MAX_NUM_RATE_CONTROL_POSSIBILITIES;
+    decoder.rmltScaleFactor = Math.floor(INTEROP_RMLT_SCALE_FACTOR_14);
+    decoder.window = g722Window14kHz;
+  }
+
+  decoder.numberOfBitsPerFrame = decoder.bitRate / 50;
+  decoder.numberOfWords16PerFrame = (decoder.bitRate / 50) >> 4;
+
+  return decoder;
+}
+
+/**
+ * 获取下一个比特
+ */
+function getNextBit(decInfo: DecInfo): number {
+  if (decInfo.codeBitCount === 0) {
+    decInfo.codeWord = decInfo.codeWords[decInfo.codeWordIndex++];
+    decInfo.codeBitCount = 16;
+  }
+  decInfo.codeBitCount--;
+  decInfo.nextBit = (decInfo.codeWord >> decInfo.codeBitCount) & 1;
+  return decInfo.nextBit;
+}
+
+/**
+ * 解码功率包络
+ */
+function decodeEnvelope(
+  decInfo: DecInfo,
+  numberOfRegions: number,
+  decoderRegionStandardDeviation: Float32Array,
+  absoluteRegionPowerIndex: Int32Array
+): void {
+  const differentialRegionPowerIndex = new Int32Array(MAX_NUM_REGIONS);
+
+  // 恢复第一个区域的功率索引
+  let index = 0;
+  for (let i = 0; i < 5; i++) {
+    getNextBit(decInfo);
+    index <<= 1;
+    index += decInfo.nextBit;
+  }
+
+  differentialRegionPowerIndex[0] = index - ESF_ADJUSTMENT_TO_RMS_INDEX;
+  decInfo.numberOfBitsLeft -= 5;
+
+  // 恢复后续区域的功率索引
+  for (let region = 1; region < numberOfRegions; region++) {
+    index = 0;
+    let bitCount = 0;
+    do {
+      // 检查索引有效性
+      if (index < 0 || index >= differentialRegionPowerDecoderTree[region].length) {
+        index = -12; // 默认值
+        break;
+      }
+
+      getNextBit(decInfo);
+      if (decInfo.nextBit === 0) {
+        index = differentialRegionPowerDecoderTree[region][index][0];
+      } else {
+        index = differentialRegionPowerDecoderTree[region][index][1];
+      }
+      decInfo.numberOfBitsLeft--;
+      bitCount++;
+      // 防止无限循环
+      if (bitCount > 20) {
+        index = -12; // 默认值
+        break;
+      }
+    } while (index > 0);
+    differentialRegionPowerIndex[region] = -index;
+  }
+
+  // 重建绝对功率索引
+  absoluteRegionPowerIndex[0] = differentialRegionPowerIndex[0];
+  for (let region = 1; region < numberOfRegions; region++) {
+    absoluteRegionPowerIndex[region] =
+      absoluteRegionPowerIndex[region - 1] +
+      differentialRegionPowerIndex[region] +
+      (-12); // DRP_DIFF_MIN
+  }
+
+  // 重建区域标准差
+  for (let region = 0; region < numberOfRegions; region++) {
+    const i = absoluteRegionPowerIndex[region] + REGION_POWER_TABLE_NUM_NEGATIVES;
+    if (i >= 0 && i < regionStandardDeviationTable.length) {
+      decoderRegionStandardDeviation[region] = regionStandardDeviationTable[i];
+    } else {
+      // 越界处理
+      decoderRegionStandardDeviation[region] = 0;
+    }
+  }
+}
+
+/**
+ * 速率调整类别
+ */
+function rateAdjustCategories(
+  rateControl: number,
+  decoderPowerCategories: Int32Array,
+  decoderCategoryBalances: Int32Array
+): void {
+  let i = 0;
+  while (rateControl > 0) {
+    const region = decoderCategoryBalances[i++];
+    decoderPowerCategories[region]++;
+    rateControl--;
+  }
+}
+
+/**
+ * 分类函数
+ */
+function categorize(
+  numberOfRegions: number,
+  numRateControlPossibilities: number,
+  numberOfAvailableBits: number,
+  rmsIndex: Int32Array,
+  powerCategories: Int32Array,
+  categoryBalances: Int32Array,
+  maxRateCategories: Int32Array,
+  minRateCategories: Int32Array,
+  tempCategoryBalances: Int32Array
+): void {
+  // 在较高比特率下进行补偿
+  if (numberOfRegions === NUM_REGIONS && numberOfAvailableBits > FRAME_SIZE) {
+    numberOfAvailableBits = FRAME_SIZE + (((numberOfAvailableBits - FRAME_SIZE) * 5) >> 3);
+  } else if (numberOfRegions === MAX_NUM_REGIONS && numberOfAvailableBits > MAX_FRAME_SIZE) {
+    numberOfAvailableBits = MAX_FRAME_SIZE + (((numberOfAvailableBits - MAX_FRAME_SIZE) * 5) >> 3);
+  }
+
+  let offset = -32;
+  let delta = 32;
+
+  // 二分搜索找到最佳偏移
+  do {
+    const testOffset = offset + delta;
+    let expectedNumberOfCodeBits = 0;
+
+    for (let region = 0; region < numberOfRegions; region += 2) {
+      let j0 = (testOffset - rmsIndex[region]) >> 1;
+      let j1 = (testOffset - rmsIndex[region + 1]) >> 1;
+
+      j0 = Math.max(0, Math.min(j0, NUM_CATEGORIES - 1));
+      j1 = Math.max(0, Math.min(j1, NUM_CATEGORIES - 1));
+
+      powerCategories[region] = j0;
+      powerCategories[region + 1] = j1;
+      expectedNumberOfCodeBits += expectedBitsTable[j0] + expectedBitsTable[j1];
+    }
+
+    if (expectedNumberOfCodeBits >= numberOfAvailableBits - 32) {
+      offset = testOffset;
+    }
+
+    delta >>= 1;
+  } while (delta > 0);
+
+  // 使用最终偏移重新计算类别
+  let expectedNumberOfCodeBits = 0;
+  for (let region = 0; region < numberOfRegions; region += 2) {
+    let j0 = (offset - rmsIndex[region]) >> 1;
+    let j1 = (offset - rmsIndex[region + 1]) >> 1;
+
+    j0 = Math.max(0, Math.min(j0, NUM_CATEGORIES - 1));
+    j1 = Math.max(0, Math.min(j1, NUM_CATEGORIES - 1));
+
+    powerCategories[region] = j0;
+    powerCategories[region + 1] = j1;
+    expectedNumberOfCodeBits += expectedBitsTable[j0] + expectedBitsTable[j1];
+  }
+
+  // 初始化最大/最小速率类别
+  for (let region = 0; region < numberOfRegions; region++) {
+    maxRateCategories[region] = powerCategories[region];
+    minRateCategories[region] = powerCategories[region];
+  }
+
+  let max = expectedNumberOfCodeBits;
+  let min = expectedNumberOfCodeBits;
+  let maxRatePointer = numRateControlPossibilities;
+  let minRatePointer = numRateControlPossibilities;
+
+  // 计算类别平衡
+  for (let j = 0; j < numRateControlPossibilities - 1; j++) {
+    if (max + min <= numberOfAvailableBits * 2) {
+      let rawMin = 99;
+      let rawMinIndex = 0;
+
+      for (let region = 0; region < numberOfRegions; region++) {
+        if (maxRateCategories[region] > 0) {
+          const itemp0 = offset - rmsIndex[region] - (maxRateCategories[region] << 1);
+          if (itemp0 < rawMin) {
+            rawMin = itemp0;
+            rawMinIndex = region;
+          }
+        }
+      }
+
+      maxRatePointer--;
+      tempCategoryBalances[maxRatePointer] = rawMinIndex;
+
+      max -= expectedBitsTable[maxRateCategories[rawMinIndex]];
+      maxRateCategories[rawMinIndex]--;
+      max += expectedBitsTable[maxRateCategories[rawMinIndex]];
+    } else {
+      let rawMax = -99;
+      let rawMaxIndex = 0;
+
+      for (let region = numberOfRegions - 1; region >= 0; region--) {
+        if (minRateCategories[region] < NUM_CATEGORIES - 1) {
+          const itemp0 = offset - rmsIndex[region] - (minRateCategories[region] << 1);
+          if (itemp0 > rawMax) {
+            rawMax = itemp0;
+            rawMaxIndex = region;
+          }
+        }
+      }
+
+      tempCategoryBalances[minRatePointer] = rawMaxIndex;
+      minRatePointer++;
+
+      min -= expectedBitsTable[minRateCategories[rawMaxIndex]];
+      minRateCategories[rawMaxIndex]++;
+      min += expectedBitsTable[minRateCategories[rawMaxIndex]];
+    }
+  }
+
+  for (let region = 0; region < numberOfRegions; region++) {
+    powerCategories[region] = maxRateCategories[region];
+  }
+
+  for (let j = 0; j < numRateControlPossibilities - 1; j++) {
+    categoryBalances[j] = tempCategoryBalances[maxRatePointer++];
+  }
+}
+
+/**
+ * 索引转数组
+ */
+function indexToArray(index: number, array: Int32Array, category: number): number {
+  let numberOfNonZero = 0;
+  let p = index;
+  const maxBinPlusOne = maxBin[category] + 1;
+  const inverseOfMaxBinPlusOne = maxBinPlusOneInverse[category];
+
+  for (let j = vectorDimension[category] - 1; j >= 0; j--) {
+    const q = (p * inverseOfMaxBinPlusOne) >> 15;
+    array[j] = p - q * maxBinPlusOne;
+    p = q;
+    if (array[j] !== 0) {
+      numberOfNonZero++;
+    }
+  }
+
+  return numberOfNonZero;
+}
+
+/**
+ * 获取随机数
+ */
+function getRand(random: { b0: number; b1: number; b2: number; b3: number }): number {
+  let randomWord = random.b0 + random.b3;
+  if ((randomWord & 32768) !== 0) randomWord++;
+  random.b3 = random.b2;
+  random.b2 = random.b1;
+  random.b1 = random.b0;
+  random.b0 = randomWord;
+  return randomWord;
+}
+
+/**
+ * 解码向量量化的MLT索引
+ */
+function decodeVectorQuantizedMltIndices(
+  decoder: G722Decoder,
+  numberOfRegions: number,
+  decoderRegionStandardDeviation: Float32Array,
+  decoderPowerCategories: Int32Array,
+  decoderMltCoefs: Float32Array,
+  rmltScaleFactor: number
+): void {
+  const decInfo = decoder.decInfo;
+  const random = decoder.random;
+  const k = new Int32Array(MAX_VECTOR_DIMENSION);
+  let ranOutOfBitsFlag = 0;
+
+  for (let region = 0; region < numberOfRegions; region++) {
+    const category = decoderPowerCategories[region];
+    let decoderMltIndex = region * regionSize;
+    const standardDeviation = decoderRegionStandardDeviation[region];
+
+    if (category < NUM_CATEGORIES - 1) {
+      const decoderTablePtr = tableOfDecoderTables[category];
+
+      // 检查解码表是否存在
+      if (!decoderTablePtr || decoderTablePtr.length === 0) {
+        // 如果表不存在，直接使用噪声填充
+        const noifillpos = standardDeviation * 0.70711;
+        const noifillneg = -noifillpos;
+        let randomWord = getRand(random);
+        for (let j = 0; j < regionSize; j++) {
+          if (j % 16 === 0 && j > 0) randomWord = getRand(random);
+          const temp1 = (randomWord & 1) === 0 ? noifillneg : noifillpos;
+          decoderMltCoefs[decoderMltIndex++] = temp1 * rmltScaleFactor;
+          randomWord >>= 1;
+        }
+        continue;
+      }
+
+      const vecDim = vectorDimension[category];
+      const numVecs = numberOfVectors[category];
+
+      for (let n = 0; n < numVecs; n++) {
+        let index = 0;
+        let bitCount = 0;
+        const maxBits = 32; // 安全限制：防止无限循环
+        do {
+          if (decInfo.numberOfBitsLeft <= 0) {
+            ranOutOfBitsFlag = 1;
+            break;
+          }
+          if (bitCount++ >= maxBits) {
+            // 解码失败，跳过此区域
+            ranOutOfBitsFlag = 1;
+            break;
+          }
+
+          getNextBit(decInfo);
+          if (index >= decoderTablePtr.length) {
+            // 索引越界，解码错误
+            ranOutOfBitsFlag = 1;
+            break;
+          }
+          if (decInfo.nextBit === 0) {
+            index = decoderTablePtr[index][0];
+          } else {
+            index = decoderTablePtr[index][1];
+          }
+          decInfo.numberOfBitsLeft--;
+        } while (index > 0);
+
+        if (ranOutOfBitsFlag === 1) break;
+        index = -index;
+        const numSignBits = indexToArray(index, k, category);
+
+        if (decInfo.numberOfBitsLeft >= numSignBits) {
+          let signsIndex = 0;
+          if (numSignBits !== 0) {
+            for (let j = 0; j < numSignBits; j++) {
+              getNextBit(decInfo);
+              signsIndex <<= 1;
+              signsIndex += decInfo.nextBit;
+              decInfo.numberOfBitsLeft--;
+            }
+          }
+          let bit = 1 << (numSignBits - 1);
+
+          for (let j = 0; j < vecDim; j++) {
+            let decoderMltValue =
+              standardDeviation * mltQuantCentroid[category][k[j]] * rmltScaleFactor;
+
+            if (decoderMltValue !== 0) {
+              if ((signsIndex & bit) === 0) {
+                decoderMltValue *= -1;
+              }
+              bit >>= 1;
+            }
+
+            decoderMltCoefs[decoderMltIndex++] = decoderMltValue;
+          }
+        } else {
+          ranOutOfBitsFlag = 1;
+          break;
+        }
+      }
+
+      if (ranOutOfBitsFlag === 1) {
+        for (let j = region + 1; j < numberOfRegions; j++) {
+          decoderPowerCategories[j] = NUM_CATEGORIES - 1;
+        }
+        decoderMltIndex = region * regionSize;
+      }
+    }
+
+    // 噪声填充
+    if (category === NUM_CATEGORIES - 1) {
+      const noifillpos = standardDeviation * 0.70711;
+      const noifillneg = -noifillpos;
+
+      let randomWord = getRand(random);
+      for (let j = 0; j < 10; j++) {
+        const temp1 = (randomWord & 1) === 0 ? noifillneg : noifillpos;
+        decoderMltCoefs[decoderMltIndex++] = temp1 * rmltScaleFactor;
+        randomWord >>= 1;
+      }
+      randomWord = getRand(random);
+      for (let j = 0; j < 10; j++) {
+        const temp1 = (randomWord & 1) === 0 ? noifillneg : noifillpos;
+        decoderMltCoefs[decoderMltIndex++] = temp1 * rmltScaleFactor;
+        randomWord >>= 1;
+      }
+    }
+  }
+
+  if (ranOutOfBitsFlag) {
+    decInfo.numberOfBitsLeft = -1;
+  }
+}
+
+// 简单的暴力DCT Type IV实现（用于验证）
+function dctTypeIvSimple(input: Float32Array, output: Float32Array, dctLength: number): void {
+  // voipsdk的实现在dct_core矩阵中内置了 sqrt(2/N) 的缩放因子
+  const scale = Math.sqrt(2.0 / dctLength);
+  for (let k = 0; k < dctLength; k++) {
+    let sum = 0;
+    for (let n = 0; n < dctLength; n++) {
+      sum += input[n] * Math.cos(Math.PI * (n + 0.5) * (k + 0.5) / dctLength);
+    }
+    output[k] = sum * scale;
+  }
+}
+
+/**
+ * DCT Type IV变换 - 使用简单暴力实现（调试用）
+ */
+function dctTypeIv(
+  input: Float32Array,
+  output: Float32Array,
+  dctLength: number,
+  bufferA: Float32Array,
+  bufferB: Float32Array
+): void {
+  // 临时使用简单实现来验证
+  dctTypeIvSimple(input, output, dctLength);
+}
+
+/**
+ * DCT Type IV变换 - 快速实现（原始）
+ */
+function dctTypeIvFast(
+  input: Float32Array,
+  output: Float32Array,
+  dctLength: number,
+  bufferA: Float32Array,
+  bufferB: Float32Array
+): void {
+  const maxSetCountLog = dctLength === 640 ? 5 : 4;
+  const dctCorePtr = dctLength === 640 ? dctCore640 : dctCore320;
+
+  let inBuffer = input;
+  let outBuffer = bufferA;
+  let nextOutBuffer = bufferB;
+
+  // Sum/difference butterflies
+  for (let setCountLog = 0; setCountLog <= maxSetCountLog; setCountLog++) {
+    const setSpan = dctLength >> setCountLog;
+    const spanDiv20 = 1 << (maxSetCountLog - setCountLog);
+    const setCount = 1 << setCountLog;
+    let inPtrIndex = 0;
+    let nextOutBaseIndex = 0;
+
+    for (let setsLeft = setCount; setsLeft > 0; setsLeft--) {
+      let outPtrLowIndex = nextOutBaseIndex;
+      nextOutBaseIndex += setSpan;
+      let outPtrHighIndex = nextOutBaseIndex;
+
+      for (let i = 0; i < spanDiv20; i++) {
+        outPtrHighIndex -= 10;
+
+        for (let k = 0; k < 10; k++) {
+          const inValLow = inBuffer[inPtrIndex + k * 2];
+          const inValHigh = inBuffer[inPtrIndex + k * 2 + 1];
+          outBuffer[outPtrLowIndex + k] = inValLow + inValHigh;
+          outBuffer[outPtrHighIndex + 9 - k] = inValLow - inValHigh;
+        }
+
+        inPtrIndex += 20;
+        outPtrLowIndex += 10;
+      }
+    }
+
+    inBuffer = outBuffer;
+    outBuffer = nextOutBuffer;
+    nextOutBuffer = inBuffer;
+  }
+
+  // 10点变换
+  let fptr0Index = 0;
+  let bufferSwapIndex = 0;
+  const decadesCount = 2 << maxSetCountLog;
+
+  for (let decadesLeft = decadesCount; decadesLeft > 0; decadesLeft--) {
+    for (let row = 0; row < 10; row++) {
+      let sum = 0;
+      for (let col = 0; col < 10; col++) {
+        sum += inBuffer[fptr0Index + col] * dctCorePtr[row * 10 + col];
+      }
+      outBuffer[bufferSwapIndex + row] = sum;
+    }
+
+    fptr0Index += 10;
+    bufferSwapIndex += 10;
+  }
+
+  // 交换缓冲区指针
+  inBuffer = outBuffer;
+  outBuffer = nextOutBuffer;
+  nextOutBuffer = inBuffer;
+
+  // Rotation butterflies
+  let tablePtrIndex = 0;
+
+  for (let setCountLog = maxSetCountLog; setCountLog >= 0; setCountLog--) {
+    const setSpan = dctLength >> setCountLog;
+    const spanDiv20 = 1 << (maxSetCountLog - setCountLog);
+    const setCount = 1 << setCountLog;
+    let nextInBaseIndex = 0;
+    let nextOutBaseIndex = 0;
+
+    const cosMsinPtr = cosMsinTables[tablePtrIndex];
+
+    for (let setsLeft = setCount; setsLeft > 0; setsLeft--) {
+      let inPtrLowIndex = nextInBaseIndex;
+      let inPtrHighIndex = inPtrLowIndex + (setSpan >> 1);
+      nextInBaseIndex += setSpan;
+      let outPtrLowIndex = nextOutBaseIndex;
+      nextOutBaseIndex += setSpan;
+      let outPtrHighIndex = nextOutBaseIndex;
+      let cosMsinIndex = 0;
+
+      for (let i = 0; i < spanDiv20; i++) {
+        outPtrHighIndex -= 10;
+
+        for (let k = 0; k < 10; k++) {
+          const cosVal = cosMsinPtr[cosMsinIndex + k].cosine;
+          const msinVal = cosMsinPtr[cosMsinIndex + k].minusSine;
+          const inLow = inBuffer[inPtrLowIndex + k];
+          const inHigh = inBuffer[inPtrHighIndex + k];
+
+          if (k % 2 === 0) {
+            // Even index: cos*low - msin*high, msin*low + cos*high
+            outBuffer[outPtrLowIndex + k] = cosVal * inLow - msinVal * inHigh;
+            outBuffer[outPtrHighIndex + 9 - k] = msinVal * inLow + cosVal * inHigh;
+          } else {
+            // Odd index: cos*low + msin*high, msin*low - cos*high
+            outBuffer[outPtrLowIndex + k] = cosVal * inLow + msinVal * inHigh;
+            outBuffer[outPtrHighIndex + 9 - k] = msinVal * inLow - cosVal * inHigh;
+          }
+        }
+
+        cosMsinIndex += 10;
+        inPtrLowIndex += 10;
+        inPtrHighIndex += 10;
+        outPtrLowIndex += 10;
+      }
+    }
+
+    // 交换缓冲区
+    const tempBuffer = inBuffer;
+    inBuffer = outBuffer;
+    outBuffer = nextOutBuffer;
+    nextOutBuffer = tempBuffer;
+
+    tablePtrIndex++;
+  }
+
+  // 复制最终结果到输出
+  for (let i = 0; i < dctLength; i++) {
+    output[i] = inBuffer[i];
+  }
+}
+
+/**
+ * RMLT系数转换为采样
+ */
+function rmltCoefsToSamples(decoder: G722Decoder, coefs: Float32Array, outSamples: Float32Array): void {
+  const newSamples = new Float32Array(MAX_DCT_SIZE);
+  const dctSize = decoder.frameSize;
+  const halfDctSize = dctSize >> 1;
+  const pWindow = decoder.window;
+  const oldSamples = decoder.oldSamples;
+
+  // 执行逆DCT
+  dctTypeIv(coefs, newSamples, dctSize, decoder.bufferA, decoder.bufferB);
+
+  // 加窗和重叠相加
+  let outPtrIndex = 0;
+  let winNewIndex = 0;
+  let winOldIndex = halfDctSize - 4;
+  let oldPtrIndex = 0;
+  let newPtrIndex = halfDctSize - 4;
+  let oldPtr1Index = halfDctSize - 4;
+  let newPtr1Index = 0;
+
+  for (let valsLeft = halfDctSize; valsLeft > 0; valsLeft -= 4) {
+    const a0 = pWindow[winNewIndex] * newSamples[newPtrIndex + 3];
+    const a1 = pWindow[winNewIndex + 1] * newSamples[newPtrIndex + 2];
+    const a2 = pWindow[winNewIndex + 2] * newSamples[newPtrIndex + 1];
+    const a3 = pWindow[winNewIndex + 3] * newSamples[newPtrIndex];
+
+    const a4 = pWindow[winNewIndex + halfDctSize] * newSamples[newPtr1Index];
+    const a5 = pWindow[winNewIndex + halfDctSize + 1] * newSamples[newPtr1Index + 1];
+    const a6 = pWindow[winNewIndex + halfDctSize + 2] * newSamples[newPtr1Index + 2];
+    const a7 = pWindow[winNewIndex + halfDctSize + 3] * newSamples[newPtr1Index + 3];
+
+    const b0 = pWindow[winOldIndex + halfDctSize + 3] * oldSamples[oldPtrIndex];
+    const b1 = pWindow[winOldIndex + halfDctSize + 2] * oldSamples[oldPtrIndex + 1];
+    const b2 = pWindow[winOldIndex + halfDctSize + 1] * oldSamples[oldPtrIndex + 2];
+    const b3 = pWindow[winOldIndex + halfDctSize] * oldSamples[oldPtrIndex + 3];
+
+    const b4 = pWindow[winOldIndex + 3] * oldSamples[oldPtr1Index + 3];
+    const b5 = pWindow[winOldIndex + 2] * oldSamples[oldPtr1Index + 2];
+    const b6 = pWindow[winOldIndex + 1] * oldSamples[oldPtr1Index + 1];
+    const b7 = pWindow[winOldIndex] * oldSamples[oldPtr1Index];
+
+    outSamples[outPtrIndex] = a0 + b0;
+    outSamples[outPtrIndex + 1] = a1 + b1;
+    outSamples[outPtrIndex + 2] = a2 + b2;
+    outSamples[outPtrIndex + 3] = a3 + b3;
+
+    outSamples[outPtrIndex + halfDctSize] = a4 - b4;
+    outSamples[outPtrIndex + halfDctSize + 1] = a5 - b5;
+    outSamples[outPtrIndex + halfDctSize + 2] = a6 - b6;
+    outSamples[outPtrIndex + halfDctSize + 3] = a7 - b7;
+
+    outPtrIndex += 4;
+    winNewIndex += 4;
+    winOldIndex -= 4;
+    oldPtrIndex += 4;
+    newPtr1Index += 4;
+    newPtrIndex -= 4;
+    oldPtr1Index -= 4;
+  }
+
+  // 保存当前帧的后半部分供下一帧使用
+  oldSamples.set(newSamples.subarray(halfDctSize, dctSize), 0);
+}
+
+/**
+ * 主解码函数
+ */
+function decoder(
+  hDecoder: G722Decoder,
+  bitstream: Int16Array,
+  decoderMltCoefs: Float32Array,
+  frameErrorFlag: number
+): void {
+  const absoluteRegionPowerIndex = new Int32Array(MAX_NUM_REGIONS);
+  const decoderPowerCategories = new Int32Array(MAX_NUM_REGIONS);
+  const decoderCategoryBalances = new Int32Array(MAX_NUM_RATE_CONTROL_POSSIBILITIES - 1);
+  const decoderRegionStandardDeviation = new Float32Array(MAX_NUM_REGIONS);
+
+  const numberOfRegions = hDecoder.numberOfRegions;
+  const numberOfBitsPerFrame = hDecoder.numberOfBitsPerFrame;
+  const numberOfCoefs = hDecoder.frameSize;
+  const rmltScaleFactor = hDecoder.rmltScaleFactor;
+  const numRateControlBits = hDecoder.numRateControlBits;
+  const numRateControlPossibilities = hDecoder.numRateControlPossibilities;
+
+  const numberOfValidCoefs = numberOfRegions * regionSize;
+
+  if (frameErrorFlag === 0) {
+    const decInfo = hDecoder.decInfo;
+
+    decInfo.numberOfBitsLeft = numberOfBitsPerFrame;
+    decInfo.codeWords = bitstream;
+    decInfo.codeWordIndex = 0;
+    decInfo.codeBitCount = 0;
+
+    decodeEnvelope(decInfo, numberOfRegions, decoderRegionStandardDeviation, absoluteRegionPowerIndex);
+
+    let rateControl = 0;
+    for (let i = 0; i < numRateControlBits; i++) {
+      getNextBit(decInfo);
+      rateControl <<= 1;
+      rateControl += decInfo.nextBit;
+    }
+    decInfo.numberOfBitsLeft -= numRateControlBits;
+
+    categorize(
+      numberOfRegions,
+      numRateControlPossibilities,
+      decInfo.numberOfBitsLeft,
+      absoluteRegionPowerIndex,
+      decoderPowerCategories,
+      decoderCategoryBalances,
+      hDecoder.maxRateCategories,
+      hDecoder.minRateCategories,
+      hDecoder.tempCategoryBalances
+    );
+
+    rateAdjustCategories(rateControl, decoderPowerCategories, decoderCategoryBalances);
+
+    decodeVectorQuantizedMltIndices(
+      hDecoder,
+      numberOfRegions,
+      decoderRegionStandardDeviation,
+      decoderPowerCategories,
+      decoderMltCoefs,
+      rmltScaleFactor
+    );
+
+    // 检测比特流错误
+    if (decInfo.numberOfBitsLeft > 0) {
+      for (let i = 0; i < decInfo.numberOfBitsLeft; i++) {
+        getNextBit(decInfo);
+        if (decInfo.nextBit === 0) {
+          frameErrorFlag = 1;
+        }
+      }
+    } else {
+      if (rateControl < numRateControlPossibilities - 1) {
+        if (decInfo.numberOfBitsLeft < 0) {
+          frameErrorFlag |= 2;
+        }
+      }
+    }
+
+    // 验证功率索引
+    for (let region = 0; region < numberOfRegions; region++) {
+      if (
+        absoluteRegionPowerIndex[region] + ESF_ADJUSTMENT_TO_RMS_INDEX > 31 ||
+        absoluteRegionPowerIndex[region] + ESF_ADJUSTMENT_TO_RMS_INDEX < -8
+      ) {
+        frameErrorFlag |= 4;
+      }
+    }
+  }
+
+  // 错误隐藏
+  if (frameErrorFlag !== 0) {
+    decoderMltCoefs.set(hDecoder.oldDecoderMltCoefs.subarray(0, numberOfValidCoefs));
+    hDecoder.oldDecoderMltCoefs.fill(0, 0, numberOfValidCoefs);
+  } else {
+    hDecoder.oldDecoderMltCoefs.set(decoderMltCoefs.subarray(0, numberOfValidCoefs));
+  }
+
+  // 将频谱的高频部分置零
+  decoderMltCoefs.fill(0, numberOfValidCoefs, numberOfCoefs);
+}
+
+/**
+ * 解码一帧
+ */
+export function g722DecDecode(
+  hG722Dec: G722Decoder,
+  inBytes: Uint8Array,
+  outputSample: Int16Array,
+  numInBytes: { value: number },
+  numOut: { value: number },
+  isGoodPkt: number
+): void {
+  hG722Dec.frameCnt++;
+
+  // 将输入字节转换为16位字 (little-endian)
+  const numWords = Math.floor(inBytes.length / 2);
+  const inWords = new Int16Array(numWords);
+  for (let i = 0; i < numWords; i++) {
+    inWords[i] = (inBytes[i * 2 + 1] << 8) | inBytes[i * 2];
+  }
+
+  const decoderMltCoefs = hG722Dec.decoderMltCoefs;
+  const floatOutSamples = hG722Dec.floatOutSamples;
+  const frameSize = hG722Dec.frameSize;
+
+  // 解码MLT系数
+  decoder(hG722Dec, inWords, decoderMltCoefs, isGoodPkt ? 0 : 1);
+
+  // 将RMLT系数转换为输出采样
+  rmltCoefsToSamples(hG722Dec, decoderMltCoefs, floatOutSamples);
+
+  // 将浮点输出转换为16位整数输出
+  for (let i = 0; i < frameSize; i++) {
+    let ftemp0 = floatOutSamples[i];
+
+    if (ftemp0 >= 0.0) {
+      outputSample[i] = ftemp0 < 32767.0 ? Math.floor(ftemp0 + 0.5) : 32767;
+    } else {
+      outputSample[i] = ftemp0 > -32768.0 ? Math.floor(ftemp0 - 0.5) : -32768;
+    }
+
+    // ITU测试：清除最低2位
+    outputSample[i] &= 0xfffc;
+  }
+
+  numInBytes.value = hG722Dec.numberOfWords16PerFrame << 1;
+  numOut.value = frameSize;
+}
+
+/**
+ * 关闭解码器
+ */
+export function g722DecClose(hG722Dec: G722Decoder): void {
+  // TypeScript中不需要手动释放内存
+  // 此函数保留以保持API兼容性
+}