13.4 พื้นฐาน DSP

เสียงทุกอย่างที่เกมสร้างขึ้น — เสียงฝีเท้า เสียงปืน เสียงพูดของตัวละคร เพลงประกอบ — พอไปถึงลำโพงแล้วกลายเป็นสิ่งเดียวกันหมด คือ list ตัวเลขยาวๆ บทนี้พูดถึง list นั้น เสียงกลายเป็นตัวเลขได้ยังไงตั้งแต่แรก แล้วก็คณิตศาสตร์เล็กๆ ที่เราใช้เปลี่ยนตัวเลขพวกนั้น เช่น เพิ่มความดัง ผสมสองเสียงเข้าด้วยกัน ทำให้เสียงแหบๆ นุ่มขึ้น ใส่เสียงก้อง หรือปั้นความดังของโน้ตตามเวลา วงการทั้งหมดนี้เรียกว่า DSP (Digital Signal Processing — การประมวลผลที่มอง signal ในที่นี้คือเสียง เป็นข้อมูล คือตัวเลขทีละตัว วนใน loop) ไม่มีอะไรเกินสิ่งที่เรารู้อยู่แล้วเลย: array, loop, for วนบน buffer และเลขคณิตนิดหน่อย

เราจะสร้างมันตามลำดับที่ audio engine จริงๆ ทำ: sample คืออะไรกันแน่ สร้างขึ้นมาจากศูนย์ ปรับให้ดังขึ้นหรือเบาลง ผสมสองเสียงเข้าด้วยกันอย่างปลอดภัย กรองมันด้วย filter หน่วงมันให้กลายเป็นเสียงก้อง คิดถึงมันในเชิง frequency แทนที่จะเป็นเวลา ปั้นรูปทรงมันด้วย envelope และสุดท้าย โค้ดทั้งหมดนี้รันอยู่ตรงไหนในเกมจริงๆ — ใน callback ที่เข้มงวดมาก ห้าม allocate memory เด็ดขาด รันอยู่บน thread ของตัวเองโดยเฉพาะ

1. เสียงในรูปแบบข้อมูล: Sample, Sample Rate และ Amplitude

เสียงในโลกจริงคือความดันอากาศที่สั่นขึ้นลงเร็วมากๆ ไมโครโฟนแปลงการสั่นนั้นให้เป็นแรงดันไฟฟ้า (voltage) ที่สั่นขึ้นลงแบบต่อเนื่อง ราบเรียบ ไม่มีช่องว่าง คอมพิวเตอร์เก็บสิ่งที่ต่อเนื่อง (continuous) ไม่ได้ — เก็บได้แค่ตัวเลขจำนวนจำกัด ดังนั้นเพื่อแปลงเสียงเป็นข้อมูล คอมพิวเตอร์จะวัดความสูงของการสั่นนั้นที่ช่วงเวลาคงที่สม่ำเสมอ การวัดแต่ละครั้งเรียกว่า sample: ตัวเลขหนึ่งตัว ปกติเป็นค่า floating-point ประมาณระหว่าง -1.0 ถึง +1.0 ตัวเลขนั้นสูงหรือต่ำแค่ไหน ณ ขณะหนึ่งๆ เรียกว่า amplitude (ความดัง/แรงดันของเสียง ณ ขณะนั้น — 0.0 แปลว่าเงียบสนิทในขณะนั้น +1.0 หรือ -1.0 แปลว่าดังสุดเท่าที่ format จะรองรับได้)

ความถี่ที่วัดค่าพวกนี้เรียกว่า sample rate วัดเป็น Hz (จำนวนครั้งต่อวินาที) เสียงคุณภาพระดับ CD และเสียงเกมส่วนใหญ่ใช้ 44100 Hz (44,100 sample ต่อวินาที) บางทีเขียนเป็น 44.1kHz บาง engine ใช้ 48000 Hz แทน ทำไมต้องสูงขนาดนั้น หูมนุษย์ได้ยินสูงสุดประมาณ 20,000 Hz และมีกฎจาก information theory (the Nyquist theorem — จะไม่พิสูจน์ในที่นี้) บอกว่าต้องใช้ sample rate อย่างน้อยสองเท่าของความถี่สูงสุดที่ต้องการจับ 44100 นั้นสูงกว่าสองเท่าของ 20,000 อย่างสบายๆ

sample ทั้งหมดนี้เรียงต่อกันถูกเก็บไว้ใน array — ในโค้ดเสียง array นี้เกือบทุกครั้งจะเรียกว่า buffer ถ้าเอาค่าใน buffer มาพล็อตตามเวลาจะได้ภาพที่เรียกว่า waveform — รูปทรงที่เห็นในโปรแกรมตัดต่อเสียงทุกตัว

2. สร้างเสียงขึ้นมาจากศูนย์: Sine Wave

เสียงที่ง่ายที่สุดคือ pure tone: sine wave เส้นเดียวที่เรียบๆ มันคือ building block ที่ทุกอย่างในบทนี้ถูกอธิบายด้วย (พูดเพิ่มในหัวข้อ 9) sine wave มี frequency (จำนวนรอบการสั่นเต็มรอบต่อวินาที หน่วยเป็น Hz — นี่คือสิ่งที่เรารับรู้เป็น pitch หรือระดับเสียง) และ amplitude (การสั่นสูงแค่ไหน — นี่คือสิ่งที่เรารับรู้เป็นความดัง)

