SnowLuma/packages/protocol/tests/native/audio-transcode.test.ts

import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
import os from 'os';
import path from 'path';
import { fileURLToPath } from 'url';
import { convertAudioBytes } from '@snowluma/protocol/highway/ffmpeg-addon';

interface NativeAudioAddon {
  convertToNTSilkTct(inputFile: string, outputFile: string): Promise<void>;
  decodeAudioToFmt(
    inputFile: string,
    outputFile: string,
    format: string,
  ): Promise<{ result: boolean; sampleRate: number; channels: number; format: string }>;
  getDuration(filePath: string): Promise<number>;
}

const __dirname = path.dirname(fileURLToPath(import.meta.url));

function makeMonoWav(sampleRate = 24_000, durationSeconds = 1): Buffer {
  const samples = sampleRate * durationSeconds;
  const bytes = Buffer.alloc(44 + samples * 2);
  bytes.write('RIFF', 0);
  bytes.writeUInt32LE(36 + samples * 2, 4);
  bytes.write('WAVE', 8);
  bytes.write('fmt ', 12);
  bytes.writeUInt32LE(16, 16);
  bytes.writeUInt16LE(1, 20);
  bytes.writeUInt16LE(1, 22);
  bytes.writeUInt32LE(sampleRate, 24);
  bytes.writeUInt32LE(sampleRate * 2, 28);
  bytes.writeUInt16LE(2, 32);
  bytes.writeUInt16LE(16, 34);
  bytes.write('data', 36);
  bytes.writeUInt32LE(samples * 2, 40);
  for (let i = 0; i < samples; i += 1) {
    bytes.writeInt16LE(Math.round(Math.sin(2 * Math.PI * 440 * i / sampleRate) * 12_000), 44 + i * 2);
  }
  return bytes;
}

function loadBundledAddon(): NativeAudioAddon {
  const addonPath = path.resolve(
    __dirname,
    `../../../runtime/native/ffmpeg/ffmpegAddon.${process.platform}.${process.arch}.node`,
  );
  const mod = { exports: {} as Record<string, unknown> };
  process.dlopen(mod, addonPath);
  return mod.exports as unknown as NativeAudioAddon;
}

function hasMp3Signature(bytes: Buffer): boolean {
  const hasId3Tag = bytes.length >= 3 && bytes.subarray(0, 3).toString('ascii') === 'ID3';
  const hasFrameSync = bytes.length >= 2 && bytes[0] === 0xff && (bytes[1] & 0xe0) === 0xe0;
  return hasId3Tag || hasFrameSync;
}

const isReleaseTarget = (process.platform === 'win32' && process.arch === 'x64')
  || (process.platform === 'linux' && (process.arch === 'x64' || process.arch === 'arm64'));
const describeBundledAddon = isReleaseTarget
  ? describe
  : describe.skip;

describeBundledAddon('bundled native ffmpeg addon', () => {
  let tmpDir: string;
  beforeAll(() => {
    tmpDir = mkdtempSync(path.join(os.tmpdir(), 'sl-native-audio-test-'));
  });
  afterAll(() => rmSync(tmpDir, { recursive: true, force: true }));

  it('converts a mono QQ-style SILK record to a decodable MP3 through the public transcode seam', async () => {
    const addon = loadBundledAddon();
    const wavPath = path.join(tmpDir, 'mono-input.wav');
    const silkPath = path.join(tmpDir, 'mono-input.ntsilk');
    writeFileSync(wavPath, makeMonoWav());
    await addon.convertToNTSilkTct(wavPath, silkPath);

    const result = await convertAudioBytes(readFileSync(silkPath), 'mp3', { addon, tmpDir });
    const mp3 = Buffer.from(result.base64, 'base64');
    const outputPath = path.join(tmpDir, 'mono-output.mp3');
    writeFileSync(outputPath, mp3);

    expect(result.size).toBe(mp3.length);
    expect(hasMp3Signature(mp3)).toBe(true);
    const duration = await addon.getDuration(outputPath);
    expect(duration).toBeGreaterThan(0.9);
    expect(duration).toBeLessThan(1.2);
  });

  it('converts the QQ AI SILK container variant through the public transcode seam', async () => {
    const addon = loadBundledAddon();
    const wavPath = path.join(tmpDir, 'ai-input.wav');
    const silkPath = path.join(tmpDir, 'ai-input.ntsilk');
    writeFileSync(wavPath, makeMonoWav());
    await addon.convertToNTSilkTct(wavPath, silkPath);

    const aiSilk = readFileSync(silkPath);
    expect(aiSilk.subarray(0, 10)).toEqual(
      Buffer.concat([Buffer.from([0x02]), Buffer.from('#!SILK_V3', 'ascii')]),
    );
    aiSilk[0] = 0x03;

    const result = await convertAudioBytes(aiSilk, 'mp3', { addon, tmpDir });
    const mp3 = Buffer.from(result.base64, 'base64');
    const outputPath = path.join(tmpDir, 'ai-output.mp3');
    writeFileSync(outputPath, mp3);

    expect(hasMp3Signature(mp3)).toBe(true);
    const duration = await addon.getDuration(outputPath);
    expect(duration).toBeGreaterThan(0.9);
    expect(duration).toBeLessThan(1.2);
  });
});