//--------------------------------------------------------------
void ofApp::update(){
kinect.update();
if (kinect.isFrameNew()) {
focus.set(kinect.getFocus());
int w = DEPTH_WIDTH;
int h = DEPTH_HEIGHT;
int x, y, offset;
float value, invalid;
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
float dist = kinect.getDistanceAt(x, y);
offset = (y * w + x) * 3;
if(near < dist && dist < far) {
value = ofMap(dist, far, near, 0.0f, 1.0f, true);
invalid = 0.0f;
} else {
value = 0.0f;
invalid = 1.0f;
}
depthPixels[offset ] = value;
depthPixels[offset + 1] = invalid;
depthPixels[offset + 2] = 0.0f;
}
}
depthPixels.mirror(false, !isFlipHorizontal);
depthImage.setFromPixels(depthPixels);
if (isRecording) {
recorder.addFrame(depthPixels);
}
}
if (willStopRecording && recorder.q.size() == 0) {
recorder.stopThread();
willStopRecording = false;
doPostProcessing();
}
// update guide
// guide.clear();
// guide.addVertex(0, 0, 0);
// guide.addVertex()
}
ssize_t AudioALSAPlaybackHandlerNormal::write(const void *buffer, size_t bytes)
{
ALOGV("%s(), buffer = %p, bytes = %d", __FUNCTION__, buffer, bytes);
if (mPcm == NULL)
{
ALOGE("%s(), mPcm == NULL, return", __FUNCTION__);
return bytes;
}
// const -> to non const
void *pBuffer = const_cast<void *>(buffer);
ASSERT(pBuffer != NULL);
#ifdef DEBUG_LATENCY
clock_gettime(CLOCK_REALTIME, &mNewtime);
latencyTime[0] = calc_time_diff(mNewtime, mOldtime);
mOldtime = mNewtime;
#endif
// stereo to mono for speaker
if (mStreamAttributeSource->audio_format == AUDIO_FORMAT_PCM_16_BIT) // AudioMixer will perform stereo to mono when 32-bit
{
doStereoToMonoConversionIfNeed(pBuffer, bytes);
}
// post processing (can handle both Q1P16 and Q1P31 by audio_format_t)
void *pBufferAfterPostProcessing = NULL;
uint32_t bytesAfterPostProcessing = 0;
doPostProcessing(pBuffer, bytes, &pBufferAfterPostProcessing, &bytesAfterPostProcessing);
// SRC
void *pBufferAfterBliSrc = NULL;
uint32_t bytesAfterBliSrc = 0;
doBliSrc(pBufferAfterPostProcessing, bytesAfterPostProcessing, &pBufferAfterBliSrc, &bytesAfterBliSrc);
// bit conversion
void *pBufferAfterBitConvertion = NULL;
uint32_t bytesAfterBitConvertion = 0;
doBitConversion(pBufferAfterBliSrc, bytesAfterBliSrc, &pBufferAfterBitConvertion, &bytesAfterBitConvertion);
// data pending
void *pBufferAfterPending = NULL;
uint32_t bytesAfterpending = 0;
dodataPending(pBufferAfterBitConvertion, bytesAfterBitConvertion, &pBufferAfterPending, &bytesAfterpending);
// pcm dump
WritePcmDumpData(pBufferAfterPending, bytesAfterpending);
#ifdef DEBUG_LATENCY
clock_gettime(CLOCK_REALTIME, &mNewtime);
latencyTime[1] = calc_time_diff(mNewtime, mOldtime);
mOldtime = mNewtime;
#endif
// write data to pcm driver
int retval = pcm_write(mPcm, pBufferAfterPending, bytesAfterpending);
#ifdef DEBUG_LATENCY
clock_gettime(CLOCK_REALTIME, &mNewtime);
latencyTime[2] = calc_time_diff(mNewtime, mOldtime);
mOldtime = mNewtime;
#endif
#if 1 // TODO(Harvey, Wendy), temporary disable Voice Unlock until 24bit ready
//============Voice UI&Unlock REFERECE=============
AudioVUnlockDL *VUnlockhdl = AudioVUnlockDL::getInstance();
if (VUnlockhdl != NULL)
{
// get remain time
//VUnlockhdl->SetDownlinkStartTime(ret_ms);
VUnlockhdl->GetFirstDLTime();
//VUnlockhdl->SetInputStandBy(false);
if (mStreamAttributeSource->output_devices & AUDIO_DEVICE_OUT_WIRED_HEADSET ||
mStreamAttributeSource->output_devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE)
{
memset((void *)pBufferAfterBitConvertion, 0, bytesAfterBitConvertion);
}
VUnlockhdl->WriteStreamOutToRing(pBufferAfterBitConvertion, bytesAfterBitConvertion);
}
//===========================================
#endif
if (retval != 0)
{
ALOGE("%s(), pcm_write() error, retval = %d", __FUNCTION__, retval);
}
#ifdef DEBUG_LATENCY
ALOGD("AudioALSAPlaybackHandlerNormal::write (-) latency_in_us,%1.6lf,%1.6lf,%1.6lf", latencyTime[0], latencyTime[1], latencyTime[2]);
#endif
return bytes;
}
ssize_t AudioALSAPlaybackHandlerSphDL::write(const void *buffer, size_t bytes)
{
ALOGV("%s(), buffer = %p, bytes = %d", __FUNCTION__, buffer, bytes);
if (mPcm == NULL)
{
ALOGE("%s(), mPcm == NULL, return", __FUNCTION__);
return bytes;
}
// const -> to non const
void *pBuffer = const_cast<void *>(buffer);
ASSERT(pBuffer != NULL);
#ifdef DEBUG_LATENCY
clock_gettime(CLOCK_REALTIME, &mNewtime);
latencyTime[0] = calc_time_diff(mNewtime, mOldtime);
mOldtime = mNewtime;
#endif
// stereo to mono for speaker
if (mStreamAttributeSource->audio_format == AUDIO_FORMAT_PCM_16_BIT) // AudioMixer will perform stereo to mono when 32-bit
{
doStereoToMonoConversionIfNeed(pBuffer, bytes);
}
// post processing (can handle both Q1P16 and Q1P31 by audio_format_t)
void *pBufferAfterPostProcessing = NULL;
uint32_t bytesAfterPostProcessing = 0;
doPostProcessing(pBuffer, bytes, &pBufferAfterPostProcessing, &bytesAfterPostProcessing);
// SRC
void *pBufferAfterBliSrc = NULL;
uint32_t bytesAfterBliSrc = 0;
doBliSrc(pBufferAfterPostProcessing, bytesAfterPostProcessing, &pBufferAfterBliSrc, &bytesAfterBliSrc);
// bit conversion
void *pBufferAfterBitConvertion = NULL;
uint32_t bytesAfterBitConvertion = 0;
doBitConversion(pBufferAfterBliSrc, bytesAfterBliSrc, &pBufferAfterBitConvertion, &bytesAfterBitConvertion);
// pcm dump
WritePcmDumpData(pBufferAfterBitConvertion, bytesAfterBitConvertion);
#ifdef DEBUG_LATENCY
clock_gettime(CLOCK_REALTIME, &mNewtime);
latencyTime[1] = calc_time_diff(mNewtime, mOldtime);
mOldtime = mNewtime;
#endif
// write data to pcm driver
int retval = pcm_write(mPcm, pBufferAfterBitConvertion, bytesAfterBitConvertion);
#ifdef DEBUG_LATENCY
clock_gettime(CLOCK_REALTIME, &mNewtime);
latencyTime[2] = calc_time_diff(mNewtime, mOldtime);
mOldtime = mNewtime;
#endif
if (retval != 0)
{
ALOGE("%s(), pcm_write() error, retval = %d", __FUNCTION__, retval);
}
#ifdef DEBUG_LATENCY
ALOGD("AudioALSAPlaybackHandlerSphDL::write (-) latency_in_us,%1.6lf,%1.6lf,%1.6lf", latencyTime[0], latencyTime[1], latencyTime[2]);
#endif
return bytes;
}
int AudioALSAPlaybackHandlerOffload::process_write()
{
while(1)
{
int32_t consumed;
if(mDecBsbufRemain < mDecHandler->BsbufferSize() && mDecPcmbufRemain < mWritebytes)
return OFFLOAD_WRITE_EMPTY;
if(mDecPcmbufRemain >= mWritebytes)
{
memcpy(offload_stream.tmpBuffer, mDecPcmbuf, mWritebytes);
mDecPcmbufRemain -= mWritebytes;
memmove(mDecPcmbuf, mDecPcmbuf+mWritebytes, mDecPcmbufRemain);
// stereo to mono for speaker
if (mStreamAttributeSource->audio_format == AUDIO_FORMAT_PCM_16_BIT) // AudioMixer will perform stereo to mono when 32-bit
{
doStereoToMonoConversionIfNeed(offload_stream.tmpBuffer, mWritebytes);
}
// post processing (can handle both Q1P16 and Q1P31 by audio_format_t)
void *pBufferAfterPostProcessing = NULL;
uint32_t bytesAfterPostProcessing = 0;
doPostProcessing(offload_stream.tmpBuffer, mWritebytes, &pBufferAfterPostProcessing, &bytesAfterPostProcessing);
// SRC
void *pBufferAfterBliSrc = NULL;
uint32_t bytesAfterBliSrc = 0;
doBliSrc(pBufferAfterPostProcessing, bytesAfterPostProcessing, &pBufferAfterBliSrc, &bytesAfterBliSrc);
// bit conversion
void *pBufferAfterBitConvertion = NULL;
uint32_t bytesAfterBitConvertion = 0;
doBitConversion(pBufferAfterBliSrc, bytesAfterBliSrc, &pBufferAfterBitConvertion, &bytesAfterBitConvertion);
int *ptr32;
int ptr32_temp, ptr32_cnt;
ptr32 = (int*)pBufferAfterBitConvertion;
#if 0
for(ptr32_cnt = 0; ptr32_cnt<(bytesAfterBitConvertion>>2); ptr32_cnt++)
{
ptr32_temp = *ptr32;
*ptr32 = ptr32_temp<<8;
*ptr32++;
}
#endif
// data pending
void *pBufferAfterPending = NULL;
uint32_t bytesAfterpending = 0;
dodataPending(pBufferAfterBitConvertion, bytesAfterBitConvertion, &pBufferAfterPending, &bytesAfterpending);
// pcm dump
WritePcmDumpData(pBufferAfterPending, bytesAfterpending);
//int retval = compress_write(mComprStream, offload_stream.tmpBuffer, mWritebytes);
int retval = compress_write(mComprStream, pBufferAfterPending, bytesAfterpending);
if (retval < 0)
{
ALOGE("%s(), compress_write() error, retval = %d, %s", __FUNCTION__, retval, compress_get_error(mComprStream));
}
else
{
if(!mReady)
{
mReady = true;
if( offload_stream.offload_state == OFFLOAD_STATE_IDLE)
offload_stream.offload_state = OFFLOAD_STATE_PLAYING;
compress_nonblock(mComprStream, 1);
compress_start(mComprStream);
}
}
#if 0
if( compress_blockwrite(mComprStream) != 0)
ALOGE("%s(), compress_blockwrite() error= %s", __FUNCTION__, compress_get_error(mComprStream));
#endif
return OFFLOAD_WRITE_REMAIN;
}
ALOGV("%s(),Decode+ %x, %x ", __FUNCTION__, mDecBsbufRemain, mDecPcmbufRemain);
if(mDecBsbufRemain >= mDecHandler->BsbufferSize())
consumed = mDecHandler->DecodeAudio( mDecBsbuf, mDecPcmbuf+mDecPcmbufRemain, mDecBsbufRemain);
if(consumed < 0)
{
ALOGD("%s(), Decoder return error:%x", __FUNCTION__, consumed);
}
else
{
mDecBsbufRemain -= consumed;
memmove(mDecBsbuf, mDecBsbuf + consumed, mDecBsbufRemain);
mDecPcmbufRemain += mDecHandler->PcmbufferSize();
}
ALOGD("%s(),Decode- %x, %x", __FUNCTION__, mDecBsbufRemain, mDecPcmbufRemain);
}