สูตรคณิตศาสตร์สำหรับหนึ่ง sample คือ: sample = amplitude * sin(2 * pi * frequency * n / sampleRate) โดย n คือ index ของ sample (sample 0, sample 1, sample 2, ...) ส่วนที่อยู่ใน sin(...) เรียกว่า phase — ตำแหน่งปัจจุบันรอบวงกลมของคลื่น หน่วยเป็น radian แทนที่จะคำนวณสูตรทั้งหมดใหม่ทุกครั้งสำหรับทุก sample ง่ายกว่าและถูกกว่าถ้าเก็บค่า phase ไว้ตัวเดียวแล้วบวกค่าคงที่เข้าไปทีละสเต็ป:

#include <cmath>

void FillSineBuffer(float* buffer, int numSamples, float frequency,
                     float sampleRate, float amplitude, float& phase)
{
    float phaseStep = 2.0f * 3.14159265f * frequency / sampleRate;
    for (int n = 0; n < numSamples; n++)
    {
        buffer[n] = amplitude * std::sin(phase);
        phase += phaseStep;
        if (phase > 2.0f * 3.14159265f)
            phase -= 2.0f * 3.14159265f;   // keep the angle from growing forever
    }
}

phase ถูกส่งแบบ pass by reference (float&) และเก็บไว้นอกฟังก์ชันโดยตั้งใจ: ถ้าเรียก FillSineBuffer อีกครั้งสำหรับ chunk เสียงถัดไป คลื่นต้องต่อจากจุดที่ค้างไว้พอดี ไม่งั้นจะได้ยินเสียง click ตรงรอยต่อระหว่าง buffer ลองไล่ดู 5 sample ของโทน 440 Hz (โน้ตดนตรี A4) ที่ 44100 Hz, amplitude 0.5, เริ่มจาก phase = 0:

float phase = 0.0f;
float buf[5];
FillSineBuffer(buf, 5, 440.0f, 44100.0f, 0.5f, phase);
for (int i = 0; i < 5; i++)
    printf("%.4f\n", buf[i]);

Output:

0.0000
0.0313
0.0625
0.0935
0.1241

แต่ละสเต็ปที่เดินหน้าไปจะบวก phaseStep ค่าคงที่เท่าเดิม (ประมาณ 0.0627 radian ในที่นี้) ทำให้ sin(phase) ไต่ขึ้นจาก 0 อย่างนุ่มนวล — นี่คือจุดเริ่มต้นของคลื่นที่กำลังไต่ขึ้นไปหาจุดสูงสุด frequency ที่สูงขึ้นจะทำให้ phaseStep ใหญ่ขึ้น sine เลยไต่และวนซ้ำเร็วขึ้น (สั่นถี่ขึ้นต่อวินาที pitch สูงขึ้น) ส่วน amplitude ที่ใหญ่ขึ้นแค่ scale ทุก sample ให้มากขึ้นหรือน้อยลงโดยไม่เปลี่ยนรูปทรงเลย — ซึ่งเป็นหัวข้อของหัวข้อถัดไปพอดี

3. Volume คือการคูณ

การปรับเสียงให้ดังขึ้นหรือเบาลงก็แค่การคูณทุก sample ด้วยตัวเลขตัวหนึ่ง เรียกว่า gain (ตัวคูณที่ใส่เข้าไปใน signal เวลาที่ผู้ใช้เห็นมักเรียกว่า volume) gain เท่ากับ 1.0 ทำให้เสียงไม่เปลี่ยน 0.5 ทำให้เบาลง 0.0 ทำให้เงียบสนิท และค่าที่มากกว่า 1.0 ทำให้ดังกว่าเดิม

void ApplyVolume(float* buffer, int numSamples, float volume)
{
    for (int n = 0; n < numSamples; n++)
        buffer[n] *= volume;
}

float samples[4] = { 0.2f, -0.4f, 0.6f, -0.8f };
ApplyVolume(samples, 4, 0.5f);
for (int i = 0; i < 4; i++)
    printf("%.4f\n", samples[i]);

Output:

0.1000
-0.2000
0.3000
-0.4000

ทุกค่าหดลงเหลือครึ่งหนึ่งพอดี ไม่ว่าจะเป็นค่าบวกหรือลบ — การคูณด้วย 0.5 ดึงทุก sample เข้าใกล้ 0.0 เท่าๆ กัน นี่คือไอเดียทั้งหมดที่อยู่เบื้องหลัง volume slider ใน settings menu ของเกม: อ่านค่าจาก slider (0.0 ถึง 1.0) แล้วคูณเข้าไปใน buffer ก่อนที่เสียงจะไปถึงลำโพง

4. Mixing คือการบวก — และปัญหา Clipping

เวลาสองเสียงเล่นพร้อมกัน — เช่น เสียงฝีเท้ากับเพลงประกอบ — engine ต้องรวมมันเข้าเป็น buffer เดียวก่อนที่จะไปถึงลำโพง Mixing สอง buffer เข้าด้วยกันก็แค่บวก sample ของมันเข้าด้วยกันทีละตำแหน่ง

