Please help, with buffers and/or arrays.

You can write at any position in a TBuf, not only at the end.
just use operator[] to index into it.

You shouldn't use TBuf:s though for this, a better idea is RBufs, that always keep its storage on the heap.
TBuf:s this big, if declared as automatic stack variables will bust your stack very quickly.

RBuf8 iAudioBuffer; //a member in some class somewhere
TBool iHasContent[16]; //flag field would be more efficient, but bools are easy....

[...]
iAudioBuffer.CreateL(16*4096); // space for 16 samples;

[...]
void CMyClass::AddSample(TInt aSampleNo, const TDesC8& aBuffer) {
   TInt startindex = aSampleNo*4096;
   for(TInt i = 0; i < 4096; i++) {
     iAudioBuffer[startindex + i] = aBuffer[i];
  }
  iHasContent[aSampleNo] = ETrue;
}

(Its possible to make a little bit more efficient using Mem::Copy instead of a for-loop)

It's better to use RBuf8 or HBufC8 as alh suggested, and allocate your buffers dynamically. You can also use TDes::Insert to insert data in between existing data.

If you use a 2d-buffer, you don't have to offset with the "startindex", then you select what subbuffer to use by the first []

My example used a simple 1dimensional buffer, and then you need the "startindex" offset to jump to the next "subbuffer" within the buffer.

Similar to how you step between scanlines when accessing raw images...

I think the problem is that this:

iAudioBuffer[0][startindex + i] = aBuffer[i]; // here it crashes.

should be:

iAudioBuffer[0][i] = aBuffer[i]; // here it crashes.

in your case.

My example used one single flat buffer, a single array, to store all audiodata.
Like this, here is place for 10 audiobuffers of 4096 bytes each:

__________

I called each of the logical buffers within the buffer for "subbuffers"
Then I used "startindex" to jump into the buffer, to write a part of it, lets say I want to write the 3rd audiobuffer.
I used startindex to step into it and after writing my buffer would look like
__X_______

Then I write the 5th buffer too and my buffer would look like

__X_X_____

Then write the 4th buffer and it would look like

__XXX_____

etc...

In your example code on the other hand, you do not use a flat buffer, you are using a 2-dimensional buffer, or as its also called "and array of arrays"

which could be diagrammed like this:

_
_
_
_
_
_

Then you use the first parantesis to select which "sub buffer", and you must use 0-based index to index into that sub-buffer.

I prefer the flat buffer approach, feels like I have more control, and I don't have to keep track of two indexes when using it.
And easier when scanning through all samples, since they all are guaranteed to be just after the previous sample in memory.

Ah.. I think I know what the problem is now.

When you "Create" the buffer, you get a buffer with the maxlength of what you specify.
but Length is still set to 0, even though the memory for the whole array is allocated.
So before you can use = you have to do do:

iAudioBuffer.SetMax();

The out-of-bounds check on [] is on the Length and not on the MaxLength....

Append ofcourse also works, but only if you add the buffers in order, and I thought a requirement was that they could come out-of-order.

Append is also a bit slower since each assignment also has to update the length of the descriptor.