[ Incoming PCM Packets ] 
         │
         ▼
 1. NetEq::InsertPacket()  ──► [ Internal Jitter Buffer ]
                                        │
                                        ▼
 2. NetEq::GetAudio()      ──► [ DSP Decision Engine ] (Normal / PLC / Stretch)
                                        │
                                        ▼
                               [ 10ms Smooth PCM Output ]

#include <vector>
#include <cmath>
#include <algorithm>
#include <cstdint>

class JamulusPcmPlc {
private:
    static const int SFREQ = 48000;
    static const int MAX_LAG = 600;   // 80 Hz at 48kHz
    static const int MIN_LAG = 40;    // 1200 Hz at 48kHz
    static const int HIST_SIZE = 2048; // Keeping ~42ms of history
    
    std::vector<int16_t> history_left;
    std::vector<int16_t> history_right;

    // Finds the pitch period in samples using AMDF
    int DetectPitchPeriod(const std::vector<int16_t>& history) {
        int best_lag = MIN_LAG;
        uint64_t min_diff = UINT64_MAX;
        
        // Window size to evaluate (approx 10ms of audio)
        const int window_size = 480; 
        int start_idx = HIST_SIZE - window_size;

        for (int lag = MIN_LAG; lag <= MAX_LAG; ++lag) {
            uint64_t current_diff = 0;
            for (int i = 0; i < window_size; ++i) {
                current_diff += std::abs(history[start_idx + i] - history[start_idx + i - lag]);
            }
            
            if (current_diff < min_diff) {
                min_diff = current_diff;
                best_lag = lag;
            }
        }
        return best_lag;
    }

    // Extrapolates a single channel using PSOLA
    void ConcealChannel(std::vector<int16_t>& history, int16_t* output, int frame_size) {
        int pitch = DetectPitchPeriod(history);
        
        // Cross-fade length: 1ms (48 samples) or half the frame size, whichever is smaller
        int crossfade_len = std::min(48, frame_size / 2);
        
        // 1. Extrapolate the waveform by copying back from the history by 'pitch' samples
        for (int i = 0; i < frame_size; ++i) {
            int history_target_idx = HIST_SIZE - pitch + (i % pitch);
            output[i] = history[history_target_idx];
        }
        
        // 2. Smooth the transition at the beginning of the concealment frame (Overlap-Add)
        for (int i = 0; i < crossfade_len; ++i) {
            float fade_in = static_cast<float>(i) / crossfade_len;
            float fade_out = 1.0f - fade_in;
            
            // Boundary mix: smoothly blend the true history tail with the newly generated pitch start
            int hist_tail_idx = HIST_SIZE - crossfade_len + i;
            if (hist_tail_idx < HIST_SIZE) {
                output[i] = static_cast<int16_t>((output[i] * fade_in) + (history[hist_tail_idx] * fade_out));
            }
        }
    }

public:
    JamulusPcmPlc() {
        history_left.resize(HIST_SIZE, 0);
        history_right.resize(HIST_SIZE, 0);
    }

    // Call this EVERY time a valid packet successfully arrives to update the history
    void UpdateHistory(const int16_t* interleaved_pcm, int frame_size) {
        // Shift history left
        std::rotate(history_left.begin(), history_left.begin() + frame_size, history_left.end());
        std::rotate(history_right.begin(), history_right.begin() + frame_size, history_right.end());
        
        // Insert new samples at the tail
        for (int i = 0; i < frame_size; ++i) {
            history_left[HIST_SIZE - frame_size + i] = interleaved_pcm[2 * i];
            history_right[HIST_SIZE - frame_size + i] = interleaved_pcm[2 * i + 1];
        }
    }

    // Call this when Jamulus detects a lost UDP packet
    void GeneratePlcFrame(int16_t* output_interleaved_pcm, int frame_size) {
        std::vector<int16_t> plc_left(frame_size);
        std::vector<int16_t> plc_right(frame_size);
        
        // Synthesise missing audio for both channels
        ConcealChannel(history_left, plc_left.data(), frame_size);
        ConcealChannel(history_right, plc_right.data(), frame_size);
        
        // Interleave back into Jamulus's native buffer structure
        for (int i = 0; i < frame_size; ++i) {
            output_interleaved_pcm[2 * i] = plc_left[i];
            output_interleaved_pcm[2 * i + 1] = plc_right[i];
        }
        
        // Feed our own synthesised frame back into history so consecutive drops remain continuous
        UpdateHistory(output_interleaved_pcm, frame_size);
    }
};

[ Incoming UDP Packet ] ──► ( If Valid ) ──► plc.UpdateHistory() ────┐
                         │                                           ▼
                         └──► ( If Lost )  ──► plc.GeneratePlcFrame() ─► [ int16_t Buffer ]
                                                                             │
                                                                             ▼
                                                                     [ Convert to Float ]
                                                                             │
                                                                             ▼
                                                                     [ Gain & Mixing ]

// Add this private member variable to the JamulusPcmPlc class header:
// int consecutive_drop_count = 0;

void GeneratePlcFrame(int16_t* output_interleaved_pcm, int frame_size) {
    std::vector<int16_t> plc_left(frame_size);
    std::vector<int16_t> plc_right(frame_size);
    
    // 1. Synthesise missing audio based on history
    ConcealChannel(history_left, plc_left.data(), frame_size);
    ConcealChannel(history_right, plc_right.data(), frame_size);
    
    // 2. Calculate fade attenuation for consecutive packet losses
    // First dropped frame is 100% volume. Subsequent frames fade out exponentially.
    float volume_scale = 1.0f;
    if (consecutive_drop_count > 0) {
        // Drop volume by ~20% per additional frame drop
        volume_scale = std::max(0.0f, 1.0f - (consecutive_drop_count * 0.20f)); 
    }
    consecutive_drop_count++; 

    // 3. Interleave and apply attenuation
    for (int i = 0; i < frame_size; ++i) {
        output_interleaved_pcm[2 * i]     = static_cast<int16_t>(plc_left[i] * volume_scale);
        output_interleaved_pcm[2 * i + 1] = static_cast<int16_t>(plc_right[i] * volume_scale);
    }
    
    // Feed our own synthesised frame back into history so subsequent drops remain continuous
    UpdateHistory(output_interleaved_pcm, frame_size);
}

// IMPORTANT: In your main network thread, whenever a packet ARRIVES SUCCESSFULLY, 
// you must reset this counter so the next drop starts fresh:
// plc.consecutive_drop_count = 0;

// This code runs inside the audio thread callback loop processing each channel
int16_t current_channel_buffer[2 * current_frame_size]; 

// Attempt to pull the next sequential block from the jitter buffer
bool packet_found = JitterBuffer.PopNextFrame(current_channel_buffer);

if (packet_found) {
    // 1. A valid packet was present at the playback deadline.
    // Reset the consecutive drop tracking.
    plc_instance.consecutive_drop_count = 0;
    
    // Feed this real audio into the PLC history so it has fresh data to track.
    plc_instance.UpdateHistory(current_channel_buffer, current_frame_size);
} 
else {
    // 2. Blackout occurred! The jitter buffer slot was empty or too late.
    // Synthesise a smooth, phase-aligned concealment block into the buffer.
    plc_instance.GeneratePlcFrame(current_channel_buffer, current_frame_size);
}

// 3. Continue to the existing Jamulus dev pipeline:
// Convert int16_t 'current_channel_buffer' to float, apply gain, mix, and output.