audio_chunk_impl m_chunk;  // in member declaration 

bool on_chunk(audio_chunk * chunk,abort_callback &)
{
// ...
// output the buffered stuff (hen m_chunk big enough
audio_chunk * out = insert_chunk(buffer_size * m_ch);
audio_sample * src = m_chunk.get_data();
out->set_data(src, buffer_size, m_ch, m_rate, m_ch_mask);
m_chunk.skip_first_samples(buffer_size);

// ...

// buffer the input
m_chunk.grow_data_size((buffered + sample_count) * m_ch);
audio_sample * src2 = chunk->get_data();
audio_sample * dst2 = m_chunk.get_data();
dst2 += buffered * m_ch;
for (t_size i = 0, j = sample_count * m_ch; i < j; i++)
{
	*dst2++ = *src2++;
}
}

• Is it a good idea to store input chunks in this big "audio_chunk_impl m_chunk member" ? Or would it better to instead copy each chunk to list of audio_chunk member? Or to save it in a pfc::array_t<audio_sample>? Or is it mandatory to use circular buffers (I'd like to avoid them in a first stage, and optimize that later)?
• Any idea why when I call m_chunk.skip_first_samples(buffer_size); it seems to completely empty m_chunk and not only the few samples (buffer_size) I asked? I thought skip_first_samples would simply move the chunk starting address (and probably de-allocate the skipped ones).
• Finally, a more general question, for the future steps: how often does on_chunk() method get called? Is it called at the playback speed and the chunk is then quickly sent to the hardware? Or could it go faster than the playback speed and then store somewhere the chunk (and the inserted one) until they are played? Hope this makes sense. I'm asking because I want to have a "lookahead" of ~20s of signal, but I will actually only process them only at the end of the file. Therefore, I don't need (nor want) to wait before the track starts for 20s. All I need is to have in advance the 20 last seconds of the track. (Assuming I only play tracks longer than 20s)

Is it a good idea to store input chunks in this big "audio_chunk_impl m_chunk member" ? Or would it better to instead copy each chunk to list of audio_chunk member? Or to save it in a pfc::array_t<audio_sample>? Or is it mandatory to use circular buffers (I'd like to avoid them in a first stage, and optimize that later)?

Any idea why when I call m_chunk.skip_first_samples(buffer_size); it seems to completely empty m_chunk and not only the few samples (buffer_size) I asked?

Finally, a more general question, for the future steps: how often does on_chunk() method get called? Is it called at the playback speed and the chunk is then quickly sent to the hardware?

It should only empty the buffer when you request larger skip amount than there are samples in the buffer.

The function is called as rapidly as possible when used outside audio playback and during audio playback when output buffer has room. So when playback starts you don't have to wait for 20 seconds to buffer 20 seconds worth of audio. It will be some milliseconds on modern machine and fast audio formats. Exception of course is if user plays steaming media. It won't arrive faster than realtime.