float Clamp(float x, float lo, float hi)
{
    if (x < lo) return lo;
    if (x > hi) return hi;
    return x;
}

void MixBuffers(float* dst, const float* src, int numSamples)
{
    for (int n = 0; n < numSamples; n++)
    {
        float sum = dst[n] + src[n];
        dst[n] = Clamp(sum, -1.0f, 1.0f);   // see the warning below
    }
}

ลองไล่ดูด้วย buffer เสียงฝีเท้า (dry) กับ buffer sound effect (sfx) ที่บังเอิญดังพร้อมกันในจังหวะเดียวกัน:

float dry[3] = { 0.6f, 0.7f, -0.5f };
float sfx[3] = { 0.5f, 0.6f, -0.6f };
MixBuffers(dry, sfx, 3);
for (int i = 0; i < 3; i++)
    printf("%.4f\n", dry[i]);

Output:

1.0000
1.0000
-1.0000

ก่อน clamp ผลรวมดิบๆ คือ 1.1, 1.3 และ -1.1 — ทุกตัวอยู่นอกช่วง -1.0 .. +1.0 ที่ลำโพง (และตัว audio format เอง) รองรับได้ นี่เรียกว่า clipping: sample ตัวไหนที่เกินขีดจำกัดจะถูกตัดให้แบนแทนที่จะไปถึงจุดสูงสุดจริงๆ ของมัน

5. Gain กับ Pan: หนึ่ง Sample สองแชนแนล

เสียง mono (ลำโพงเดียว) คือ buffer เดียว ตัวเลขหนึ่งตัวต่อหนึ่งขณะเวลา เสียง stereo (ลำโพงซ้าย/ขวา) ต้องการตัวเลขสองตัวต่อขณะเวลา — หนึ่งสำหรับแชนแนลซ้าย หนึ่งสำหรับขวา game engine เกือบทุกตัวเก็บเสียง stereo แบบ interleaved: ไม่ใช่ array แยกกันสองตัว แต่เป็น array เดียวที่สลับกัน left, right, left, right, ...

Pan ควบคุมว่าเสียง mono จะไปลำโพงซ้ายกี่ส่วนเทียบกับขวา (ค่าตั้งแต่ -1.0 ซ้ายสุด, 0.0 กึ่งกลาง, ไปจนถึง +1.0 ขวาสุด) pan แบบง่าย (linear) ก็แค่แยกหนึ่ง sample ออกเป็นสองสำเนาที่ scale ไม่เท่ากัน:

void ApplyPan(float sampleIn, float pan, float& outLeft, float& outRight)
{
    // pan: -1.0 = full left, 0.0 = center, 1.0 = full right
    outLeft  = sampleIn * 0.5f * (1.0f - pan);
    outRight = sampleIn * 0.5f * (1.0f + pan);
}

float left, right;
ApplyPan(0.8f, -0.5f, left, right);
printf("left=%.4f right=%.4f\n", left, right);

Output:

left=0.6000 right=0.2000

เมื่อ pan = -0.5 (เอียงไปทางซ้าย) แชนแนลซ้ายเก็บ signal ไว้ส่วนใหญ่ (0.6) ส่วนแชนแนลขวาได้น้อยกว่า (0.2) ถ้า pan = 0 ทั้งสองแชนแนลจะได้ครึ่งหนึ่งเท่ากันพอดี

6. Filter ภาค 1: One-Pole Low-Pass Filter

filter ปรับรูปทรงของ signal ตามความเร็วที่มันเปลี่ยนแปลง ไม่ใช่ตามความดัง low-pass filter ปล่อยให้การเปลี่ยนแปลงที่ช้าๆ ค่อยเป็นค่อยไปผ่านไปได้ แล้วทำให้การเปลี่ยนแปลงที่เร็วฉับพลันเรียบลง — ในแง่ของเสียงแปลว่ามันปล่อยให้ pitch ต่ำผ่านแล้วอู้ pitch สูง (การตัด "highs" ออก เหมือนเสียงที่ได้ยินผ่านกำแพงหรือใต้น้ำ)

low-pass filter ที่ง่ายที่สุดต้องการคณิตศาสตร์แค่บรรทัดเดียว เรียกว่า recurrence relation (สูตรที่นิยามค่าถัดไปจากค่าก่อนหน้า — เคยเห็นไอเดียนี้มาแล้วตอน recursion ในบทก่อนๆ แต่ในที่นี้มันวิ่งไปข้างหน้าผ่าน buffer แทนที่จะเรียกตัวเองซ้ำ):

output ใหม่แต่ละตัวคือ output เก่าที่ถูกดันขยับไปทางค่า input ใหม่แค่บางส่วน แทนที่จะกระโดดไปเลย การดันขยับแบบนี้แหละที่ทำให้การสั่นเร็วๆ เรียบลง filter แบบ one-pole จริงๆ ต้องเก็บ memory แค่ตัวเลขเดียวระหว่างการเรียกแต่ละครั้ง (y[n-1]) นี่คือเหตุผลที่มันถูกเรียกว่า "one-pole"

struct OnePoleLowPass
{
    float a;               // smoothing coefficient, 0..1
    float y_prev = 0.0f;   // filter memory: the last output

