Ftyjtk

How to use WASAPI (or something like it) to continuously sample audio into a (thread-safe) ring-buffer, so that a consumer thread can read from that buffer in an a set interval?

Currently we have a .sample() method that returns a chunk of samples after a set sampling interval, but this has quite the overhead due to memory allocation etc.. maybe this method could be optimized; I'm pretty sure we're doing it wrong.

std::vector<short> sampler2::sample()

{

    // prepare header

    waveInPrepareHeader(hWaveIn, &WaveInHdr, sizeof(WAVEHDR));



    // insert a wave input buffer

    waveInAddBuffer(hWaveIn, &WaveInHdr, sizeof(WAVEHDR));



    // commence sampling input

    waveInStart(hWaveIn);



    // sleep for the duration of a sample interval

    std::this_thread::sleep_for(milliseconds(SAMPLE_INTERVAL));



    // create vector

    std::vector<short> samplesChunk(&waveIn[0], &waveIn[0] + NUMPTS);



    // return vector

    return samplesChunk;

}

GitHub Links: sampler2.h & sampler2.cpp

The code is very shitty and we have no clue how to properly use WASAPI. Our goal was to (quickly) create a sampler class that can leverage a sampling interval of >10 ms.

Your sample uses waveout API. You can check MSDN for WASAPI reference and usage.
Here is the basic description of WASAPI usage:
The client calls the methods in the IAudioRenderClient interface to write rendering data to an endpoint buffer.To request an endpoint buffer of a particular size, the client calls the IAudioClient::Initialize method. To get the size of the allocated buffer, which might be different from the requested size, the client calls the IAudioClient::GetBufferSize method.
To move a stream of rendering data through the endpoint buffer, the client alternately calls the IAudioRenderClient::GetBuffer method and the IAudioRenderClient::ReleaseBuffer method. The client accesses the data in the endpoint buffer as a series of data packets. The GetBuffer call retrieves the next packet so that the client can fill it with rendering data. After writing the data to the packet, the client calls ReleaseBuffer to add the completed packet to the rendering queue.
There is also this Microsoft C++ WASAPI example.