uint32 nuiWaveWriter::Write(const void* pBuffer, uint32 SampleFrames, nuiSampleBitFormat format)
{
//add size to read To size already read
uint64 NbFrames = mrSampleInfo.GetSampleFrames() + SampleFrames;
mrSampleInfo.SetSampleFrames( NbFrames );
const uint32 SamplePointsToWrite = SampleFrames * mrSampleInfo.GetChannels();
uint32 SampleFramesWritten = 0;
switch(format)
{
case eSampleInt16 :
{
switch ( mrSampleInfo.GetBitsPerSample() )
{
case 16 :
{
SampleFramesWritten = (uint32)mrStream.WriteInt16( (int16*)pBuffer, SamplePointsToWrite) / mrSampleInfo.GetChannels();
}
break;
default:
SampleFramesWritten = 0;
break;
}
}
break;
case eSampleFloat32 :
{
switch ( mrSampleInfo.GetBitsPerSample() )
{
case 16 :
{
float* pTempFloat = (float*)pBuffer;
int16* pInt16Buffer = new int16[SamplePointsToWrite];
nuiAudioConvert_FloatBufferTo16bits(pTempFloat, pInt16Buffer, SamplePointsToWrite);
SampleFramesWritten = (uint32)mrStream.WriteInt16(pInt16Buffer, SamplePointsToWrite) / mrSampleInfo.GetChannels();
}
break;
case 24 :
{
float* pTempFloat = (float*)pBuffer;
std::vector<uint8> TempBuffer;
TempBuffer.resize(SamplePointsToWrite * 3); //nb of sample points * 3 bytes (24 bits) = nb of bytes to read
nuiAudioConvert_FloatTo24bitsLittleEndian(pTempFloat,&TempBuffer[0],SamplePointsToWrite);
SampleFramesWritten = (uint32)mrStream.WriteUInt8(&TempBuffer[0], SamplePointsToWrite * 3) / (3 * mrSampleInfo.GetChannels());
}
break;
case 32 :
{
float* pTempFloat = (float*)pBuffer;
SampleFramesWritten = (uint32)mrStream.WriteFloat(pTempFloat, SamplePointsToWrite) / mrSampleInfo.GetChannels();
}
break;
default:
SampleFramesWritten = 0;
break;
}
}
break;
default :
SampleFramesWritten = 0;
break;
}
return SampleFramesWritten;
}
uint32 nuiAudioDecoder::ReadDE(std::vector<void*> buffers, uint32 sampleframes, nuiSampleBitFormat format)
{
if (!mInitialized)
return 0;
SetPosition((uint32)mPosition);
uint32 length = mInfo.GetSampleFrames();
if (mPosition >= length)
return 0;
sampleframes = MIN(sampleframes, length - mPosition);
uint32 channels = mInfo.GetChannels();
if (buffers.size() != channels)
return 0;
std::vector<float*> temp(channels);
for (uint32 c = 0; c < channels; c++)
{
if (format == eSampleFloat32)
temp[c] = (float*)(buffers[c]);
else
temp[c] = new float[sampleframes];
}
//
uint64 BytesToRead = SampleFramesToBytes(sampleframes);
uint32 listSize = sizeof(AudioBufferList) + sizeof(AudioBuffer)* (channels-1);
AudioBufferList* pBufList = reinterpret_cast<AudioBufferList*> (new Byte[listSize]);
pBufList->mNumberBuffers = channels; // we query non-interleaved samples, so we need as many buffers as channels
for (uint32 c = 0; c < pBufList->mNumberBuffers; c++)
{
// each AudioBuffer represents one channel (non-interleaved samples)
pBufList->mBuffers[c].mNumberChannels = 1;
pBufList->mBuffers[c].mDataByteSize = BytesToRead / channels;
pBufList->mBuffers[c].mData = temp[c];
}
//
UInt32 frames = sampleframes;
OSStatus err = ExtAudioFileRead(mpPrivate->mExtAudioFileRef, &frames, pBufList);
if (err != noErr)
frames = 0;
if (format == eSampleInt16)
{
for (uint32 c = 0; c < channels; c++)
{
if (err != noErr)
{
nuiAudioConvert_FloatBufferTo16bits(temp[c], (int16*)(buffers[c]), frames);
}
delete[] temp[c];
}
}
delete pBufList;
mPosition += frames;
return frames;
}
int32 nuiAudioDecoder::ReadIN(void* pBuffer, int32 sampleframes, nuiSampleBitFormat format)
{
if (!mInitialized)
return 0;
SetPosition(mPosition);
int32 BitsPerSample = mInfo.GetBitsPerSample();
int32 channels = mInfo.GetChannels();
int32 frameSize = channels * (mInfo.GetBitsPerSample() / 8.f);
int32 outBytes = sampleframes * frameSize;
unsigned char* pTemp;
bool allocated = false;
if (BitsPerSample != 16 && BitsPerSample != 32)
{
NGL_ASSERT(0);
return 0;
}
else if ( ((format == eSampleFloat32) && (BitsPerSample == 32)) || ((format == eSampleInt16) && (BitsPerSample == 16)) )
{
pTemp = (unsigned char*)pBuffer;
}
else
{
pTemp = new unsigned char[outBytes];
allocated = true;
}
unsigned char* pIn = NULL;
int32 bytesDone = 0;
int err = MPG123_OK;
int32 bytesRead = -1;
while (outBytes && err != MPG123_DONE && bytesRead != 0)
{
size_t outBytesDone = 0;
unsigned char* pOut = pTemp + bytesDone;
err = mpg123_decode(mpPrivate->mpHandle, NULL, 0, pOut, outBytes, &outBytesDone);
outBytes -= outBytesDone;
bytesDone += outBytesDone;
if (err == MPG123_NEW_FORMAT)
{
long r;
int c;
int e;
mpg123_getformat(mpPrivate->mpHandle, &r, &c, &e);
}
// feed decoder if needed
bytesRead = -1;
while (err == MPG123_NEED_MORE && bytesRead != 0)
{
int32 inBytes = DECODER_INPUT_SIZE;
if (!pIn)
{
pIn = new unsigned char[inBytes];
}
bytesRead = mrStream.ReadUInt8(pIn, inBytes);
err = mpg123_decode(mpPrivate->mpHandle, pIn, bytesRead, NULL, 0, &outBytesDone);
}
if (err != MPG123_OK && err != MPG123_DONE)
{
NGL_LOG("nuiAudioDecoder", NGL_LOG_INFO, "mpg123 error while decoding: %s", mpg123_strerror(mpPrivate->mpHandle));
}
}
int32 frames = bytesDone / frameSize;
if (format == eSampleFloat32 && BitsPerSample == 16)
{
// convert '16 bits int' samples in pTemp to '32 bits float' samples in pBuffer
int16* pSrc = (int16*)pTemp;
float* pCopy = (float*)( ((int16*)pBuffer) + frames * channels );
float* pFloat = (float*)pBuffer;
// copy int16 data to the second half of the output buffer
// => nuiAudioConvert_16bitsBufferToFloat converts in place
// 'int16' samples atored in the second half of the buffer are converted in 'float' samples filling all the buffer (sizeof(float) == 2 * sizeof(int16))
memcpy(pCopy, pSrc, frames * channels * sizeof(int16));
nuiAudioConvert_16bitsBufferToFloat(pFloat, frames * channels); // convert in place (int16 to float)
}
else if (format == eSampleInt16 && BitsPerSample == 32)
{
// convert '32 bits float' samples in pTemp to '16 bits int' samples in pBuffer
float* pFloat = (float*)pTemp;
int16* pInt16 = (int16*)pBuffer;
nuiAudioConvert_FloatBufferTo16bits(pFloat, pInt16, frames * channels);
}
if (allocated)
{
delete[] pTemp;
}
if (pIn)
{
delete[] pIn;
}
mPosition += frames;
return frames;
}