    float Process(float x)
    {
        y_prev = y_prev + a * (x - y_prev);
        return y_prev;
    }
};

ลองไล่ดูกับ input ที่ฉับพลันแล้วคงอยู่ต่อเนื่อง — เหมือนเสียงดังที่เริ่มขึ้นทันทีแล้วดังต่อเนื่อง (x = 1.0 ซ้ำๆ) โดย a = 0.3:

OnePoleLowPass lp;
lp.a = 0.3f;
for (int i = 0; i < 5; i++)
    printf("%.3f\n", lp.Process(1.0f));

Output:

0.300
0.510
0.657
0.760
0.832

แทนที่จะกระโดดไป 1.000 ทันที filter ค่อยๆ ไต่เข้าหามัน: แต่ละสเต็ปปิดช่องว่างที่เหลือไป 30% (a = 0.3) การกระโดดฉับพลันคือการเปลี่ยนแปลงที่เร็ว — ตรงกับสิ่งที่ low-pass filter ถูกสร้างมาเพื่อทำให้เรียบลงพอดี ถ้าป้อน signal ที่ช้าและนิ่งอยู่แล้วเข้าไป มันแทบจะไม่เปลี่ยนอะไรเลย

7. Filter ภาค 2: High-Pass กับ Band-Pass

High-pass

high-pass filter ทำตรงข้ามกับ low-pass: มันปล่อยให้การเปลี่ยนแปลงเร็วๆ (pitch สูง) ผ่าน แล้วกั้นสิ่งที่ช้าและนิ่ง (pitch ต่ำและเสียงฮัม) วิธีที่ถูกที่สุดในการสร้างมันคือเอา low-pass filter ที่มีอยู่แล้วมาใช้ซ้ำ: อะไรก็ตามที่ low-pass ทำให้เรียบหายไปและกันไว้ นั่นแหละคือผลลัพธ์ของ high-pass เอา low-pass output ไปลบออกจาก input ต้นฉบับ เหลืออะไรก็คือทุกอย่างที่ low-pass filter เอาออกไป

struct OnePoleHighPass
{
    OnePoleLowPass lowpass;   // reuse the low-pass from section 6

    float Process(float x)
    {
        float low = lowpass.Process(x);
        return x - low;        // whatever the low-pass did NOT keep
    }
};

ลองรัน input x = 1.0 แบบต่อเนื่องเดียวกับหัวข้อ 6 ผ่านมัน (a = 0.3):

0.700
0.490
0.343
0.240
0.168

ค่าพวกนี้คือ 1.0 ลบด้วยค่า low-pass แต่ละตัวจากหัวข้อ 6 พอดี (1.0 - 0.300 = 0.700 ไปเรื่อยๆ) high-pass output เริ่มแรงตั้งแต่ต้น (การกระโดดฉับพลันเองก็คือการเปลี่ยนแปลงที่ใหญ่และเร็ว) แล้วค่อยๆ จางลงเป็นศูนย์ตามที่ signal นิ่งลงเป็นค่าคงที่ — ซึ่งก็สมเหตุสมผล: high-pass filter ตอบสนองต่อ การเปลี่ยนแปลง เท่านั้น และ signal คงที่สุดท้ายก็ไม่มีอะไรให้ตอบสนองอีกแล้ว

Band-pass

band-pass filter ปล่อยผ่านแค่ช่วงกลาง ("band") ของ frequency เท่านั้น กั้นทั้ง lows และ highs ที่อยู่นอกช่วงนั้น — เสียง "เสียงพูดในโทรศัพท์" หรือ "วิทยุเก่า" แบบคลาสสิก สร้างมันโดยการต่อ high-pass (เพื่อเอา lows ออก) เข้ากับ low-pass (เพื่อเอา highs ออก) เพื่อให้เหลือแต่สิ่งที่รอดทั้งสองขั้นตอนแล้วผ่านไปได้:

struct OnePoleBandPass
{
    OnePoleHighPass highpass;
    OnePoleLowPass  lowpass;

    float Process(float x)
    {
        float noLows = highpass.Process(x);
        return lowpass.Process(noLows);
    }
};

ป้อน step ต่อเนื่องเดิม (x = 1.0 ซ้ำๆ) เข้าไปใน OnePoleBandPass ส่วนที่ต่ำและนิ่งจะถูก high-pass ภายในกั้นไว้ก่อน แล้วพลังงานเร็วๆ ที่เหลืออยู่ก็จะถูก low-pass ภายในทำให้เรียบต่ออีกที ผลลัพธ์คือขึ้นสูงสุดสั้นๆ ทันทีหลังการกระโดด แล้วก็จางกลับไปเป็นศูนย์ — มันไม่ปล่อยผ่านทั้งโทนคงที่บริสุทธิ์และช่วงเวลาที่เปลี่ยนแปลงคมที่สุด ปล่อยผ่านแค่สิ่งที่อยู่ระหว่างกลาง

8. Delay กับ Echo: Buffer ที่จำอดีตได้

