/**
* @fn int check_lifelimit(struct CONN_BCAP_SERVER *parent)
* @brief Checks the life limit all of child nodes, and if expired then deletes.
* @param[in] parent The server object.
*/
static int
check_lifelimit(struct CONN_BCAP_SERVER *parent)
{
uint32_t cur, diff;
struct CONN_BCAP_SERVER *child, *tmp;
child = parent->node1;
while(child != NULL) {
tmp = child->node2;
cur = gettimeofday_msec();
diff = calc_time_diff(child->last_modified, cur);
if(diff > UDP_LIFELIMIT) {
change_relation(child, DESTROY_SELF, NULL);
}
child = tmp;
}
change_relation(parent, DELETE_CHILD, NULL);
return parent->num_child;
}
/**
* @fn HRESULT receive_execute(struct CONN_BCAP_SERVER *bcap_param)
* @brief Receives the b-CAP packet and executes callback functions.
* @param[in,out] bcap_param b-CAP communication object.
*/
static HRESULT
receive_execute(struct CONN_BCAP_SERVER *bcap_param)
{
int index;
int32_t relation_id;
uint16_t i, clear_flag = 1;
uint32_t cur, start, diff;
HRESULT hr;
struct CONN_BCAP_SERVER *tmp_param = bcap_param;
struct CONN_PARAM_COMMON *device = &bcap_param->device;
struct BCAP_PACKET tmp_send_packet, tmp_recv_packet, *send_packet =
&bcap_param->last_send, *recv_packet = &bcap_param->last_recv;
struct VEC_OBJECT *pObj = NULL;
BSTR bstrOpt = NULL;
VARIANT vntTmp, vntOpt;
VariantInit(&vntTmp);
VariantInit(&vntOpt);
/* Initializes temporary packet */
tmp_recv_packet.argc = (uint16_t) -1;
tmp_recv_packet.args = NULL;
/* Receives b-CAP packet */
hr = bcap_recv(device, &tmp_recv_packet, 0);
if(SUCCEEDED(hr)) {
/* Sets S_EXECUTING packet */
memset(&tmp_send_packet, 0, sizeof(struct BCAP_PACKET));
tmp_send_packet.serial = tmp_recv_packet.serial;
tmp_send_packet.id = S_EXECUTING;
/* Checks retry packet */
switch(device->type) {
case CONN_UDP:
tmp_param = search_node(bcap_param, device->arg,
sizeof(struct sockaddr_in));
if(tmp_param == NULL) {
/* Checks life limit */
if((bcap_param->num_child >= BCAP_CLIENT_MAX)
&& (check_lifelimit(bcap_param) >= BCAP_CLIENT_MAX))
{
tmp_send_packet.id = E_MAX_CONNECT;
bcap_send(device, &tmp_send_packet);
hr = S_FALSE;
goto exit_proc;
}
/* Adds child */
change_relation(bcap_param, ADD_CHILD, &device->sock);
tmp_param = bcap_param->node1;
}
send_packet = &tmp_param->last_send;
//break;
case CONN_COM:
/* Sets retry count */
tmp_recv_packet.reserv =
(tmp_recv_packet.reserv == 0) ?
tmp_recv_packet.serial : tmp_recv_packet.reserv;
/* If already responded, then does not execute */
if(send_packet->serial == tmp_recv_packet.reserv) {
/* Copies last send packet */
tmp_send_packet = *send_packet;
/* Sets new serial number */
tmp_send_packet.serial = tmp_recv_packet.serial;
/* Sends temporary send packet */
bcap_send(device, &tmp_send_packet);
hr = S_FALSE;
goto exit_proc;
}
break;
default:
break;
}
/* Checks execute thread */
hr = wait_event(&bcap_param->comp_evt, 0);
if(hr == E_TIMEOUT) {
/* Sends result busy process */
tmp_send_packet.id = E_BUSY_PROC;
bcap_send(device, &tmp_send_packet);
goto exit_proc;
}
switch(tmp_recv_packet.id) {
case ID_SERVICE_START:
case ID_CONTROLLER_CONNECT:
case ID_CONTROLLER_GETEXTENSION:
case ID_CONTROLLER_GETFILE:
case ID_FILE_GETFILE:
case ID_CONTROLLER_GETROBOT:
case ID_CONTROLLER_GETTASK:
case ID_CONTROLLER_GETVARIABLE:
case ID_EXTENSION_GETVARIABLE:
case ID_FILE_GETVARIABLE:
case ID_ROBOT_GETVARIABLE:
case ID_TASK_GETVARIABLE:
case ID_CONTROLLER_GETCOMMAND:
case ID_CONTROLLER_GETMESSAGE:
if(bcap_param->num_object >= BCAP_OBJECT_MAX) {
tmp_send_packet.id = E_MAX_OBJECT;
bcap_send(device, &tmp_send_packet);
hr = S_FALSE;
goto exit_proc;
}
if(tmp_recv_packet.id == ID_SERVICE_START) {
if((tmp_recv_packet.argc >= 1) && (tmp_recv_packet.args != NULL)) {
VariantCopy(&vntTmp, &tmp_recv_packet.args[0]);
hr = VariantChangeType(&vntTmp, &vntTmp, 0, VT_BSTR);
if(FAILED(hr)) {
tmp_send_packet.id = hr;
bcap_send(device, &tmp_send_packet);
hr = S_FALSE;
goto exit_proc;
}
} else {
vntTmp.vt = VT_BSTR;
vntTmp.bstrVal = SysAllocString(L"");
}
bstrOpt = SysAllocString(L"WDT");
hr = GetOptionValue(vntTmp.bstrVal, bstrOpt, VT_UI4, &vntOpt);
vntOpt.ulVal =
(vntOpt.vt == VT_UI4) ? vntOpt.ulVal : INIT_WDT_INTERVAL;
if(vntOpt.ulVal < MIN_WDT_INTERVAL) {
tmp_send_packet.id = E_INVALIDARG;
bcap_send(device, &tmp_send_packet);
hr = S_FALSE;
goto exit_proc;
} else {
tmp_param->wdt_interval = vntOpt.ulVal;
}
SysFreeString(bstrOpt);
VariantClear(&vntOpt);
bstrOpt = SysAllocString(L"InvokeTimeout");
hr = GetOptionValue(vntTmp.bstrVal, bstrOpt, VT_UI4, &vntOpt);
vntOpt.ulVal =
(vntOpt.vt == VT_UI4) ? vntOpt.ulVal : INIT_EXEC_TIMEOUT;
if(vntOpt.ulVal < MIN_WDT_INTERVAL) {
tmp_send_packet.id = E_INVALIDARG;
bcap_send(device, &tmp_send_packet);
hr = S_FALSE;
goto exit_proc;
} else {
tmp_param->exec_timeout = vntOpt.ulVal;
}
SysFreeString(bstrOpt);
VariantClear(&vntOpt);
VariantClear(&vntTmp);
bstrOpt = NULL;
}
break;
default:
break;
}
/* Resets last received packet */
if(recv_packet->args != NULL) {
for(i = 0; i < recv_packet->argc; i++) {
VariantClear(&recv_packet->args[i]);
}
free(recv_packet->args);
}
/* Copies to last receive packet */
clear_flag = 0;
*recv_packet = tmp_recv_packet;
/* Runs execute thread */
reset_event(&bcap_param->comp_evt);
set_event(&bcap_param->exec_evt);
if(SUCCEEDED(hr)) {
start = gettimeofday_msec();
while(1) {
hr = wait_event(&bcap_param->comp_evt, tmp_param->wdt_interval);
if(SUCCEEDED(hr)) {
break;
} else {
/* Sends S_EXECUTING packet */
hr = bcap_send(device, &tmp_send_packet);
if(FAILED(hr)) {
break;
}
}
/* Checks executing timeout */
cur = gettimeofday_msec();
diff = calc_time_diff(start, cur);
if(diff > tmp_param->exec_timeout) {
hr = E_TIMEOUT;
break;
}
}
}
}
exit_proc:
if(hr == S_OK) {
if(bcap_param->last_send.id == S_OK) {
/* Changes the vector of created objects */
relation_id = m_map_id[recv_packet->id].relation_id;
if(relation_id > 0) { // Push
pObj = (struct VEC_OBJECT *) malloc(sizeof(struct VEC_OBJECT));
if(pObj != NULL) {
memset(pObj, 0, sizeof(struct VEC_OBJECT));
pObj->id = relation_id;
pObj->hObj =
(recv_packet->id == ID_SERVICE_START) ?
0 : bcap_param->last_send.args[0].lVal;
push_vector(bcap_param, pObj);
}
}
else if(relation_id < 0) { // Pop
index = search_vector(bcap_param, recv_packet->id,
(recv_packet->id == ID_SERVICE_STOP) ?
0 : recv_packet->args[0].lVal);
if(index >= 0) {
pop_vector(bcap_param, &pObj, index);
free(pObj);
}
if((device->type == CONN_UDP)
&& (recv_packet->id == ID_SERVICE_STOP))
{
change_relation(tmp_param, DESTROY_SELF, NULL);
change_relation(bcap_param, DELETE_CHILD, NULL);
tmp_param = NULL;
}
}
}
/* Responds the result message */
hr = bcap_send(device, &bcap_param->last_send);
if(SUCCEEDED(hr) && (tmp_param != NULL)) {
tmp_param->last_send.serial = bcap_param->last_send.serial;
tmp_param->last_send.reserv = bcap_param->last_send.reserv;
tmp_param->last_send.id = bcap_param->last_send.id;
tmp_param->last_send.argc = bcap_param->last_send.argc;
VariantCopy(tmp_param->last_send.args, bcap_param->last_send.args);
tmp_param->last_modified = gettimeofday_msec();
}
}
/* Clears temporary packet */
if(clear_flag) {
if(tmp_recv_packet.args != NULL) {
for(i = 0; i < tmp_recv_packet.argc; i++) {
VariantClear(&tmp_recv_packet.args[i]);
}
free(tmp_recv_packet.args);
}
}
VariantClear(&vntTmp);
VariantClear(&vntOpt);
if(bstrOpt) {
SysFreeString(bstrOpt);
}
return hr;
}
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;
}
void *AudioALSACaptureDataProviderEchoRefExt::readThread(void *arg)
{
status_t retval = NO_ERROR;
AudioALSACaptureDataProviderEchoRefExt *pDataProvider = static_cast<AudioALSACaptureDataProviderEchoRefExt *>(arg);
uint32_t open_index = pDataProvider->mOpenIndex;
char nameset[32];
sprintf(nameset, "%s%d", __FUNCTION__, pDataProvider->mCaptureDataProviderType);
prctl(PR_SET_NAME, (unsigned long)nameset, 0, 0, 0);
#ifdef MTK_AUDIO_ADJUST_PRIORITY
// force to set priority
struct sched_param sched_p;
sched_getparam(0, &sched_p);
sched_p.sched_priority = RTPM_PRIO_AUDIO_RECORD + 5;
if (0 != sched_setscheduler(0, SCHED_RR, &sched_p))
{
ALOGE("[%s] failed, errno: %d", __FUNCTION__, errno);
}
else
{
sched_p.sched_priority = RTPM_PRIO_AUDIO_RECORD + 5;
sched_getparam(0, &sched_p);
ALOGD("sched_setscheduler ok, priority: %d", sched_p.sched_priority);
}
#endif
ALOGD("+%s(), pid: %d, tid: %d, kReadBufferSize=%x", __FUNCTION__, getpid(), gettid(), kReadBufferSize);
// read raw data from alsa driver
char linear_buffer[kReadBufferSize];
while (pDataProvider->mEnable == true)
{
if (open_index != pDataProvider->mOpenIndex)
{
ALOGD("%s(), open_index(%d) != mOpenIndex(%d), return", __FUNCTION__, open_index, pDataProvider->mOpenIndex);
break;
}
retval = pDataProvider->mEnableLock.lock_timeout(300);
ASSERT(retval == NO_ERROR);
if (pDataProvider->mEnable == false)
{
pDataProvider->mEnableLock.unlock();
break;
}
ASSERT(pDataProvider->mPcm != NULL);
clock_gettime(CLOCK_REALTIME, &pDataProvider->mNewtime);
pDataProvider->timerec[0] = calc_time_diff(pDataProvider->mNewtime, pDataProvider->mOldtime);
pDataProvider->mOldtime = pDataProvider->mNewtime;
int retval = pcm_read(pDataProvider->mPcm, linear_buffer, kReadBufferSize);
if (retval != 0)
{
ALOGE("%s(), pcm_read() error, retval = %d", __FUNCTION__, retval);
}
clock_gettime(CLOCK_REALTIME, &pDataProvider->mNewtime);
pDataProvider->timerec[1] = calc_time_diff(pDataProvider->mNewtime, pDataProvider->mOldtime);
pDataProvider->mOldtime = pDataProvider->mNewtime;
pDataProvider->GetCaptureTimeStamp(&pDataProvider->mStreamAttributeSource.Time_Info, kReadBufferSize);
// use ringbuf format to save buffer info
pDataProvider->mPcmReadBuf.pBufBase = linear_buffer;
pDataProvider->mPcmReadBuf.bufLen = kReadBufferSize + 1; // +1: avoid pRead == pWrite
pDataProvider->mPcmReadBuf.pRead = linear_buffer;
pDataProvider->mPcmReadBuf.pWrite = linear_buffer + kReadBufferSize;
pDataProvider->mEnableLock.unlock();
//Provide EchoRef data
#if 0 //for check the echoref data got
pDataProvider->provideCaptureDataToAllClients(open_index);
#else
pDataProvider->provideEchoRefCaptureDataToAllClients(open_index);
#endif
clock_gettime(CLOCK_REALTIME, &pDataProvider->mNewtime);
pDataProvider->timerec[2] = calc_time_diff(pDataProvider->mNewtime, pDataProvider->mOldtime);
pDataProvider->mOldtime = pDataProvider->mNewtime;
ALOGD("%s, latency_in_us,%1.6lf,%1.6lf,%1.6lf", __FUNCTION__, pDataProvider->timerec[0], pDataProvider->timerec[1], pDataProvider->timerec[2]);
}
ALOGD("-%s(), pid: %d, tid: %d", __FUNCTION__, getpid(), gettid());
pthread_exit(NULL);
return NULL;
}
void *AudioALSACaptureDataProviderNormal::readThread(void *arg)
{
status_t retval = NO_ERROR;
AudioALSACaptureDataProviderNormal *pDataProvider = static_cast<AudioALSACaptureDataProviderNormal *>(arg);
uint32_t open_index = pDataProvider->mOpenIndex;
char nameset[32];
sprintf(nameset, "%s%d", __FUNCTION__, pDataProvider->mCaptureDataProviderType);
prctl(PR_SET_NAME, (unsigned long)nameset, 0, 0, 0);
#ifdef MTK_AUDIO_ADJUST_PRIORITY
// force to set priority
struct sched_param sched_p;
sched_getparam(0, &sched_p);
sched_p.sched_priority = RTPM_PRIO_AUDIO_RECORD + 1;
if (0 != sched_setscheduler(0, SCHED_RR, &sched_p))
{
ALOGE("[%s] failed, errno: %d", __FUNCTION__, errno);
}
else
{
sched_p.sched_priority = RTPM_PRIO_AUDIO_RECORD + 1;
sched_getparam(0, &sched_p);
ALOGD("sched_setscheduler ok, priority: %d", sched_p.sched_priority);
}
#endif
ALOGD("+%s(), pid: %d, tid: %d, kReadBufferSize=%x, open_index=%d", __FUNCTION__, getpid(), gettid(), kReadBufferSize, open_index);
// read raw data from alsa driver
char linear_buffer[kReadBufferSize];
uint32_t Read_Size = kReadBufferSize;
uint32_t kReadBufferSize_new;
while (pDataProvider->mEnable == true)
{
if (open_index != pDataProvider->mOpenIndex)
{
ALOGD("%s(), open_index(%d) != mOpenIndex(%d), return", __FUNCTION__, open_index, pDataProvider->mOpenIndex);
break;
}
retval = pDataProvider->mEnableLock.lock_timeout(300);
ASSERT(retval == NO_ERROR);
if (pDataProvider->mEnable == false)
{
pDataProvider->mEnableLock.unlock();
break;
}
ASSERT(pDataProvider->mPcm != NULL);
clock_gettime(CLOCK_REALTIME, &pDataProvider->mNewtime);
pDataProvider->timerec[0] = calc_time_diff(pDataProvider->mNewtime, pDataProvider->mOldtime);
pDataProvider->mOldtime = pDataProvider->mNewtime;
if (pDataProvider->mCaptureDropSize > 0)
{
Read_Size = (pDataProvider->mCaptureDropSize > kReadBufferSize) ? kReadBufferSize : pDataProvider->mCaptureDropSize;
int retval = pcm_read(pDataProvider->mPcm, linear_buffer, Read_Size);
if (retval != 0)
{
ALOGE("%s(), pcm_read() drop error, retval = %d", __FUNCTION__, retval);
}
ALOGD("%s(), mCaptureDropSize = %d, Read_Size=%d", __FUNCTION__, pDataProvider->mCaptureDropSize, Read_Size);
pDataProvider->mCaptureDropSize -= Read_Size;
pDataProvider->mEnableLock.unlock();
continue;
}
else
{
int retval = pcm_read(pDataProvider->mPcm, linear_buffer, kReadBufferSize);
if (retval != 0)
{
ALOGE("%s(), pcm_read() error, retval = %d", __FUNCTION__, retval);
}
}
clock_gettime(CLOCK_REALTIME, &pDataProvider->mNewtime);
pDataProvider->timerec[1] = calc_time_diff(pDataProvider->mNewtime, pDataProvider->mOldtime);
pDataProvider->mOldtime = pDataProvider->mNewtime;
//struct timespec tempTimeStamp;
pDataProvider->GetCaptureTimeStamp(&pDataProvider->mStreamAttributeSource.Time_Info, kReadBufferSize);
#ifdef RECORD_INPUT_24BITS // 24bit record
uint32_t *ptr32bit_r = (uint32_t *)linear_buffer;
int16_t *ptr16bit_w = (int16_t *)linear_buffer;
int i;
ALOGV("24bit record, kReadBufferSize=%d, init ptr32bit_r=0x%x, ptr16bit_w =0x%x", kReadBufferSize, ptr32bit_r, ptr16bit_w);
for (i = 0; i < kReadBufferSize / 4; i++)
{
*(ptr16bit_w + i) = (int16_t)(*(ptr32bit_r + i) >> 8);
}
kReadBufferSize_new = kReadBufferSize >> 1;
#else
kReadBufferSize_new = kReadBufferSize;
#endif
#ifdef MTK_VOW_SUPPORT
//copy data to DC Cal
pDataProvider->copyCaptureDataToDCCalBuffer(linear_buffer, kReadBufferSize_new);
#endif
// use ringbuf format to save buffer info
pDataProvider->mPcmReadBuf.pBufBase = linear_buffer;
pDataProvider->mPcmReadBuf.bufLen = kReadBufferSize_new + 1; // +1: avoid pRead == pWrite
pDataProvider->mPcmReadBuf.pRead = linear_buffer;
pDataProvider->mPcmReadBuf.pWrite = linear_buffer + kReadBufferSize_new;
pDataProvider->mEnableLock.unlock();
pDataProvider->provideCaptureDataToAllClients(open_index);
clock_gettime(CLOCK_REALTIME, &pDataProvider->mNewtime);
pDataProvider->timerec[2] = calc_time_diff(pDataProvider->mNewtime, pDataProvider->mOldtime);
pDataProvider->mOldtime = pDataProvider->mNewtime;
ALOGD("%s, latency_in_us,%1.6lf,%1.6lf,%1.6lf", __FUNCTION__, pDataProvider->timerec[0], pDataProvider->timerec[1], pDataProvider->timerec[2]);
}
ALOGD("-%s(), pid: %d, tid: %d", __FUNCTION__, getpid(), gettid());
pthread_exit(NULL);
return NULL;
}
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;
}
static int
add_initial_data(const struct kmr_kv_box kv,
const KMR_KVS *kvi, KMR_KVS *kvo, void *p, long i_)
{
common_t *common = (common_t *)p;
char filename[FILENAME_LEN];
create_file(common->rank, common->iteration, common->file_size,
filename, FILENAME_LEN);
common->val_count = IO_COUNT * common->file_size;
struct kmr_kv_box nkv = { .klen = sizeof(char) * (strlen(common->key) + 1),
.k.p = common->key,
.vlen = sizeof(char) * (strlen(filename) + 1),
.v.p = (void *)filename };
kmr_add_kv(kvo, nkv);
return MPI_SUCCESS;
}
static int
increment_in_file_value(const struct kmr_kv_box kv,
const KMR_KVS *kvi, KMR_KVS *kvo, void *p, long i_)
{
common_t *common = (common_t *)p;
char *infile = (char *)kv.v.p;
char outfile[FILENAME_LEN];
snprintf(outfile, FILENAME_LEN, "./%06d-%02d.dat", common->rank,
common->iteration + 1);
FILE *ifp = fopen(infile, "r");
FILE *ofp = fopen(outfile, "w+");
assert(ifp != 0 && ofp != 0);
/* read/write 1MB at once */
long *buf = (long *)malloc(sizeof(long) * IO_COUNT);
for (int i = 0; i < common->file_size; i++) {
size_t cc = fread(buf, sizeof(long), IO_COUNT, ifp);
assert(cc == IO_COUNT);
for (int j = 0; j < IO_COUNT; j++) {
buf[j] += 1;
}
cc = fwrite(buf, sizeof(long), IO_COUNT, ofp);
assert(cc == IO_COUNT);
}
free(buf);
fclose(ofp);
struct kmr_kv_box nkv = { .klen = sizeof(char) * (strlen(common->key) + 1),
.k.p = common->key,
.vlen = sizeof(char) * (strlen(outfile) + 1),
.v.p = (void *)outfile };
kmr_add_kv(kvo, nkv);
#ifdef DEBUG
fseek(ifp, 0, SEEK_SET);
long val;
fread(&val, sizeof(long), 1, ifp);
fprintf(stderr, "Rank[%d]: process key[%s]-val[%ld]\n",
common->rank, (char *)kv.k.p, val);
#endif
fclose(ifp);
delete_file(common->rank, common->iteration);
return MPI_SUCCESS;
}
int
main(int argc, char **argv)
{
int thlv;
MPI_Init_thread(&argc, &argv, MPI_THREAD_SERIALIZED, &thlv);
int nprocs, rank, task_nprocs;
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
check_nprocs(nprocs, rank, &task_nprocs);
kmr_init();
KMR *mr = kmr_create_context(MPI_COMM_WORLD, MPI_INFO_NULL, 0);
mr->verbosity = 5;
mr->trace_map_mp = 1;
char even_key[KEY_LEN];
char odd_key[KEY_LEN];
snprintf(even_key, KEY_LEN, "even%06d", (rank / task_nprocs + 1));
snprintf(odd_key, KEY_LEN, "odd%06d", (rank % task_nprocs + 1));
common_t common0;
common0.key = even_key;
parse_param_file(argc, argv, &(common0.file_size));
common0.rank = rank;
common0.iteration = 0;
KMR_KVS *kvs0 = kmr_create_kvs(mr, KMR_KV_OPAQUE, KMR_KV_OPAQUE);
kmr_map_once(kvs0, &common0, kmr_noopt, 0, add_initial_data);
double itr_times[ITERATIONS];
for (int i = 0; i < ITERATIONS; i++) {
common0.key = (i % 2 == 0)? odd_key : even_key;
common0.iteration = i;
KMR_KVS *kvs1 = kmr_create_kvs(mr, KMR_KV_OPAQUE, KMR_KV_OPAQUE);
struct timeval ts;
measure_time(&ts);
kmr_map_multiprocess_by_key(kvs0, kvs1, &common0, kmr_noopt, rank,
increment_in_file_value);
struct timeval te;
measure_time(&te);
itr_times[i] = calc_time_diff(&ts, &te);
kvs0 = kvs1;
}
kmr_free_kvs(kvs0);
delete_file(common0.rank, common0.iteration + 1);
print_time(itr_times, ITERATIONS, rank);
kmr_free_context(mr);
kmr_fin();
MPI_Finalize();
return 0;
}
static int uvvp_vdec_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret=0;
int i, j;
//int recv_buf[256];
//int send_buf[256];
//int num = 0;
// For UVVP_VDEC_TEST_VERSION_1
int reg_in = 0;
int reg_out = 0;
// For UVVP_VDEC_TEST_VERSION_2
int mem_sz = 1;
UCHAR *p = NULL;
unsigned int u4Align = 1024;
unsigned int u4Size = 16384;
unsigned char *buf_data;
unsigned char *buf_data2;
UINT32 u4RetValue;
// For UVVP_VDEC_TEST_VERSION_3
struct termios settings;
struct file *fd = 0;
mm_segment_t oldfs;
unsigned long crc = 0;
unsigned long own_crc = 0;
int frame_start = 0;
int frame_end= 0;
int file_num = 0;
int file_len = 0;
int read_len = 0;
int tmp_buf[256];
// For speed measurement
struct timeval tv1;
struct timeval tv2;
//struct file * pfilename;
VDEC_PARAM_T *param;
#if (VDEC_MVC_SUPPORT)
VDEC_PARAM_T *param1;
#endif
printk("\r\n******** uvvp_vdec_ioctl cmd[%d]********\r\n",cmd);
param = kmalloc(sizeof(VDEC_PARAM_T), GFP_KERNEL);
#if (VDEC_MVC_SUPPORT)
param1 = kmalloc(sizeof(VDEC_PARAM_T), GFP_KERNEL);
#endif
switch (cmd) {
// General TEST CASE
case UVVP_VDEC_TEST_VERSION:
param->u4InstanceId = 0;
param->u4Mode = 0;
#if (VDEC_MVC_SUPPORT)
param->fgMVCType = TRUE;
#else
param->fgMVCType = FALSE;
#endif
printk("\r\n******** uvvp_vdec_ioctl UVVP_VDEC_TEST_VERSION ********\r\n");
#if VDEC_VP8_WEBP_SUPPORT_ME2_INTEGRATION
vVDecVerifyThread(param);
vVerInitVDec(0);
vVParserProc(0);
vVDecProc(0);
#if VP8_MB_ROW_MODE_SUPPORT_ME2_INTEGRATION
while(1)
{
u4RetValue = vVerVP8DecEndProc_MB_ROW_START(0);
if (u4RetValue == vVerResult_MB_ROW_DONE)
{
printk("\n\n======== MB ROW DONE!! ========\n\n");
}
else if(u4RetValue == vVerResult_FRAME_DONE)
{
printk("\n\n======== FRAME DONE!! ========\n\n");
break;
}
else
{
printk("\n\n[ERROR]======== decode timeout!! ========\n\n");
break;
}
}
vChkVDec_Webp_Row_Mode(0);
#else
vChkVDec(0);
#endif
#ifdef PCFILE_WRITE
if(_tInFileInfo[param->u4InstanceId].pFile)
{
fclose(_tInFileInfo[param->u4InstanceId].pFile);
}
#endif
vVerifyVDecIsrStop(param->u4InstanceId);
vMemoryFree(param->u4InstanceId);
#ifdef SATA_HDD_READ_SUPPORT
#ifdef SATA_HDD_FS_SUPPORT
if (_tFileListInfo[param->u4InstanceId].i4FileId != 0xFFFFFFFF)
{
// fgHDDFsCloseFile(u4InstID); // temp avoid system crash
_tFileListInfo[param->u4InstanceId].i4FileId = 0xFFFFFFFF;
}
//FS mount
fgHDDFsUnMount(0);
#endif
#endif
#else
MPV_thread = kthread_run(vVDecVerifyThread, param, "rt8192cu_rtw_xmit_thread");
if (IS_ERR(MPV_thread)) {
printk("[%s]: failed to create MPV thread\n", __FUNCTION__);
return 0;
}
else
{
printk("Creat mpv0 thread ok!\n");
}
// break;
// case UVVP_VDEC_TEST_VERSION_1:
#if (VDEC_MVC_SUPPORT)
param1->u4InstanceId = 1;
param1->u4Mode = 0;
param1->fgMVCType = TRUE;
msleep(2);
MPV_thread = kthread_run(vVDecVerifyThread, param1, "rt8192cu_rtw_xmit_thread");
if (IS_ERR(MPV_thread)) {
printk("[%s]: failed to create MPV thread\n", __FUNCTION__);
return 0;
}
else
{
printk("Creat mpv1 thread ok!\n");
}
#endif
#endif
break;
case UVVP_VDEC_TEST_VERSION_1:
printk("UVVP_VDEC_TEST_VERSION_1\n");
reg_in = 0x1;
reg_out = 0;
MFV_HW_WRITE(VDEC_GCON_BASE, reg_in);
reg_out = MFV_HW_READ(VDEC_GCON_BASE);
printk("GCON write 0x%x, read 0x%x, %s\n", reg_in, reg_out, reg_in == reg_out ? "Pass":"******");
reg_in = 0xFFFFFFFF;
reg_out = 0;
MFV_HW_WRITE((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R1Y_ADD), reg_in);
reg_out = MFV_HW_READ((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R1Y_ADD));
printk("OFFSET_R1Y_ADD write 0x%x, read 0x%x, mask 0x%x, %s\n", reg_in, reg_out, Y_MASK, (reg_in & Y_MASK) == reg_out ? "Pass":"******");
reg_in = 0xFFFFFFFF;
reg_out = 0;
MFV_HW_WRITE((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R1C_ADD), reg_in);
reg_out = MFV_HW_READ((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R1C_ADD));
printk("OFFSET_R1C_ADD write 0x%x, read 0x%x, mask 0x%x, %s\n", reg_in, reg_out, C_MASK, (reg_in & C_MASK) == reg_out ? "Pass":"******");
reg_in = 0xFFFFFFFF;
reg_out = 0;
MFV_HW_WRITE((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R2Y_ADD), reg_in);
reg_out = MFV_HW_READ((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R2Y_ADD));
printk("OFFSET_R2Y_ADD write 0x%x, read 0x%x, mask 0x%x, %s\n", reg_in, reg_out, Y_MASK, (reg_in & Y_MASK) == reg_out ? "Pass":"******");
reg_in = 0xFFFFFFFF;
reg_out = 0;
MFV_HW_WRITE((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R2C_ADD), reg_in);
reg_out = MFV_HW_READ((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R2C_ADD));
printk("OFFSET_R2C_ADD write 0x%x, read 0x%x, mask 0x%x, %s\n", reg_in, reg_out, C_MASK, (reg_in & C_MASK) == reg_out ? "Pass":"******");
break;
case UVVP_VDEC_TEST_VERSION_2:
printk("UVVP_VDEC_TEST_VERSION_2\n");
printk("=== vmalloc memory speed test ===\n");
do_gettimeofday(&tv1);
buf_data = (unsigned char *)vmalloc(TESTDATA_BUFFER_SZ);
buf_data2 = (unsigned char *)vmalloc(TESTDATA_BUFFER_SZ);
do_gettimeofday(&tv2);
calc_time_diff(&tv1, &tv2);
printk("Allocated %d + %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec);
do_gettimeofday(&tv1);
memset(buf_data, 0, TESTDATA_BUFFER_SZ);
memset(buf_data2, 1, TESTDATA_BUFFER_SZ);
do_gettimeofday(&tv2);
calc_time_diff(&tv1, &tv2);
printk("memset %d + %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec);
do_gettimeofday(&tv1);
memcpy(buf_data, buf_data2, TESTDATA_BUFFER_SZ);
do_gettimeofday(&tv2);
calc_time_diff(&tv1, &tv2);
printk("memcpy %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec);
vfree(buf_data);
vfree(buf_data2);
printk("=== ioremap_nocache memory speed test ===\n");
do_gettimeofday(&tv1);
buf_data = g_pu1AllocSA;
buf_data2 = g_pu1AllocSA + TESTDATA_BUFFER_SZ;
buf_data = ioremap_nocache(buf_data, TESTDATA_BUFFER_SZ);
buf_data2 = ioremap_nocache(buf_data2, TESTDATA_BUFFER_SZ);
do_gettimeofday(&tv2);
calc_time_diff(&tv1, &tv2);
printk("ioremap %d + %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec);
do_gettimeofday(&tv1);
memset(buf_data, 0, TESTDATA_BUFFER_SZ);
memset(buf_data2, 1, TESTDATA_BUFFER_SZ);
do_gettimeofday(&tv2);
calc_time_diff(&tv1, &tv2);
printk("memset %d + %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec);
do_gettimeofday(&tv1);
memcpy(buf_data, buf_data2, TESTDATA_BUFFER_SZ);
do_gettimeofday(&tv2);
calc_time_diff(&tv1, &tv2);
printk("memcpy %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec);
iounmap(buf_data);
iounmap(buf_data2);
printk("=== ioremap write test ===\n");
p = g_pu1AllocSA;
p = ((UINT32)p + u4Align-1) & (~(u4Align - 1));
printk("p physical addr 0x%x\n", p);
p = ioremap_nocache(p, u4Size);
printk("p virtual addr 0x%x\n", p);
*p = 'S';
*(p+u4Size-1) = 'E';
printk("p %c %c\n", *p, *(p+u4Size-1));
iounmap(p);
/*
while (1)
{
buf_data = (unsigned char *)vmalloc(mem_sz*1024*1024);
if (buf_data != NULL)
{
vfree(buf_data);
mem_sz = mem_sz + 1;
printk("Memory size %dMB allocated!\n", mem_sz);
}
else
{
printk("Memory size %dMB failed to allocate\n", mem_sz);
break;
}
}
*/
break;
case UVVP_VDEC_TEST_VERSION_3:
printk("UVVP_VDEC_TEST_VERSION_3\n");
buf_data = (unsigned char *)vmalloc(TESTDATA_BUFFER_SZ);
if (0 == buf_data)
{
printk("Allocate %d bytes failed\n", TESTDATA_BUFFER_SZ);
return 0;
}
oldfs = get_fs();
set_fs(KERNEL_DS);
#ifdef USB_ACM_DMA1
printk("UVVP_VDEC_TEST_VERSION_3 Open /dev/usbacm\n");
fd = filp_open("/dev/usbacm", O_RDWR|O_NOCTTY|O_NDELAY, 0);
if (fd == 0)
{ printk("Open /dev/usbacm failed\n");
return 0;
}
#else
printk("UVVP_VDEC_TEST_VERSION_3 Open /dev/ttyGS0\n");
fd = filp_open("/dev/ttyGS0", O_RDWR, 0);
if (fd == 0)
{ printk("Open /dev/ttyGS0 failed\n");
return 0;
}
fd->f_op->unlocked_ioctl(fd, TCGETS, (unsigned long)&settings);
settings.c_cflag &= ~CBAUD;
settings.c_cflag |= B921600;
settings.c_cflag &= ~PARENB;
settings.c_cflag &= ~CSTOPB;
settings.c_cflag &= ~CSIZE;
settings.c_cflag |= CS8 | CLOCAL | CREAD;
settings.c_iflag &= ~(INLCR | ICRNL | IXON | IXOFF | IXANY);
settings.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); /*raw input*/
settings.c_oflag &= ~OPOST; /*raw output*/
settings.c_cc[VMIN] = 0;
settings.c_cc[VTIME] = 100;
fd->f_op->unlocked_ioctl(fd, TCSETS, (unsigned long)&settings);
#endif
// Read CRC
printk("Read CRC file\n");
file_num = remote_open(fd, "Z:\\1280x720_30_2000.ivf.crc", 27, "rb", 2);
if (file_num < 0)
{
printk("Open CRC failed\n");
return 0;
}
file_len = remote_seek(fd, file_num, 0, SEEK_END);
if (file_len < 0 || file_len > TESTDATA_BUFFER_SZ)
{
printk("CRC file too big %d\n", file_len);
return 0;
}
remote_seek(fd, file_num, 0, SEEK_SET);
read_len = remote_read(fd, file_num, &crc, sizeof(int));
if (read_len < file_len)
{
printk("Fail to read CRC file\n");
return 0;
}
remote_close(fd, file_num);
// Read real file
printk("Read Data file\n");
file_num = remote_open(fd, "Z:\\1280x720_30_2000.ivf", 23, "rb", 2);
if (file_num < 0)
{
printk("Open data file failed\n");
return 0;
}
file_len = remote_seek(fd, file_num, 0, SEEK_END);
if (file_len < 0 || file_len > TESTDATA_BUFFER_SZ)
{
printk("Data file too big %d\n", file_len);
return 0;
}
remote_seek(fd, file_num, 0, SEEK_SET);
memset(&tv1, 0, sizeof(struct timeval));
memset(&tv2, 0, sizeof(struct timeval));
printk("Start reading data\n");
do_gettimeofday(&tv1);
read_len = remote_read(fd, file_num, buf_data, file_len);
do_gettimeofday(&tv2);
printk("End reading data\n");
printk("tv1 %d.%d, tv2 %d.%d \n", tv1.tv_sec, tv1.tv_usec, tv2.tv_sec, tv2.tv_usec);
tv2.tv_sec -= tv1.tv_sec;
if (tv2.tv_usec < tv1.tv_usec)
{
if (tv2.tv_sec < 1)
printk("TIME ERROR\n");
tv2.tv_usec = tv2.tv_usec + 1000000 - tv1.tv_usec;
tv2.tv_sec -= 1;
}
else
{
tv2.tv_usec -= tv1.tv_usec;
}
printk("Data len %d, elapsed time %d ms, avg speed %d bytes/ms\n", read_len, (tv2.tv_sec * 1000000 + tv2.tv_usec)/1000, read_len/((tv2.tv_sec * 1000000 + tv2.tv_usec)/1000));
if (read_len < file_len)
{
printk("Fail read data file exp. %d, read %d\n", file_len, read_len);
return 0;
}
remote_close(fd, file_num);
// CRC check
own_crc = av_adler32_update(1, buf_data, 1, read_len);
printk("own_crc 0x%08x, crc 0x%08x, %s\n", own_crc, crc, (own_crc == crc) ? "Pass":"******");
// Write file
file_num = remote_open(fd, "D:\\Test.txt", 11, "wb", 2);
if (file_num < 0)
{
printk("Open data file failed\n");
return 0;
}
for (i = 0; i < 256; i++)
{
tmp_buf[i] = i;
}
for (i = 0; i < 1024; i++)
{
memcpy(buf_data+(1024*i), (unsigned char *)&tmp_buf[0], 1024);
}
remote_write(fd, file_num, buf_data, 1024*1024);
remote_close(fd, file_num);
filp_close(fd, NULL);
vfree(buf_data);
/*
_pucVFifo[0] = ioremap(0x8000000, 0x100000);
memset(_pucVFifo[0] ,5,0x100000);
printk("_pucVFifo = 0x%x\n", _pucVFifo[0]);
printk("_pucVFifo m4u_v2p = 0x%x\n", m4u_v2p_new((unsigned int)_pucVFifo[0]));
iounmap(_pucVFifo[0]);
_pucVFifo[0] = ioremap(0x8000000, 0x100000);
memset(_pucVFifo[0] ,5,0x100000);
printk("_pucVFifo = 0x%x\n", _pucVFifo[0]);
printk("_pucVFifo m4u_v2p = 0x%x\n", m4u_v2p_new((unsigned int)_pucVFifo[0]));
iounmap(_pucVFifo[0]);
_pucVFifo[0] = ioremap(0x8000000, 0x100000);
memset(_pucVFifo[0] ,5,0x100000);
printk("_pucVFifo = 0x%x\n", _pucVFifo[0]);
printk("_pucVFifo m4u_v2p = 0x%x\n", m4u_v2p_new((unsigned int)_pucVFifo[0]));
iounmap(_pucVFifo[0]);
*/
break;
case UVVP_VDEC_TEST_VERSION_4:
initKernelEnv();
fd = openFile("/etc/frame_num",O_RDONLY,0);
if (IS_ERR(fd) )
printk("[Error] Miss file: input arg file!!!!!!!!!!!!!\n");
else
readFile(fd ,tmp_buf, 256 );
closeFile(fd);
set_fs( oldfs );
sscanf ( tmp_buf, "%i %i %i %i %i %s %i %i" , &frame_start, &frame_end, &width, &height, &debug_mode, bitstream_name, &error_rate, &UFO_MODE);
hevc_test( frame_start, frame_end);
break;
default:
break;
}
//printk("\r\n******** uvvp_vdec_ioctl done********\r\n");
return 0;
}
