void *listenThread(void *arg)
{
printf("Listen Thread: init sphinx...\n");
if(!sphinxInit())
exit(-1);
if(!recordInit())
exit(-1);
while(!getExitApp())
{
if(getRun())
{
printf("Listen Thread: starting to decode...\n");
pthread_barrier_wait(&startBarrier);
if(!decode())
exit(-1);
printf("Listen Thread: decoding finished...\n");
if (!printResult())
exit(-1);
pthread_barrier_wait(&endBarrier);
} else {
usleep(1000);
}
}
recordClose();
sphinxClose();
printf("Listen thread terminated.\n");
return NULL;
}
int main(int argc, char** argv) {
ensure_eq(argc,2);
recordInit();
init_timeop();
ssize_t amt;
realpath(argv[0],lackey);
char* lastslash = strrchr(lackey,'/');
if(lastslash == NULL) {
realpath("./lackey-bin",lackey);
} else {
// take the real path of us, and convert the end to lackey-bin
amt = lastslash - lackey + 1;
record(INFO,"realp %s",lackey+amt);
memcpy(lackey+amt,"lackey-bin",sizeof("lackey-bin"));
}
record(INFO, "lackey '%s'",lackey);
ensure_eq(0,chdir(argv[1])); // ehhhh
dolock();
mkfifo("incoming",0644); // not a directory anymore
// we're opening our pipe for writing, so that it doesn't go into an EOF spin loop
// when there are no more writers
int incoming = open("incoming",O_RDWR|O_NONBLOCK);
/* block the signals we care about
this does NOT ignore them, but queues them up
and interrupts stuff like ppoll (which reenables getting hit by those signals atomically)
then we can read info off the signalfd at our leisure, with no signal handler jammed in-between
an if(numworkers == 0) and start_worker();
*/
waiter_setup();
assert(0 == numworkers);
pfd = malloc(sizeof(*pfd)*2);
pfd[INCOMING].fd = incoming;
pfd[INCOMING].events = POLLIN;
pfd[ACCEPTING].fd = start_working(true);
pfd[ACCEPTING].events = POLLIN;
void clear_incoming(void) {
char buf[512];
for(;;) {
ssize_t amt = read(incoming,buf,512);
if(amt <= 0) {
ensure_eq(errno,EAGAIN);
break;
}
}
record(INFO,"Incoming fifo unclogged");
}
int main(void)
{
int ret = 0;
uint8_t *pTemp;
int len;
int ch;
// led1 = new DigitalOut(P0_4);
led1 = new DigitalOut(LED2);
ticker = new Ticker();
ticker->attach(periodicCallback, 0.4f); // blink LED
serialPort = new Serial(USBTX, USBRX);
// serialPort = new Serial(P0_0, P0_1);
(*led1) = 1;
serialPort->baud(115200);
serialPort->attach(&rxInterrupt,SerialBase::RxIrq);
// serialPort->printf("Yeth sport\r\n");
wait_ms(100);
ret = bicProcessInit();
if (ret)
{
serialPort->printf("bic process init failed:%d\r\n", ret);
while(1);
}
// serialPort->printf("%s\r\n", __TIME__);
ble.init();
ble.onDisconnection(disconnectionCallback);
ble.onConnection(connectionEventCallback);
uart = new UARTService(ble);
recordInit();
/* setup advertising */
ble.accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED);
ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
ble.accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME,
(const uint8_t *)"ysport", sizeof("ysport") - 1);
ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,
(const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));
ble.setAdvertisingInterval(50); /* 100ms; in multiples of 0.625ms. */
ble.startAdvertising();
while (true) {
ble.waitForEvent();
ch = EOF;
if (ledToggle) {
(*led1) = !(*led1);
ledToggle = 0;
}
while(1)
{
ch = uart->_getc();
if (ch == EOF)
break;
serialPort->putc(ch);
bicReceiveChar((uint8_t)ch);
}
while(0 == bicProcessDispatchEvents()){
wait_ms(20);
}
}
}
static void *Audio_Record_thread(void *mPtr)
{
struct headset *hds = (struct headset *)mPtr;
ALOGD(TAG "%s: Start", __FUNCTION__);
usleep(100000);
bool dumpFlag = read_preferred_recorddump();
// bool dumpFlag = true;//for test
int magLower = 0, magUpper = 0;
read_preferred_magnitude(&magUpper, &magLower);
int lowFreq = 1000 * (1 - 0.1); //1k
int highFreq = 1000 * (1 + 0.1);
short pbuffer[8192] = {0};
short pbufferL[4096] = {0};
short pbufferR[4096] = {0};
unsigned int freqDataL[3] = {0}, magDataL[3] = {0};
unsigned int freqDataR[3] = {0}, magDataR[3] = {0};
int checkCnt = 0;
uint32_t samplerate = 0;
// headsetLR: Phone level test; headset: Non-Phone level test.
return_data.headsetL.freqL = return_data.headsetR.freqL = return_data.headset.freqL = freqDataL[0];
return_data.headsetL.freqR = return_data.headsetR.freqR = return_data.headset.freqR = freqDataR[0];
return_data.headsetL.amplL = return_data.headsetR.amplL = return_data.headset.amplL = magDataL[0];
return_data.headsetL.amplR = return_data.headsetR.amplR = return_data.headset.amplR = magDataR[0];
recordInit(hds->recordDevice, &samplerate);
while (1)
{
memset(pbuffer, 0, sizeof(pbuffer));
memset(pbufferL, 0, sizeof(pbufferL));
memset(pbufferR, 0, sizeof(pbufferR));
int readSize = readRecordData(pbuffer, 8192 * 2);
for (int i = 0 ; i < 4096 ; i++)
{
pbufferL[i] = pbuffer[2 * i];
pbufferR[i] = pbuffer[2 * i + 1];
}
if (dumpFlag)
{
char filenameL[] = "/data/record_headset_dataL.pcm";
char filenameR[] = "/data/record_headset_dataR.pcm";
FILE *fpL = fopen(filenameL, "wb+");
FILE *fpR = fopen(filenameR, "wb+");
if (fpL != NULL)
{
fwrite(pbufferL, readSize / 2, 1, fpL);
fclose(fpL);
}
if (fpR != NULL)
{
fwrite(pbufferR, readSize / 2, 1, fpR);
fclose(fpR);
}
}
memset(freqDataL, 0, sizeof(freqDataL));
memset(freqDataR, 0, sizeof(freqDataR));
memset(magDataL, 0, sizeof(magDataL));
memset(magDataR, 0, sizeof(magDataR));
ApplyFFT256(samplerate, pbufferL, 0, freqDataL, magDataL);
ApplyFFT256(samplerate, pbufferR, 0, freqDataR, magDataR);
for (int i = 0; i < 3 ; i ++)
{
SXLOGV("%d.freqDataL[%d]:%d,magDataL[%d]:%d", i, i, freqDataL[i], i, magDataL[i]);
SXLOGV("%d.freqDataR[%d]:%d,magDataR[%d]:%d", i, i, freqDataR[i], i, magDataR[i]);
}
if (hds->isPhoneTest)
{
if (headset_phonetest_state == 0) // CH1
{
//CH1 Log
return_data.headsetL.freqL = freqDataL[0];
return_data.headsetL.amplL = magDataL[0];
return_data.headsetL.freqR = freqDataR[0];
return_data.headsetL.amplR = magDataR[0];
if ((freqDataL[0] <= highFreq && freqDataL[0] >= lowFreq) && (magDataL[0] <= magUpper && magDataL[0] >= magLower))
{
checkCnt ++;
if (checkCnt >= 5)
{
ALOGD("[Headset-L] freqDataL:%d,magDataL:%d,freqDataR:%d,magDataR:%d", freqDataL[0], magDataL[0], freqDataR[0], magDataR[0]);
checkCnt = 0;
}
}
else
{
checkCnt = 0;
}
}
else if (headset_phonetest_state == 1) // CH2
{
if ((freqDataR[0] <= highFreq && freqDataR[0] >= lowFreq) && (magDataR[0] <= magUpper && magDataR[0] >= magLower))
{
checkCnt ++;
if (checkCnt >= 5)
{
ALOGD("[Headset-R] freqDataL:%d,magDataL:%d,freqDataR:%d,magDataR:%d", freqDataL[0], magDataL[0], freqDataR[0], magDataR[0]);
snprintf(hds->info, sizeof(hds->info), "Check freq pass.\n");
ALOGD(" @ info : %s", hds->info);
break;
}
}
else
{
checkCnt = 0;
}
}
else
{
break;
}
}
else // Non Phone level test
{
if (((freqDataL[0] <= highFreq && freqDataL[0] >= lowFreq) && (magDataL[0] <= magUpper && magDataL[0] >= magLower)) && ((freqDataR[0] <= highFreq && freqDataR[0] >= lowFreq) && (magDataR[0] <= magUpper && magDataR[0] >= magLower)))
{
checkCnt ++;
if (checkCnt >= 5)
{
snprintf(hds->info, sizeof(hds->info), "Check freq pass.\n");
ALOGD(" @ info : %s", hds->info);
break;
}
}
else
{
checkCnt = 0;
}
if (hds->exit_thd)
{
break;
}
}
}
// Log and ATA Return
if (hds->isPhoneTest)
{
//CH2 Log
return_data.headsetR.freqL = freqDataL[0];
return_data.headsetR.freqR = freqDataR[0];
return_data.headsetR.amplL = magDataL[0];
return_data.headsetR.amplR = magDataR[0];
ALOGD(TAG "ATA Return Data[Headset-L]: [Mic1]Freq = %d, Amp = %d, [Mic2]Freq = %d, Amp = %d", return_data.headsetL.freqL, return_data.headsetL.amplL, return_data.headsetL.freqR, return_data.headsetL.amplR);
ALOGD(TAG "ATA Return Data[Headset-R]: [Mic1]Freq = %d, Amp = %d, [Mic2]Freq = %d, Amp = %d", return_data.headsetR.freqL, return_data.headsetR.amplL, return_data.headsetR.freqR, return_data.headsetR.amplR);
}
else
{
return_data.headset.freqL = freqDataL[0];
return_data.headset.freqR = freqDataR[0];
return_data.headset.amplL = magDataL[0];
return_data.headset.amplR = magDataR[0];
ALOGD(TAG "ATA Return Data: FreqL = %d, FreqR = %d, AmpL = %d, AmpR = %d", return_data.headset.freqL, return_data.headset.freqR, return_data.headset.amplL, return_data.headset.amplR);
}
ALOGD(TAG "%s: Stop", __FUNCTION__);
pthread_exit(NULL); // thread exit
return NULL;
}
static void *Headset_THD_Record_thread(void *mPtr)
{
struct headset *hds = (struct headset *)mPtr;
ALOGD(TAG "%s: Start", __FUNCTION__);
usleep(100000);
int magLower = 0, magUpper = 0;
read_preferred_magnitude(&magUpper, &magLower);
int freqOfRingtone = 1000;
//int lowFreq = freqOfRingtone * (1-0.05);
//int highFreq = freqOfRingtone * (1+0.05);
short pbuffer[8192] = {0};
short pbufferL[4096] = {0};
short pbufferR[4096] = {0};
//unsigned int freqDataL[3]={0},magDataL[3]={0};
//unsigned int freqDataR[3]={0},magDataR[3]={0};
float thdPercentage = 0;
int lenL = 0, lenR = 0;
float thdData[2][FFT_DAT_MAXNUM];
audio_data_statistic headsetL_thd_sta, headsetR_thd_sta;
uint32_t sampleRate;
recordInit(hds->recordDevice, &sampleRate);
while (1)
{
memset(pbuffer, 0, sizeof(pbuffer));
memset(pbufferL, 0, sizeof(pbufferL));
memset(pbufferR, 0, sizeof(pbufferR));
int readSize = readRecordData(pbuffer, 8192 * 2);
for (int i = 0 ; i < 4096 ; i++)
{
pbufferL[i] = pbuffer[2 * i];
pbufferR[i] = pbuffer[2 * i + 1];
}
if (headset_phonetest_state == 0) // L ch
{
thdPercentage = CalculateTHD(48000, pbufferL, freqOfRingtone, 0.0);
ALOGD("HeadsetL THD: %f", thdPercentage);
thdData[0][lenL] = thdPercentage;
lenL++;
}
else if (headset_phonetest_state == 1)
{
thdPercentage = CalculateTHD(48000, pbufferR, freqOfRingtone, 0.0);
ALOGD("HeadsetR THD: %f", thdPercentage);
thdData[1][lenR] = thdPercentage;
lenR++;
}
if (hds->exit_thd)
{
break;
}
}
CalculateStatistics(&thdData[0][0], lenL, 5, 1, &headsetL_thd_sta);
CalculateStatistics(&thdData[1][0], lenR, 5, 1, &headsetR_thd_sta);
if (headsetL_thd_sta.deviation < 0.5 && headsetR_thd_sta.deviation < 0.5)
{
snprintf(hds->info + strlen(hds->info), sizeof(hds->info) - strlen(hds->info), "Check THD pass.\n");
ALOGD(" @ info : %s", hds->info);
}
{
return_data.headsetL_thd.thd.mean = headsetL_thd_sta.mean;
return_data.headsetL_thd.thd.deviation = headsetL_thd_sta.deviation;
return_data.headsetL_thd.thd.max = headsetL_thd_sta.max;
return_data.headsetL_thd.thd.min = headsetL_thd_sta.min;
return_data.headsetR_thd.thd.mean = headsetR_thd_sta.mean;
return_data.headsetR_thd.thd.deviation = headsetR_thd_sta.deviation;
return_data.headsetR_thd.thd.max = headsetR_thd_sta.max;
return_data.headsetR_thd.thd.min = headsetR_thd_sta.min;
ALOGD(TAG "ATA Return THD(Headset-L): Mean = %f, Deviation = %f, Max = %f, Min = %f", return_data.headsetL_thd.thd.mean, return_data.headsetL_thd.thd.deviation, return_data.headsetL_thd.thd.max, return_data.headsetL_thd.thd.min);
ALOGD(TAG "ATA Return THD(Headset-R): Mean = %f, Deviation = %f, Max = %f, Min = %f", return_data.headsetR_thd.thd.mean, return_data.headsetR_thd.thd.deviation, return_data.headsetR_thd.thd.max, return_data.headsetR_thd.thd.min);
}
ALOGD(TAG "%s: Stop", __FUNCTION__);
pthread_exit(NULL); // thread exit
return NULL;
}
static void * Audio_Record_thread(void *mPtr)
{
struct mVibrator *hds = (struct mVibrator *)mPtr;
ALOGD(TAG "%s: Start", __FUNCTION__);
usleep(100000);
bool dumpFlag = 0; // read_preferred_recorddump() = 0
// dumpFlag=true;//for test
int magLower = 0,magUpper = 0;
//read_preferred_magnitude(hds->i4OutputType,&magUpper,&magLower);
//int freqOfRingtone = read_preferred_ringtone_freq();
magLower = 1000;
magUpper = 1000000000;
int freqOfRingtone = 200;
int lowFreq = freqOfRingtone * (1-0.1);
int highFreq = freqOfRingtone * (1+0.1);
short pbuffer[8192]={0};
short pbufferL[4096]={0};
short pbufferR[4096]={0};
unsigned int freqDataL[3]={0},magDataL[3]={0};
unsigned int freqDataR[3]={0},magDataR[3]={0};
int checkCnt = 0;
uint32_t samplerate;
return_data.vibrator.freq = 0;
return_data.vibrator.ampl = 0;
recordInit(hds->recordDevice, &samplerate);
while (1) {
memset(pbuffer,0,sizeof(pbuffer));
memset(pbufferL,0,sizeof(pbufferL));
memset(pbufferR,0,sizeof(pbufferR));
int readSize = readRecordData(pbuffer,8192*2);
int i;
for(i = 0 ; i < 4096 ; i++)
{
pbufferL[i] = pbuffer[2 * i];
pbufferR[i] = pbuffer[2 * i + 1];
}
if(dumpFlag)
{
char filenameL[]="/data/record_dataL.pcm";
char filenameR[]="/data/record_dataR.pcm";
FILE * fpL= fopen(filenameL, "wb+");
FILE * fpR= fopen(filenameR, "wb+");
if(fpL!=NULL)
{
fwrite(pbufferL,readSize/2,1,fpL);
fclose(fpL);
}
if(fpR!=NULL)
{
fwrite(pbufferR,readSize/2,1,fpR);
fclose(fpR);
}
}
memset(freqDataL,0,sizeof(freqDataL));
memset(freqDataR,0,sizeof(freqDataR));
memset(magDataL,0,sizeof(magDataL));
memset(magDataR,0,sizeof(magDataR));
ApplyFFT256(samplerate,pbufferL,0,freqDataL,magDataL);
ApplyFFT256(samplerate,pbufferR,0,freqDataR,magDataR);
/*int j;
for(j = 0;j < 3 ;j ++)
{
ALOGD("freqDataL[%d]:%d,magDataL[%d]:%d",j,freqDataL[j],j,magDataL[j]);
ALOGD("freqDataR[%d]:%d,magDataR[%d]:%d",j,freqDataR[j],j,magDataR[j]);
}*/
if (((freqDataL[0] <= highFreq && freqDataL[0] >= lowFreq) && (magDataL[0] <= magUpper && magDataL[0] >= magLower))&&((freqDataR[0] <= highFreq && freqDataR[0] >= lowFreq) && (magDataR[0] <= magUpper && magDataR[0] >= magLower)))
{
checkCnt ++;
if(checkCnt >= 5)
{
snprintf(hds->info + strlen(hds->info), sizeof(hds->info) - strlen(hds->info), "Check freq pass.\n");
ALOGD(" @ info : %s",hds->info);
break;
}
}
else
checkCnt = 0;
if (hds->exit_thd){
break;
}
}
return_data.vibrator.freq = freqDataL[0];
return_data.vibrator.ampl = magDataL[0];
ALOGD(TAG "VIBRATOR FFT: FreqL = %d, FreqR = %d, AmpL = %d, AmpR = %d", freqDataL[0], freqDataR[0], magDataL[0], magDataR[0]);
ALOGD(TAG "%s: Stop", __FUNCTION__);
pthread_exit(NULL); // thread exit
return NULL;
}
static bool matv_auto_check_iv(void *priv)
{
struct mMATV *mc = (struct mMATV *)priv;
struct itemview *iv = mc->iv;
struct statfs stat;
matv_ch_entry ch_ent;
int ch_candidate = 0;
int status;
bool return_value = false;
bool audio_check = true;
bool preview_check = true;
int checkpass_cnt = 0;
int chkcnt = 0;
int i = 0;
uint32_t samplerate;
int mAutoLockFreqTest = matv_read_preferred_para("mAutoLockFreqTest");;
int mAutoLockFreq = matv_read_preferred_para("mAutoLockFreq");
int mAutoLockCountry = matv_read_preferred_para("mAutoLockCountry");
LOGD(TAG "%s: Start.\n", __FUNCTION__);
if((mAutoLockFreqTest > 0)
&& (mAutoLockFreq !=0))
{
if (matv_ata_lockstatus(mAutoLockFreq, mAutoLockCountry) != 0)
{
LOGD(TAG "%s: lock freq %d, country %d ok!!!!", __FUNCTION__,
mAutoLockFreq, mAutoLockCountry);
///return_value = true;
}
else
{
LOGD(TAG "%s: lock freq %d, country %d fail!!!!", __FUNCTION__,
mAutoLockFreq, mAutoLockCountry);
return return_value;
}
}
matv_ata_avpatternout();
#ifdef ANALOG_AUDIO
matv_set_chipdep(190, 3); //Turn on analog audio
#endif
iv->redraw(iv);
///system("rm /data/record_atv_dataL.pcm");
///system("rm /data/record_atv_dataR.pcm");
//--> mATV audio path
matv_audio_path(true);
Audio_enable = true;
LOGD(TAG "%s: Start video\n", __FUNCTION__);
#ifdef ANALOG_AUDIO
recordInit(MATV_ANALOG, &samplerate);
#else
recordInit(MATV_I2S, &samplerate);
#endif
usleep(300 * 1000);
///recordOpen();
short pbuffer[8192]={0};
for(int recint = 0; recint <100; recint++)
readRecordData(pbuffer,8192*2);
while (chkcnt < 3)
{
preview_check = true;
audio_check = true;
matv_preview_start();
usleep(300 * 1000);
LOGD(TAG "matv_capture_start %d\n", chkcnt);
short pbufferL[4096]={0};
short pbufferR[4096]={0};
unsigned int freqDataL[3]={0},magDataL[3]={0};
unsigned int freqDataR[3]={0},magDataR[3]={0};
memset(pbuffer, 0, 8192*2);
int readSize = readRecordData(pbuffer,8192*2);
LOGD(TAG "matv_capture_start_audio %d\n", chkcnt);
for(int i = 0 ; i < 4096 ; i++)
{
pbufferL[i] = pbuffer[2 * i];
pbufferR[i] = pbuffer[2 * i + 1];
}
#if 0
LOGD(TAG "matv_capture_start3 %d\n", chkcnt);
char filenameL[]="/data/record_atv_dataL.pcm";
char filenameR[]="/data/record_atv_dataR.pcm";
FILE * fpL= fopen(filenameL, "wb+");
FILE * fpR= fopen(filenameR, "wb+");
if(fpL!=NULL)
{
fwrite(pbufferL,readSize/2,1,fpL);
fclose(fpL);
}
if(fpR!=NULL)
{
fwrite(pbufferR,readSize/2,1,fpR);
fclose(fpR);
}
#endif
memset(freqDataL,0,sizeof(freqDataL));
memset(freqDataR,0,sizeof(freqDataR));
memset(magDataL,0,sizeof(magDataL));
memset(magDataR,0,sizeof(magDataR));
#ifdef ANALOG_AUDIO
ApplyFFT256(samplerate,pbufferL,0,freqDataL,magDataL);
ApplyFFT256(samplerate,pbufferR,0,freqDataR,magDataR);
#else
ApplyFFT256(samplerate,pbufferL,0,freqDataL,magDataL);
ApplyFFT256(samplerate,pbufferR,0,freqDataR,magDataR);
#endif
LOGD(TAG "matv_capture_audio fre L %d H %d\n", freqDataL[0], freqDataR[0] );
if (((freqDataL[0] > 1100) || (freqDataL[0] < 900))
|| ((freqDataR[0] > 1100) || (freqDataR[0] < 900)))
{
audio_check = false;
break;
}
preview_check = matv_capture_check();
matv_preview_stop();
chkcnt++;
int mDisaleImageTest = matv_read_preferred_para("mDisaleImageTest");
if(mDisaleImageTest > 0)
{
preview_check = true;
LOGD(TAG "matv mDisaleImageTest, skip it ");
}
if ((preview_check == true)
&& (audio_check == true))
{
checkpass_cnt++;
}
LOGD(TAG "matv_checking chkcnt %d, prev_ret %d aud_ret %d ", chkcnt, preview_check, audio_check);
if (checkpass_cnt >= 2)
{
return_value = true;
break;
}
}
Audio_enable = false;
///recordClose();
LOGD(TAG "%s: stop video", __FUNCTION__);
matv_ata_avpatternclose();
matv_audio_path(false);
matv_update_iv_thread_exit:
LOGD(TAG "%s: matv_test_result, checkpass_cnt %d return value %d", __FUNCTION__, checkpass_cnt, return_value);
return return_value;
}