echo ทำเสียงซ้ำหลังจากหน่วงเวลาสั้นๆ เบาลงทุกครั้ง การสร้างมันต้องมีวิธีจำ sample จากอดีต — delay line: buffer ขนาดคงที่ที่ใช้เป็น ring (circular buffer วนกลับไป index 0 หลังจาก slot สุดท้าย) sample ใหม่ถูกเขียนเข้าไป sample เก่าที่อยู่ห่างออกไปเป็นจำนวน slot คงที่ถูกอ่านกลับออกมา

struct Delay
{
    static const int kSize = 4;    // kept tiny so it is easy to trace by hand
    float buffer[kSize] = { 0.0f, 0.0f, 0.0f, 0.0f };
    int writePos = 0;
    float feedback = 0.5f;         // how much of the echo repeats again -- keep < 1.0

    float Process(float input)
    {
        float wet = buffer[writePos];                // the echo: written here N samples ago
        buffer[writePos] = input + wet * feedback;    // new input + a fraction of the echo
        writePos = (writePos + 1) % kSize;            // move forward, wrap after the last slot
        return wet;                                   // caller mixes this with the dry signal
    }
};

Process แค่คืนค่า sample ที่เป็น echo ("wet") กลับมา — การผสมมันกับ sample ต้นฉบับ ("dry") ก็คือ mixing (การบวก) จากหัวข้อ 4 นั่นเอง:

Delay delay;
float dry[9] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
for (int n = 0; n < 9; n++)
{
    float wet = delay.Process(dry[n]);
    float outSample = dry[n] + wet * 0.5f;   // 50% wet mix under the dry signal
    printf("n=%d  output=%.4f\n", n, outSample);
}

Output (แสดงเฉพาะ sample ที่น่าสนใจ ที่เหลือเป็น 0.0000):

n=0  output=1.0000
n=4  output=0.5000
n=8  output=0.2500

เสียง "clap" ดังครั้งเดียวที่ n=0 กลับมาเป็น echo อีก 4 sample ถัดมา (n=4) ถูก scale ลงด้วย wet mix 0.5 อีก 4 sample ถัดจากนั้น (n=8) มันกลับมาอีกครั้ง — คราวนี้ถูก scale ด้วย feedback = 0.5 ซ้อนเข้าไปอีก จึงเบาลงครึ่งหนึ่งของ echo แรก ทุกรอบเพิ่มเติมที่วนรอบ buffer จะคูณด้วย feedback ซ้ำอีก นี่คือเหตุผลที่ echo จริงๆ ค่อยๆ จางหายไปแทนที่จะซ้ำไปตลอดกาล

reverb พื้นฐาน (ความรู้สึกว่าเสียงอยู่ในห้อง ไม่ใช่แค่ซ้ำครั้งเดียว) สร้างจากไอเดียเดียวกัน แค่ขยายใหญ่ขึ้น: แทนที่จะใช้ delay line เดียว ใช้หลาย delay line ที่มีความยาวต่างกันไม่ตรงกัน ป้อนเข้าหากันและผสมกัน echo ที่ซ้อนกันและจางลงมากมายมาถึงใกล้กันมากจนหูหยุดได้ยินการซ้ำทีละครั้งแล้วได้ยินเป็นหางเสียงที่เรียบและกว้างแทน — ซึ่งตรงกับสิ่งที่ห้องเต็มไปด้วยพื้นผิวสะท้อนทำกับเสียงในชีวิตจริงพอดี

9. Frequency Domain กับ FFT

หัวข้อ 2 สร้าง pure sine wave เดี่ยวๆ เสียงจริงๆ — เสียงพูด สายกีตาร์ ระเบิด — ไม่ใช่ sine wave เดียว มันคือ sine wave หลายตัวที่มี frequency และความดังต่างกัน บวกรวมกันทั้งหมดพร้อมกัน นี่คือไอเดียหลักของ frequency domain: signal ที่ซ้ำตัวเองได้อธิบายเป็นผลรวมของ sine wave ง่ายๆ แต่ละตัวมี frequency กับ amplitude ของตัวเอง การอธิบายเสียงแบบนี้ (เป็น list ว่า "มี frequency ไหนมากแค่ไหน") ถูกต้องพอๆ กับการอธิบายมันเป็น buffer ของ sample ตามเวลา (time domain ซึ่งคือทุกอย่างที่เราทำมาตลอดบทนี้) — ทั้งสองแบบเป็นมุมมองที่ต่างกันของเสียงเดียวกันเป๊ะๆ

การสร้างโทนที่ "อุดมสมบูรณ์" ขึ้นจริงๆ ก็แค่การบวก การกระทำเดียวกับ mixing ในหัวข้อ 4 — แค่ในที่นี้เราบวก pitch สองแบบที่ต่างกันของเครื่องดนตรีชิ้นเดียวกัน แทนที่จะเป็นสองเสียงที่ต่างกัน:

const int N = 8;
float toneA[N];
float toneB[N];
float complexTone[N];

float phaseA = 0.0f;
float phaseB = 0.0f;
FillSineBuffer(toneA, N, 220.0f, 44100.0f, 0.3f,  phaseA);  // the fundamental note
FillSineBuffer(toneB, N, 440.0f, 44100.0f, 0.15f, phaseB);  // one octave up, quieter

for (int n = 0; n < N; n++)
    complexTone[n] = toneA[n] + toneB[n];   // this line IS "mixing" from section 4

