/** * @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; }