// From Host/AudioCapturer.cpp:272-299
bool StartCapture(DWORD processId, const std::string& processName) {
    // Set MMCSS priority for audio capture thread
    ThreadPriorityManager::ThreadPriorityConfig audioConfig;
    audioConfig.mmcssClass = ThreadPriorityManager::MMCSSClass::Audio;
    audioConfig.taskName = "AudioCapture";
    audioConfig.enableMMCSS = true;
    audioConfig.threadPriority = THREAD_PRIORITY_HIGHEST;
    
    // Initialize Opus encoder
    OpusEncoderWrapper::Settings settings;
    settings.sampleRate = 48000;
    settings.channels = s_audioConfig.channels;        // Configurable
    settings.frameSize = frameSizeSamples;             // 10ms default
    settings.bitrate = s_audioConfig.bitrate;          // 64-96 kbps
    settings.complexity = s_audioConfig.complexity;    // 5-6 recommended
    settings.application = 2049;  // OPUS_APPLICATION_AUDIO for full-band
}

// From Host/AudioCapturer.cpp:321-372
settings.frameSize = (5 * 48000) / 1000;  // 5ms frames for ultra-low-latency
settings.bitrate = 48000;                 // 48 kbps for low delay
settings.enableFec = false;               // Disable FEC in low-latency mode
settings.complexity = 4;                  // Balanced encoding speed
settings.useVbr = true;
settings.constrainedVbr = true;
settings.enableDtx = false;               // No discontinuous transmission for games

// From Host/AudioCapturer.cpp:121-176
static bool RemapInterleavedChannelsInPlace(std::vector<float>& interleaved, 
                                             uint32_t inChannels, 
                                             uint32_t outChannels) {
    if (outChannels == 2 && inChannels > 2) {
        // Stereo fold-down from multi-channel
        for (size_t f = 0; f < frames; ++f) {
            const size_t base = f * inChannels;
            const float left  = interleaved[base + 0];
            const float right = interleaved[base + 1];
            float surroundSum = 0.0f;
            for (uint32_t c = 2; c < inChannels; ++c) 
                surroundSum += interleaved[base + c];
            const float surroundAvg = (inChannels > 2) ? 
                (surroundSum / static_cast<float>(inChannels - 2)) : 0.0f;
            
            g_audioTempBuffer[f * 2 + 0] = 0.85f * left  + 0.15f * surroundAvg;
            g_audioTempBuffer[f * 2 + 1] = 0.85f * right + 0.15f * surroundAvg;
        }
    }
}

// From Host/AudioCapturer.cpp:917-979
void StartEncoderThread() {
    m_encoderThread = std::thread([this]() {
        // Register with MMCSS for real-time priority
        m_hEncoderMmcssTask = AvSetMmThreadCharacteristicsW(L"Pro Audio", &m_encoderMmcssTaskIndex);
        AvSetMmThreadPriority(m_hEncoderMmcssTask, AVRT_PRIORITY_HIGH);
        
        // Main encoding loop
        while (!m_stopEncoder) {
            if (PopFrameFromRingBuffer(frame, timestamp)) {
                RawAudioFrame rawFrame;
                rawFrame.samples = std::move(frame);
                rawFrame.timestampUs = timestamp;
                EncodeAndQueueFrame(rawFrame);
            }
        }
    });
}

// From gortc_main/main.go:1678-1750
func createPeerConnectionGo() C.int {
    // Build ICE servers from environment
    iceServers := buildICEServersFromEnv()
    
    // Configure for low-latency streaming
    config := webrtc.Configuration{
        ICEServers: iceServers,
    }
    
    pc, err := webrtc.NewPeerConnection(config)
    if err != nil {
        return -1
    }
    
    peerConnection = pc
    return 0
}

// From gortc_main/main.go:1535-1585
func sendVideoSample(data unsafe.Pointer, size C.int, durationUs C.longlong) C.int {
    // Validate duration for proper pacing
    durationValue := int64(durationUs)
    if !validateVideoDuration(durationValue) {
        return -3
    }
    
    // Use buffer pool to avoid allocations
    n := int(size)
    buf := getSampleBuf(n)
    C.memcpy(unsafe.Pointer(&buf[0]), data, C.size_t(n))
    dur := time.Duration(durationValue) * time.Microsecond
    
    // Queue sample with backpressure handling
    sample := media.Sample{Data: buf, Duration: dur}
    select {
    case videoSendQueue <- sample:
        return 0
    default:
        // Drop oldest frame if queue full
        select {
        case oldestSample := <-videoSendQueue:
            putSampleBuf(oldestSample.Data)
            videoSendQueue <- sample
        }
    }
}

// From gortc_main/main.go:1342-1533
func sendAudioPacket(data unsafe.Pointer, size C.int, pts C.longlong) C.int {
    // Lock-free audio RTP state management
    if !audioRTPState.IsBaselineSet() {
        audioRTPState.SetBaseline(int64(pts))
    }
    
    // Atomic sequence/timestamp operations
    packetSequence := audioRTPState.GetNextSequence()
    packetRTPTimestamp := audioRTPState.GetNextTimestamp()
    
    // Create RTP packet
    pkt := &rtp.Packet{
        Header: rtp.Header{
            Version:        2,
            PayloadType:    audioPayloadType,
            SequenceNumber: packetSequence,
            Timestamp:      packetRTPTimestamp,
            SSRC:           audioSSRC,
            Marker:         true,
        },
        Payload: payload,
    }
    
    // Queue for dedicated sender goroutine
    audioSendQueue <- pkt
}

// From gortc_main/main.go:751-869
type tieredBufferPool struct {
    pools  [13]sync.Pool
    sizes  [13]int  // 128B to 1MB for 4K support
    hits   [13]int64
    misses [13]int64
}

var sampleBufPool = &tieredBufferPool{
    sizes: [13]int{128, 256, 512, 1500, 4096, 8192, 16384, 
                   32768, 65536, 131072, 262144, 524288, 1048576},
    sizeCount: 13,
}

func getSampleBuf(n int) []byte {
    tier := sampleBufPool.getBufferTier(n)
    targetSize := sampleBufPool.sizes[tier]
    
    v := sampleBufPool.pools[tier].Get()
    if v == nil {
        return make([]byte, targetSize)[:n]
    }
    return v.([]byte)[:n]
}

// Keyboard input (ordered, reliable)
dataChannel, _ = peerConnection.CreateDataChannel("keyPressChannel", 
    &webrtc.DataChannelInit{Ordered: newTrue()})

// Mouse input (unordered, unreliable for low latency)
mouseChannel, _ = peerConnection.CreateDataChannel("mouseChannel",
    &webrtc.DataChannelInit{Ordered: newFalse(), MaxRetransmits: newZero()})

// Video feedback (ping/pong for latency measurement)
videoFeedbackChannel, _ = peerConnection.CreateDataChannel("videoFeedbackChannel",
    &webrtc.DataChannelInit{Ordered: newFalse(), MaxRetransmits: newZero()})

// From Host/main.cpp:46-56
if (!InputIntegrationLayer::initialize()) {
    std::cerr << "Failed to initialize input integration layer" << std::endl;
    return -1;
}

if (!InputIntegrationLayer::start()) {
    std::cerr << "Failed to start input integration layer" << std::endl;
    return -1;
}

{
  "host": {
    "input": {
      "enabled": true,
      "keyboard": {
        "enabled": true,
        "method": "sendinput"
      },
      "mouse": {
        "enabled": true,
        "method": "sendinput",
        "relative": false
      }
    }
  }
}

// From Host/main.cpp:123-125
ConfigUtils::ApplyThreadPrioritySettings(config);