ที่ n = 0 ทั้งสอง phase เริ่มที่ 0 ดังนั้น complexTone[0] = 0.3 * sin(0) + 0.15 * sin(0) = 0.0000 จากตรงนั้น sine wave ทั้งสองไต่ขึ้นด้วยความเร็วต่างกัน (220 Hz กับ 440 Hz มีค่า phaseStep ต่างกัน) ทำให้ผลรวมเลิกดูเหมือน sine เรียบๆ เส้นเดียวและเริ่มดูขรุขระ — ความขรุขระนั้นคือ frequency สองตัวซ้อนทับกันในตัวเลขชุดเดียวกันจริงๆ

การทำย้อนทิศทาง — เอา buffer ของ sample มาแล้วหาว่า frequency ไหนบ้าง (และมากแค่ไหน) ซ่อนอยู่ข้างใน — คือสิ่งที่ FFT (Fast Fourier Transform, อัลกอริทึมหนึ่ง เราจะไม่เขียนโค้ดของมันในที่นี้) ทำ ป้อน chunk ของ sample แบบ time-domain เข้าไป มันจะคืนชุด frequency bin กลับมา แต่ละ bin บอกว่ามีพลังงานอยู่แถวๆ frequency นั้นมากแค่ไหน

EQ (equalizer — ปุ่มควบคุมสไตล์ "bass/mid/treble" ในแอปเสียง) คือประโยคที่แล้วพอดี: boost หรือ cut ช่วง frequency ที่กำหนด ในทางแนวคิดคือรัน FFT คูณ bin บางตัวด้วย gain แล้วรันการดำเนินการย้อนกลับเพื่อกลับไปเป็น buffer แบบ time-domain:

// Pseudocode -- shows the IDEA of an FFT-based EQ; not runnable as-is.
float freqBins[bins] = FFT(timeBuffer);       // time domain -> frequency domain

freqBins[bassRange]   *= 1.5f;                 // boost the bass frequencies
freqBins[trebleRange] *= 0.6f;                 // cut the treble frequencies

float timeBuffer2[N] = InverseFFT(freqBins);   // frequency domain -> time domain again

10. Envelope: ปั้นรูปทรงเสียงตามเวลา (ADSR)

หัวข้อ 3 คูณทุก sample ด้วย volume คงที่ตัวเดียว envelope คือไอเดียเดียวกันที่ยืดออกไปตามเวลา: แทนที่จะเป็นตัวคูณค่าคงที่ตัวเดียว มันคือตัวคูณที่เปลี่ยนไปตลอดช่วงชีวิตของเสียง — เบาตอนแรก ไต่ขึ้นไปจุดสูงสุด นิ่งลง แล้วจางหายไป รูปทรงที่พบบ่อยที่สุด ใช้กันแทบทุก synthesizer และ sampler คือ ADSR: Attack, Decay, Sustain, Release

enum class EnvelopeState { Attack, Decay, Sustain, Release, Idle };

struct ADSR
{
    float attackStep;    // added to value each sample during Attack
    float decayStep;     // subtracted from value each sample during Decay
    float sustainLevel;  // held level during Sustain
    float releaseStep;   // subtracted from value each sample during Release
    float value = 0.0f;
    EnvelopeState state = EnvelopeState::Attack;

    void NoteOff() { state = EnvelopeState::Release; }

    float Next()
    {
        switch (state)
        {
            case EnvelopeState::Attack:
                value += attackStep;
                if (value >= 1.0f) { value = 1.0f; state = EnvelopeState::Decay; }
                break;
            case EnvelopeState::Decay:
                value -= decayStep;
                if (value <= sustainLevel) { value = sustainLevel; state = EnvelopeState::Sustain; }
                break;
            case EnvelopeState::Sustain:
                break;   // holds until NoteOff() is called
            case EnvelopeState::Release:
                value -= releaseStep;
                if (value <= 0.0f) { value = 0.0f; state = EnvelopeState::Idle; }
                break;
            case EnvelopeState::Idle:
                break;
        }
        return value;
    }
};

ลองไล่ดูด้วย attackStep = 1/3, decayStep = 0.25, sustainLevel = 0.5, releaseStep = 0.25 เรียก Next() หนึ่งครั้งต่อ sample แล้วเรียก NoteOff() ทันทีหลังการเรียกครั้งที่ 6:

call 1 (Attack):   0.3333
call 2 (Attack):   0.6667
call 3 (Attack):   1.0000   -> reaches peak, switches to Decay
call 4 (Decay):    0.7500
call 5 (Decay):    0.5000   -> reaches sustainLevel, switches to Sustain
call 6 (Sustain):  0.5000   -> NoteOff() called here
call 7 (Release):  0.2500
call 8 (Release):  0.0000   -> reaches 0, switches to Idle

เอาค่า value ที่คืนมานี้ไปคูณเข้ากับ sample ของเสียงทุก sample (เหมือน ApplyVolume ในหัวข้อ 3 เป๊ะๆ ต่างแค่ตัวคูณตอนนี้มาจาก Next() แทนที่จะเป็นตัวเลขคงที่) แล้วก็จะได้โน้ตที่ค่อยๆ ดังขึ้น นิ่งลง ค้างอยู่ตอนที่กดปุ่มหรือ trigger ค้างไว้ แล้วค่อยๆ จางหายไปตอนปล่อย — แทนที่จะเป็นเสียง click on/off แบบทันทีทันใด

11. DSP เสียบเข้ากับ Engine ตรงไหน: Audio Callback

โค้ดทุกชิ้นในบทนี้มีจุดร่วมกันอย่างหนึ่ง: มันเติมหรือแก้ buffer ของ sample ทีละ chunk นี่คือวิธีที่ engine จริงๆ ขอเสียง บน audio thread ของตัวเองโดยเฉพาะ (แยกจาก game thread ที่รัน Update(), physics, และ AI) engine จะเรียกเข้ามาในโค้ดของเราเป็นระยะๆ ผ่าน audio callback — ฟังก์ชันที่มีหน้าที่ทั้งหมดคือ: "เติม buffer sample นี้ให้เสร็จ เดี๋ยวนี้เลย ก่อนที่มันจะถึงกำหนดไปถึงลำโพง"

เพราะ deadline เข้มงวดมากและผลของการพลาด deadline ได้ยินทันที โค้ดที่รันบน audio thread ต้องทำตามกฎที่เข้มงวดข้อหนึ่งซึ่งไม่มีที่ไหนในหนังสือเล่มนี้ต้องการมาก่อน: ห้าม allocate memory ที่นั่น — ห้าม new, ห้าม malloc, ห้าม resize List หรือ std::vector, ห้าม lock mutex ที่ game thread อาจถืออยู่, ห้าม logging, ห้ามเข้าถึงไฟล์ สิ่งเหล่านี้ทำให้ audio thread หยุดชะงักไปชั่วขณะที่คาดเดาไม่ได้ (garbage collector รัน, OS ขอ memory, lock ที่รอ thread อื่นอยู่) — และการหยุดชะงักที่คาดเดาไม่ได้บน thread นี้แหละคือสาเหตุของเสียง click หรือ pop ที่บางทีได้ยินในเกมที่ optimize ไม่ดี buffer ทุกตัวและ state ของ filter ทุกตัวควรถูก allocate ครั้งเดียวล่วงหน้า แล้วแค่อ่านหรือเขียนภายใน callback เท่านั้น

Unity: OnAudioFilterRead (C#)

Unity เรียก OnAudioFilterRead บน audio thread สำหรับ AudioSource ใดๆ ที่อยู่บน GameObject เดียวกัน มันส่ง buffer มาให้ตรงๆ — data ถูก interleave เหมือน diagram ในหัวข้อ 5 เป๊ะๆ — เลย filter มันในที่เดิมได้เลย โดยไม่ต้อง allocate อะไรเลย:

using UnityEngine;

public class SimpleLowPassFilter : MonoBehaviour
{
    public float cutoffAmount = 0.3f;     // 0..1, smaller = more filtering

    // Filter memory lives here, as fields -- allocated once, never inside the callback.
    private float lowpassStateL = 0.0f;
    private float lowpassStateR = 0.0f;

    // Unity calls this on the AUDIO THREAD, not the main thread.
    // It must finish fast, and it must not allocate.
    void OnAudioFilterRead(float[] data, int channels)
    {
        for (int i = 0; i < data.Length; i += channels)
        {
            lowpassStateL = lowpassStateL + cutoffAmount * (data[i] - lowpassStateL);
            data[i] = lowpassStateL;

            if (channels > 1)
            {
                lowpassStateR = lowpassStateR + cutoffAmount * (data[i + 1] - lowpassStateR);
                data[i + 1] = lowpassStateR;
            }
        }
    }
}

นี่คือ one-pole low-pass จากหัวข้อ 6 เป๊ะๆ ใช้กับ buffer จริงของ Unity ทีละ sample — lowpassStateL/lowpassStateR ทำหน้าที่เหมือน y_prev และเพราะมันเป็น field บน object (ไม่ใช่ local variable) มันเลยเก็บค่าไว้ข้ามจาก callback หนึ่งไปอีก callback หนึ่งได้ เหมือนที่ phase ต้องทำในหัวข้อ 2

Native engine callback (C++)

engine ระดับล่างและ native audio API (สไตล์ที่ library อย่าง miniaudio, PortAudio, WASAPI, หรือ CoreAudio ใช้) จะส่ง raw pointer กับจำนวน frame มาให้ แทนที่จะเป็น managed array แต่รูปทรงของงานเหมือนกันทุกอย่าง:

struct DspState
{
    OnePoleLowPass filterL;
    OnePoleLowPass filterR;
};   // allocated ONCE, e.g. in an Init() function, long before playback starts

void AudioCallback(float* outputBuffer, int numFrames, int numChannels, void* userData)
{
    DspState* dsp = static_cast<DspState*>(userData);   // NOT allocated here

    for (int frame = 0; frame < numFrames; frame++)
    {
        int i = frame * numChannels;
        outputBuffer[i] = dsp->filterL.Process(outputBuffer[i]);
        if (numChannels > 1)
            outputBuffer[i + 1] = dsp->filterR.Process(outputBuffer[i + 1]);
    }
}

12. Glossary (ศัพท์)

• Sample — ตัวเลขหนึ่งตัวที่แทน amplitude ของเสียง ณ ขณะเวลาหนึ่ง
• Sample rate — จำนวน sample ที่วัดต่อวินาที หน่วยเป็น Hz (เช่น 44100 Hz / 44.1kHz)
• Amplitude — signal ดังแค่ไหน ณ ขณะหนึ่ง ปกติเก็บเป็น float ประมาณระหว่าง -1.0 ถึง +1.0
• Buffer — array ของ sample หน่วยพื้นฐานที่โค้ดเสียงอ่านและเขียน
• Waveform — รูปทรงที่ได้จากการพล็อต sample ใน buffer ตามเวลา
• Gain / Volume — ตัวคูณที่ใส่เข้าไปใน sample ของ signal เพื่อทำให้ดังขึ้นหรือเบาลง
• Clipping — ความบิดเบี้ยวที่เกิดขึ้นเมื่อค่า sample ถูกตัดให้แบนเพราะเกินสิ่งที่ format รองรับได้ (ปกติคือเกิน -1.0 หรือ +1.0)
• Mixing — รวมสองเสียงขึ้นไปเข้าเป็นหนึ่งเดียวโดยบวก sample ของมันเข้าด้วยกันทีละตำแหน่ง
• Pan — signal ไปแชนแนลซ้ายกี่ส่วนเทียบกับขวา
• Filter — DSP ที่ปรับรูปทรง signal ตามความเร็วที่มันเปลี่ยนแปลง (frequency content ของมัน) เช่น low-pass, high-pass, หรือ band-pass
• Recurrence relation — สูตรที่นิยามค่าถัดไปจากค่าก่อนหน้า เป็นพื้นฐานของ one-pole filter คือ y[n] = y[n-1] + a * (x[n] - y[n-1])
• Cutoff frequency — pitch ที่ filter เจาะจงอยู่รอบๆ จุดที่มันเริ่มปล่อย signal ผ่านน้อยลง
• Delay line — circular buffer ขนาดคงที่ที่ใช้จำ sample ในอดีตเพื่อเล่นซ้ำทีหลังในรูปแบบ echo
• Feedback — สัดส่วนของ output จาก delay ที่ถูกเขียนกลับเข้าไปใน delay buffer ควบคุมว่า echo ซ้ำกี่ครั้งและจางเร็วแค่ไหน
• Reverb — กลุ่ม echo ที่ซ้อนกันและจางลงหนาแน่น ให้ความรู้สึกว่าเสียงอยู่ในพื้นที่ทางกายภาพ
• Frequency domain / Time domain — สองวิธีอธิบาย signal เดียวกัน: เป็นผลรวมของ frequency กับความแรงของมัน หรือเป็น buffer ของค่า amplitude ตามเวลา
• FFT (Fast Fourier Transform) — อัลกอริทึมที่แปลง buffer แบบ time-domain เป็นตัวแทนแบบ frequency-domain (ชุดของ frequency bin)
• EQ (Equalizer) — effect ที่ boost หรือ cut ช่วง frequency ที่กำหนดของ signal
• Envelope / ADSR — ตัวคูณที่เปลี่ยนตามเวลา (Attack, Decay, Sustain, Release) ใช้ปั้นว่า volume ของเสียง (หรือ parameter อื่น) เปลี่ยนไปยังไงตลอดช่วงชีวิตของมัน
• Audio callback — ฟังก์ชันที่ engine หรือ audio API เรียกเพื่อขอ chunk ของ sample ถัดไปที่จะเล่น
• Audio thread — thread เฉพาะที่ audio callback รันอยู่ มี deadline แบบ real-time เข้มงวด ห้าม allocate, lock, หรือ block เด็ดขาด

13. แบบฝึกหัด

public class BadFilter : MonoBehaviour
{
    public float cutoffAmount = 0.3f;

    void OnAudioFilterRead(float[] data, int channels)
    {
        float[] smoothed = new float[data.Length];   // temp buffer
        float state = 0.0f;
        for (int i = 0; i < data.Length; i++)
        {
            state = state + cutoffAmount * (data[i] - state);
            smoothed[i] = state;
        }
        for (int i = 0; i < data.Length; i++)
            data[i] = smoothed[i];
    }
}

นั่นคือแก่นของ game audio DSP ทั้งหมด: เสียงในรูปแบบ buffer ของ sample ที่ sample rate คงที่ volume คือการคูณ mixing คือการบวก (ระวังเรื่อง clipping) แยก signal ข้ามแชนแนลด้วย gain กับ pan ปั้น frequency content ด้วย one-pole filter จำอดีตด้วย delay line เพื่อสร้าง echo คิดถึง signal ในแบบ frequency domain แทนที่จะเป็น time domain ปั้นความดังตามเวลาด้วย envelope และสุดท้าย กฎห้าม allocate ที่เข้มงวดของ audio thread ที่โค้ดทั้งหมดนี้ต้องรันอยู่จริงๆ ทุกส่วนของมันย่อลงเหลือแค่การกระทำไม่กี่แบบเหมือนกัน — คูณ บวก จำค่าก่อนหน้าหนึ่งค่า — ทำซ้ำไปทั่ว buffer วนไปเรื่อยๆ หลายครั้งต่อวินาที