int main(int argc, char *argv[] )
{
/*** get calling argument ***/
char *filePrefix;
getArgument(argc, argv, &filePrefix); /* check argument and set filePrefix if needed */
/*** input and output file pointers ***/
FILE *fpInput;
FILE *fpOutput;
/*** input and output buffers ***/
word16_t inputBuffer[L_FRAME];
word16_t outputBuffer[L_FRAME];
/*** inits ***/
/* open the input file */
if ( (fpInput = fopen(argv[1], "rb")) == NULL) {
printf("%s - Error: can't open file %s\n", argv[0], argv[1]);
exit(-1);
}
/* create the output file(filename is the same than input file with the .out extension) */
char *outputFile = malloc((strlen(filePrefix)+5)*sizeof(char));
sprintf(outputFile, "%s.out",filePrefix);
if ( (fpOutput = fopen(outputFile, "wb")) == NULL) {
printf("%s - Error: can't create file %s\n", argv[0], outputFile);
exit(-1);
}
/*** init of the tested bloc ***/
/* create the context structure */
bcg729EncoderChannelContextStruct *encoderChannelContext = malloc(sizeof(bcg729EncoderChannelContextStruct));
initPreProcessing(encoderChannelContext);
/*** initialisation complete ***/
/*** loop over input file ***/
while(1) /* infinite loop, escape condition is in the reading of data */
{
int i;
/* read the input data until we have some */
if (fscanf(fpInput,"%hd",&(inputBuffer[0])) != 1) break;
for (i=1; i<L_FRAME; i++) {
if (fscanf(fpInput,",%hd",&(inputBuffer[i])) != 1) break;
}
/* call the preProcessing function: output will replace the input in the buffer */
preProcessing(encoderChannelContext, inputBuffer, outputBuffer);
/* write the output to the output file */
fprintf(fpOutput,"%d", outputBuffer[0]);
for (i=1; i<L_FRAME; i++) {
fprintf(fpOutput,",%d", outputBuffer[i]);
}
fprintf(fpOutput,"\n");
}
exit (0);
}
void FunctionHelper::setFunc(LPTSTR raw)
{
wcscpy(this->_raw, raw);
char *buffer = new char[128];
wcstombs(buffer, raw, 128);
this->_func = preProcessing(buffer);
this->_rpn = getRPN(this->_func);
}
/**
* 新产生的谓词 s、t为内涵谓词，succ、max为外延谓词
* @param _originalFml
* @return
*/
Formulas HengZhang::transform(const Formula& _originalFml) {
Formula fml = preProcessing(_originalFml);
Formulas fmls;
fmls.pushBack(createFormula_1());
fmls.pushBack(createFormula_2(fml));
fmls.pushBack(createFormula_3(fml));
fmls.pushBack(createFormula_4_1(fml));
fmls.pushBack(createFormula_4_2(fml));
fmls.pushBack(createFormula_5_1(fml));
fmls.pushBack(createFormula_5_2(fml));
postProcessing();
return fmls;
}
int main() {
unsigned int T,m,n,i;
preProcessing();
i = scanf("%u",&T);
while(T--){
i = scanf("%u",&m);
i = scanf("%u",&n);
m--;
n--;
printf("%llu\n",(((Fact[m+n]*iFact[m])%PRIME)*iFact[n])%PRIME);
}
return 0;
}
FunctionHelper::FunctionHelper (LPTSTR raw, DWORD color, FUNC_TYPE type)
{
initialParser();
this->_raw = new TCHAR[128];
wcscpy(this->_raw, raw);
this->_color = color;
this->_type = type;
if (type == FUNC)
{
char *buffer = new char[128];
wcstombs(buffer, raw, 128);
this->_func = preProcessing(buffer);
this->_rpn = getRPN(this->_func);
}
}
int arrow_detection::featureExteraction(Mat arrow,vector<float> &features){
features.clear();
Mat binary;
vector <std::vector<cv::Point2i >> blobs;
vector<Rect> blobs_roi;
preProcessing(arrow, binary);
// viewImage(binary*255,"binary arrow");
segmentation(binary,blobs_roi, blobs);
// DEBUG_LOG("Blobs attained : %ld\n",blobs_roi.size());
if(blobs_roi.size() > 1){
// ERROR_LOG("More than one blobs detected possibly an error.");
return -1;
}
float convex_area = blobs[0].size();
features.push_back(convex_area);
// DEBUG_LOG("convex_area : %f\n",convex_area);
Rect arrow_rect(blobs_roi[0]);
float a = 0,b = 0;
if(arrow_rect.width > arrow_rect.height){
a = arrow_rect.width/2;
b = arrow_rect.height/2;
}else{
a = arrow_rect.height/2;
b = arrow_rect.width/2;
}
// DEBUG_LOG("semi major axis: %f\n",a);
// DEBUG_LOG("semi minor axis: %f\n",b);
// DEBUG_LOG("their ratio: %f\n",b/a);
// DEBUG_LOG("pow(b/a,2) : %f\n",pow(b/a,2));
float ecentricity = sqrtf(1-pow(b/a,2));
features.push_back(ecentricity);
// DEBUG_LOG("ecentricity : %f\n",ecentricity);
float extent = convex_area/float(arrow.total());
features.push_back(extent);
// DEBUG_LOG("extent : %f\n",extent);
float solidity = float(arrow.total())/convex_area;
features.push_back(extent);
// DEBUG_LOG("solidity : %f\n",solidity);
return 0;
}
void Widget::findPixels(const Point2D<int>& inDisplay, float inRange)
{
mDisplay = inDisplay;
Point2D<float> objectPoint;
objectPoint.x = mLocation.x - (mSize.x / 2.0f);
objectPoint.y = mLocation.y + (mSize.y / 2.0f);
mPixelUL = DisplayEngine::convert2DObjectToPixel(objectPoint, mDisplay, inRange);
objectPoint.x = mLocation.x + (mSize.x / 2.0f);
objectPoint.y = mLocation.y - (mSize.y / 2.0f);
mPixelLR = DisplayEngine::convert2DObjectToPixel(objectPoint, mDisplay, inRange);
preProcessing(inRange);
}
int main(int argc, char ** argv)
{
ocd_init(&argc, &argv, NULL);
ocd_initCL();
if (argc < 3)
{
printf("Calculate similarities between two strings.\n");
printf("Maximum length of each string is: %d\n", MAX_LEN);
printf("Usage: %s query database\n", argv[0]);
printf("or: %s query database [openPenalty extensionPenalty block#]\n", argv[0]);
printf("openPenalty (5.0), extensionPenalty (0.5)\n");
return 1;
}
/////////////////////////////////////
// 00 --> 01
// | |
// 10 --> 11
////////////////////////////////////
char queryFilePathName[255], dbDataFilePathName[255], dbLenFilePathName[255];
int querySize, subSequenceNum, subSequenceSize;
float openPenalty, extensionPenalty;
int coalescedOffset = COALESCED_OFFSET;
int nblosumWidth = 23;
size_t blockSize = 64;
size_t setZeroThreadNum, mfThreadNum;
int blockNum = 14;
cl_ulong maxLocalSize;
int arraySize;
struct timeval t1, t2;
float tmpTime;
FILE *pfile;
//record time
memset(&strTime, 0, sizeof(STRUCT_TIME));
timerStart();
openPenalty = 5.0f;
extensionPenalty = 0.5;
if (argc == 6)
{
openPenalty = atof(argv[3]);
extensionPenalty = atof(argv[4]);
blockNum = atoi(argv[5]);
}
//relocated to after MAX_COMPUTE_UNITS check
//mfThreadNum = blockNum * blockSize;
cl_program hProgram;
cl_kernel hMatchStringKernel, hTraceBackKernel, hSetZeroKernel;
size_t sourceFileSize;
char *cSourceCL = NULL;
//err = clGetPlatformIDs(1, &platformID, NULL);
//CHKERR(err, "Get platform ID error!");
cl_int err;
//check to make sure the device supports this block count
//then scale threads appropriately
cl_uint devBlockNum = 0;
CHKERR(clGetDeviceInfo(device_id, CL_DEVICE_MAX_COMPUTE_UNITS,\
sizeof(cl_uint), &devBlockNum, 0), \
"Error while querying CL_DEVICE_MAX_COMPUTE_UNITS.");
if (devBlockNum == MIN(blockNum, devBlockNum)) {
printf("Scaling blocks from %d to %d to fit on device\n",\
blockNum, devBlockNum);
blockNum = devBlockNum;
}
mfThreadNum = blockNum * blockSize;
CHKERR(clGetDeviceInfo(device_id, CL_DEVICE_LOCAL_MEM_SIZE,\
sizeof(cl_ulong), &maxLocalSize, 0), \
"Error while querying CL_DEVICE_LOCAL_MEM_SIZE.");
//load the source file
char kernel_file[] = "kernels.cl";
cSourceCL = loadSource(kernel_file, &sourceFileSize);
hProgram = clCreateProgramWithSource(context, 1, (const char **)&cSourceCL,
&sourceFileSize, &err);
CHKERR(err, "Create program with source error");
err = clBuildProgram(hProgram, 0, 0, 0, 0, 0);
//debug================================
int logSize = 3000, i;
size_t retSize;
char logTxt[3000];
err = clGetProgramBuildInfo(hProgram, device_id, CL_PROGRAM_BUILD_LOG, logSize, logTxt, &retSize);
for (i = 0; i < retSize; i++)
{
printf("%c", logTxt[i]);
}
//===================================
CHKERR(err, "Build program error");
hMatchStringKernel = clCreateKernel(hProgram, "MatchStringGPUSync", &err);
CHKERR(err, "Create MatchString kernel error");
hTraceBackKernel = clCreateKernel(hProgram, "trace_back2", &err);
CHKERR(err, "Create trace_back2 kernel error");
hSetZeroKernel = clCreateKernel(hProgram, "setZero", &err);
CHKERR(err, "Create setZero kernel error");
sprintf(queryFilePathName, "%s", argv[1]);
sprintf(dbDataFilePathName, "%s.data", argv[2]);
sprintf(dbLenFilePathName, "%s.loc", argv[2]);
char *allSequences, *querySequence, *subSequence;
char *seq1, *seq2;
cl_mem seq1D, seq2D;
allSequences = new char[2 * (MAX_LEN)];
if (allSequences == NULL)
{
printf("Allocate sequence buffer error!\n");
return 1;
}
querySequence = allSequences;
seq1D = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_char) * MAX_LEN, 0, &err);
CHKERR(err, "Create seq1D memory");
seq2D = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_char) * MAX_LEN, 0, &err);
CHKERR(err, "Create seq2D memory");
//read query sequence
querySize = readQuerySequence(queryFilePathName, querySequence);
if (querySize <= 0 || querySize > MAX_LEN)
{
printf("Query size %d is out of range (0, %d)\n",
MAX_LEN,
querySize);
return 1;
}
encoding(querySequence, querySize);
subSequence = allSequences + querySize;
//allocate output sequence buffer
char *outSeq1, *outSeq2;
outSeq1 = new char[2 * MAX_LEN];
outSeq2 = new char[2 * MAX_LEN];
if (outSeq1 == NULL ||
outSeq2 == NULL)
{
printf("Allocate output sequence buffer on host error!\n");
return 1;
}
cl_mem outSeq1D, outSeq2D;
outSeq1D = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_char) * MAX_LEN * 2, 0, &err);
CHKERR(err, "Create outSeq1D memory");
outSeq2D = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_char) * MAX_LEN * 2, 0, &err);
CHKERR(err, "Create outSeq2D memory");
//allocate thread number per launch and
//location difference information
int *threadNum, *diffPos;
threadNum = new int[2 * MAX_LEN];
diffPos = new int[2 * MAX_LEN];
if (threadNum == NULL ||
diffPos == NULL)
{
printf("Allocate location buffer on host error!\n");
return 1;
}
cl_mem threadNumD, diffPosD;
threadNumD = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_int) * (2 * MAX_LEN), 0, &err);
CHKERR(err, "Create threadNumD memory");
diffPosD = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_int) * (2 * MAX_LEN), 0, &err);
CHKERR(err, "Create diffPosD memory");
//allocate matrix buffer
char *pathFlag, *extFlag;
float *nGapDist, *hGapDist, *vGapDist;
int maxElemNum = (MAX_LEN + 1) * (MAX_LEN + 1);
pathFlag = new char[maxElemNum];
extFlag = new char[maxElemNum];
nGapDist = new float[maxElemNum];
hGapDist = new float[maxElemNum];
vGapDist = new float[maxElemNum];
if (pathFlag == NULL ||
extFlag == NULL ||
nGapDist == NULL ||
hGapDist == NULL ||
vGapDist == NULL)
{
printf("Allocate DP matrices on host error!\n");
return 1;
}
cl_mem pathFlagD, extFlagD, nGapDistD, hGapDistD, vGapDistD;
pathFlagD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_char) * maxElemNum, 0, &err);
CHKERR(err, "Create pathFlagD memory");
extFlagD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_char) * maxElemNum, 0, &err);
CHKERR(err, "Create extFlagD memory");
nGapDistD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float) * maxElemNum, 0, &err);
CHKERR(err, "Create nGapDistD memory");
hGapDistD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float) * maxElemNum, 0, &err);
CHKERR(err, "Create hGapDistD memory");
vGapDistD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float) * maxElemNum, 0, &err);
CHKERR(err, "Create vGapDistD memory");
//Allocate the MAX INFO structure
MAX_INFO *maxInfo;
maxInfo = new MAX_INFO[1];
if (maxInfo == NULL)
{
printf("Alloate maxInfo on host error!\n");
return 1;
}
cl_mem maxInfoD;
maxInfoD = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(MAX_INFO) * mfThreadNum, 0, &err);
CHKERR(err, "Create maxInfoD memory");
//allocate the distance table
cl_mem blosum62D;
int nblosumHeight = 23;
blosum62D = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_float) * nblosumWidth * nblosumHeight, 0, &err);
err = clEnqueueWriteBuffer(commands, blosum62D, CL_TRUE, 0,
nblosumWidth * nblosumHeight * sizeof(cl_float), blosum62[0], 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Scoring Matrix Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "copy blosum62 to device");
cl_mem mutexMem;
mutexMem = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int), 0, &err);
CHKERR(err, "create mutex mem error!");
//copy the scoring matrix to the constant memory
//copyScoringMatrixToConstant();
//open the database
pDBDataFile = fopen(dbDataFilePathName, "rb");
if (pDBDataFile == NULL)
{
printf("DB data file %s open error!\n", dbDataFilePathName);
return 1;
}
pDBLenFile = fopen(dbLenFilePathName, "rb");
if (pDBLenFile == NULL)
{
printf("DB length file %s open error!\n", dbLenFilePathName);
return 1;
}
//record time
timerEnd();
strTime.iniTime = elapsedTime();
//read the total number of sequences
fread(&subSequenceNum, sizeof(int), 1, pDBLenFile);
//get the larger and smaller of the row and colum number
int subSequenceNo, launchNum, launchNo;
int rowNum, columnNum, matrixIniNum;
int DPMatrixSize;
int seq1Pos, seq2Pos, nOffset, startPos;
for (subSequenceNo = 0; subSequenceNo < subSequenceNum; subSequenceNo++)
{
//record time
timerStart();
//read subject sequence
fread(&subSequenceSize, sizeof(int), 1, pDBLenFile);
if (subSequenceSize <= 0 || subSequenceSize > MAX_LEN)
{
printf("Size %d of bubject sequence %d is out of range!\n",
subSequenceSize,
subSequenceNo);
break;
}
fread(subSequence, sizeof(char), subSequenceSize, pDBDataFile);
gettimeofday(&t1, NULL);
if (subSequenceSize > querySize)
{
seq1 = subSequence;
seq2 = querySequence;
rowNum = subSequenceSize + 1;
columnNum = querySize + 1;
}
else
{
seq1 = querySequence;
seq2 = subSequence;
rowNum = querySize + 1;
columnNum = subSequenceSize + 1;
}
launchNum = rowNum + columnNum - 1;
//preprocessing for sequences
DPMatrixSize = preProcessing(rowNum,
columnNum,
threadNum,
diffPos,
matrixIniNum);
//record time
timerEnd();
strTime.preprocessingTime += elapsedTime();
//record time
timerStart();
//use a kernel to initialize the matrix
arraySize = DPMatrixSize * sizeof(char);
setZeroThreadNum = ((arraySize - 1) / blockSize + 1) * blockSize;
err = clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&pathFlagD);
err |= clSetKernelArg(hSetZeroKernel, 1, sizeof(int), (void *)&arraySize);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT DP Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&extFlagD);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT DP Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Initialize flag matrice");
arraySize = matrixIniNum * sizeof(float);
setZeroThreadNum = ((arraySize - 1) / blockSize + 1) * blockSize;
err = clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&nGapDistD);
err |= clSetKernelArg(hSetZeroKernel, 1, sizeof(int), (void *)&arraySize);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Distance Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&hGapDistD);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Distance Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&vGapDistD);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Distance Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Initialize dist matrice");
arraySize = sizeof(MAX_INFO) * mfThreadNum;
setZeroThreadNum = ((arraySize - 1) / blockSize + 1) * blockSize;
err = clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&maxInfoD);
err |= clSetKernelArg(hSetZeroKernel, 1, sizeof(int), (void *)&arraySize);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Max Info Matrix Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Initialize max info");
arraySize = sizeof(int);
setZeroThreadNum = ((arraySize - 1) / blockSize + 1) * blockSize;
err = clSetKernelArg(hSetZeroKernel, 0, sizeof(cl_mem), (void *)&mutexMem);
err |= clSetKernelArg(hSetZeroKernel, 1, sizeof(int), (void *)&arraySize);
err |= clEnqueueNDRangeKernel(commands, hSetZeroKernel, 1, NULL, &setZeroThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Mutex Init", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Initialize mutex variable");
//copy input sequences to device
err = clEnqueueWriteBuffer(commands, seq1D, CL_FALSE, 0, (rowNum - 1) * sizeof(cl_char), seq1, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Sequence Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clEnqueueWriteBuffer(commands, seq2D, CL_FALSE, 0, (columnNum - 1) * sizeof(cl_char), seq2, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Sequence Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "copy input sequence");
err = clEnqueueWriteBuffer(commands, diffPosD, CL_FALSE, 0, launchNum * sizeof(cl_int), diffPos, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Mutex Info Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
err |= clEnqueueWriteBuffer(commands, threadNumD, CL_FALSE, 0, launchNum * sizeof(cl_int), threadNum, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_H2D, "SWAT Mutex Info Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "copy diffpos and/or threadNum mutexMem info error!");
//record time
timerEnd();
strTime.copyTimeHostToDevice += elapsedTime();
//record time
timerStart();
//set arguments
err = clSetKernelArg(hMatchStringKernel, 0, sizeof(cl_mem), (void *)&pathFlagD);
err |= clSetKernelArg(hMatchStringKernel, 1, sizeof(cl_mem), (void *)&extFlagD);
err |= clSetKernelArg(hMatchStringKernel, 2, sizeof(cl_mem), (void *)&nGapDistD);
err |= clSetKernelArg(hMatchStringKernel, 3, sizeof(cl_mem), (void *)&hGapDistD);
err |= clSetKernelArg(hMatchStringKernel, 4, sizeof(cl_mem), (void *)&vGapDistD);
err |= clSetKernelArg(hMatchStringKernel, 5, sizeof(cl_mem), (void *)&diffPosD);
err |= clSetKernelArg(hMatchStringKernel, 6, sizeof(cl_mem), (void *)&threadNumD);
err |= clSetKernelArg(hMatchStringKernel, 7, sizeof(cl_int), (void *)&rowNum);
err |= clSetKernelArg(hMatchStringKernel, 8, sizeof(cl_int), (void *)&columnNum);
err |= clSetKernelArg(hMatchStringKernel, 9, sizeof(cl_mem), (void *)&seq1D);
err |= clSetKernelArg(hMatchStringKernel, 10, sizeof(cl_mem), (void *)&seq2D);
err |= clSetKernelArg(hMatchStringKernel, 11, sizeof(cl_int), (void *)&nblosumWidth);
err |= clSetKernelArg(hMatchStringKernel, 12, sizeof(cl_float), (void *)&openPenalty);
err |= clSetKernelArg(hMatchStringKernel, 13, sizeof(cl_float), (void *)&extensionPenalty);
err |= clSetKernelArg(hMatchStringKernel, 14, sizeof(cl_mem), (void *)&maxInfoD);
err |= clSetKernelArg(hMatchStringKernel, 15, sizeof(cl_mem), (void *)&blosum62D);
err |= clSetKernelArg(hMatchStringKernel, 16, sizeof(cl_mem), (void *)&mutexMem);
//err |= clSetKernelArg(hMatchStringKernel, 17, maxLocalSize, NULL);
CHKERR(err, "Set match string argument error!");
err = clEnqueueNDRangeKernel(commands, hMatchStringKernel, 1, NULL, &mfThreadNum,
&blockSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Kernels", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Launch kernel match string error");
//record time
timerEnd();
strTime.matrixFillingTime += elapsedTime();
//record time
timerStart();
err = clSetKernelArg(hTraceBackKernel, 0, sizeof(cl_mem), (void *)&pathFlagD);
err |= clSetKernelArg(hTraceBackKernel, 1, sizeof(cl_mem), (void *)&extFlagD);
err |= clSetKernelArg(hTraceBackKernel, 2, sizeof(cl_mem), (void *)&diffPosD);
err |= clSetKernelArg(hTraceBackKernel, 3, sizeof(cl_mem), (void *)&seq1D);
err |= clSetKernelArg(hTraceBackKernel, 4, sizeof(cl_mem), (void *)&seq2D);
err |= clSetKernelArg(hTraceBackKernel, 5, sizeof(cl_mem), (void *)&outSeq1D);
err |= clSetKernelArg(hTraceBackKernel, 6, sizeof(cl_mem), (void *)&outSeq2D);
err |= clSetKernelArg(hTraceBackKernel, 7, sizeof(cl_mem), (void *)&maxInfoD);
err |= clSetKernelArg(hTraceBackKernel, 8, sizeof(int), (void *)&mfThreadNum);
size_t tbGlobalSize[1] = {1};
size_t tbLocalSize[1] = {1};
err = clEnqueueNDRangeKernel(commands, hTraceBackKernel, 1, NULL, tbGlobalSize,
tbLocalSize, 0, NULL, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_KERNEL, "SWAT Kernels", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Launch kernel trace back error");
clFinish(commands);
//record time
timerEnd();
strTime.traceBackTime += elapsedTime();
//record time
timerStart();
//copy matrix score structure back
err = clEnqueueReadBuffer(commands, maxInfoD, CL_FALSE, 0, sizeof(MAX_INFO),
maxInfo, 0, 0, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_D2H, "SWAT Max Info Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Read maxInfo buffer error!");
int maxOutputLen = rowNum + columnNum - 2;
err = clEnqueueReadBuffer(commands, outSeq1D, CL_FALSE, 0, maxOutputLen * sizeof(cl_char),
outSeq1, 0, 0, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_D2H, "SWAT Sequence Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
err = clEnqueueReadBuffer(commands, outSeq2D, CL_FALSE, 0, maxOutputLen * sizeof(cl_char),
outSeq2, 0, 0, &ocdTempEvent);
clFinish(commands);
START_TIMER(ocdTempEvent, OCD_TIMER_D2H, "SWAT Sequence Copy", ocdTempTimer)
END_TIMER(ocdTempTimer)
CHKERR(err, "Read output sequence error!");
//record time
clFinish(commands);
gettimeofday(&t2, NULL);
timerEnd();
strTime.copyTimeDeviceToHost += elapsedTime();
//call the print function to print the match result
printf("============================================================\n");
printf("Sequence pair %d:\n", subSequenceNo);
int nlength = maxInfo->noutputlen;
PrintAlignment(outSeq1, outSeq2, nlength, CHAR_PER_LINE, openPenalty, extensionPenalty);
printf("Max alignment score (on device) is %.1f\n", maxInfo->fmaxscore);
//obtain max alignment score on host
//err = clEnqueueReadBuffer(commands, nGapDistD, CL_TRUE, 0, sizeof(cl_float) * DPMatrixSize,
// nGapDist, 0, 0, 0);
//printf("Max alignment score (on host) is %.1f\n", maxScore(nGapDist, DPMatrixSize));
printf("openPenalty = %.1f, extensionPenalty = %.1f\n", openPenalty, extensionPenalty);
printf("Input sequence size, querySize: %d, subSequenceSize: %d\n",
querySize, subSequenceSize);
printf("Max position, seq1 = %d, seq2 = %d\n", maxInfo->nposi, maxInfo->nposj);
}
tmpTime = 1000.0 * (t2.tv_sec - t1.tv_sec) + (t2.tv_usec - t1.tv_usec) / 1000.0;
pfile = fopen("../kernelTime.txt", "at");
fprintf(pfile, "verOpencl4:\t%.3f\n", tmpTime);
fclose(pfile);
//print time
printTime_toStandardOutput();
printTime_toFile();
fclose(pDBLenFile);
fclose(pDBDataFile);
clReleaseKernel(hMatchStringKernel);
clReleaseKernel(hTraceBackKernel);
clReleaseKernel(hSetZeroKernel);
delete allSequences;
clReleaseMemObject(seq1D);
clReleaseMemObject(seq2D);
delete outSeq1;
delete outSeq2;
clReleaseMemObject(outSeq1D);
clReleaseMemObject(outSeq2D);
delete threadNum;
clReleaseMemObject(threadNumD);
delete diffPos;
clReleaseMemObject(diffPosD);
delete pathFlag;
delete extFlag;
delete nGapDist;
delete hGapDist;
delete vGapDist;
clReleaseMemObject(pathFlagD);
clReleaseMemObject(extFlagD);
clReleaseMemObject(nGapDistD);
clReleaseMemObject(hGapDistD);
clReleaseMemObject(vGapDistD);
delete maxInfo;
clReleaseMemObject(maxInfoD);
free(cSourceCL);
clReleaseMemObject(blosum62D);
clReleaseMemObject(mutexMem);
clReleaseProgram(hProgram);
clReleaseCommandQueue(commands);
clReleaseContext(context);
ocd_finalize();
return 0;
}
void
pcl::GrayStereoMatching::compute (unsigned char* ref_img, unsigned char* trg_img, int width, int height)
{
//Check that a suitable value of max_disp has been selected
if ( max_disp_ <= 0)
{
PCL_ERROR(
"[pcl::StereoMatching::compute] Error. A positive max_disparity value has not be correctly inserted. Aborting..\n"
);
return;
}
if ( (disp_map_ != NULL) && (width_ != width || height_ != height) )
{
delete [] disp_map_;
disp_map_ = NULL;
if ( disp_map_trg_ != NULL)
{
delete [] disp_map_trg_;
disp_map_trg_ = NULL;
}
if ( pp_ref_img_ != NULL)
{
delete [] pp_ref_img_;
delete [] pp_trg_img_;
pp_ref_img_ = NULL;
pp_trg_img_ = NULL;
}
}
if ( disp_map_ == NULL)
{
disp_map_ = new short int[width * height];
width_ = width;
height_ = height;
}
if ( is_lr_check_ && disp_map_trg_ == NULL)
{
disp_map_trg_ = new short int[width * height];
}
if ( !is_lr_check_ && disp_map_trg_ != NULL)
{
delete [] disp_map_trg_;
disp_map_trg_ = NULL;
}
if ( is_pre_proc_ && pp_ref_img_ == NULL)
{
pp_ref_img_ = new unsigned char[width_*height_];
pp_trg_img_ = new unsigned char[width_*height_];
}
if ( !is_pre_proc_ && pp_ref_img_ != NULL)
{
delete [] pp_ref_img_;
delete [] pp_trg_img_;
pp_ref_img_ = NULL;
pp_trg_img_ = NULL;
}
memset(disp_map_, 0, sizeof(short int)*height_*width_);
if ( is_pre_proc_)
{
preProcessing(ref_img, pp_ref_img_);
preProcessing(trg_img, pp_trg_img_);
}
if (is_lr_check_)
{
if ( is_pre_proc_)
{
imgFlip(pp_ref_img_);
imgFlip(pp_trg_img_);
compute_impl(pp_trg_img_, pp_ref_img_);
imgFlip(pp_ref_img_);
imgFlip(pp_trg_img_);
}
else
{
imgFlip(ref_img);
imgFlip(trg_img);
compute_impl(trg_img, ref_img);
imgFlip(ref_img);
imgFlip(trg_img);
}
for (int j = 0; j < height_; j++)
for (int i = 0; i < width_; i++)
disp_map_trg_[j * width_ + i] = disp_map_[j * width_ + width_ - 1 - i];
}
if ( is_pre_proc_)
compute_impl(pp_ref_img_, pp_trg_img_);
else
compute_impl(ref_img, trg_img);
if ( is_lr_check_)
{
leftRightCheck();
}
//at the end, x_offset (*16) needs to be added to all computed disparities,
//so that each fixed point value of the disparity map represents the true disparity value multiplied by 16
for (int j = 0; j < height_; j++)
for (int i = 0; i < width_; i++)
if ( disp_map_[j * width_ + i] > 0)
disp_map_[j * width_ + i] += static_cast<short int> (x_off_ * 16);
}
void runCifar10()
{
/*state and cublas handle*/
cublasHandle_t handle;
init(handle);
/*read the data from disk*/
cuMatrixVector<float>trainX;
cuMatrixVector<float>testX;
cuMatrix<int>* trainY, *testY;
Config::instance()->initPath("Config/Cifar10Config.txt");
read_CIFAR10_Data(trainX, testX, trainY, testY);
preProcessing(trainX, testX);
const int nclasses = Config::instance()->getClasses();
/*build CNN net*/
int ImgSize = trainX[0]->rows;
Config::instance()->setImageSize(ImgSize - Config::instance()->getCrop());
int crop = Config::instance()->getCrop();
int nsamples = trainX.size();
int batch = Config::instance()->getBatchSize();
float start,end;
int cmd;
cuInitDistortionMemery(batch, ImgSize - crop);
printf("1. random init weight\n2. Read weight from file\nChoose the way to init weight:");
if(g_argv.size() >= 2)
cmd = g_argv[1];
else
if(1 != scanf("%d", &cmd)){
LOG("scanf fail", "result/log.txt");
}
buildNetWork(trainX.size(), testX.size());
if(cmd == 2)
cuReadConvNet(ImgSize - crop, "Result/checkPoint.txt", nclasses);
/*learning rate*/
std::vector<float>nlrate;
std::vector<float>nMomentum;
std::vector<int>epoCount;
nlrate.push_back(0.005f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.004f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.003f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.002f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.001f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0009f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0008f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0007f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0006f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0005f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0004f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0003f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0002f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.0001f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.00001f); nMomentum.push_back(0.90f); epoCount.push_back(50);
nlrate.push_back(0.000001f); nMomentum.push_back(0.90f); epoCount.push_back(50);
start = clock();
cuTrainNetwork(trainX, trainY, testX, testY, batch, ImgSize - crop, nclasses, nlrate, nMomentum, epoCount, handle);
end = clock();
char logStr[1024];
sprintf(logStr, "trainning time hours = %f\n",
(end - start) / CLOCKS_PER_SEC / 3600);
LOG(logStr, "Result/log.txt");
}
void bcg729Encoder(bcg729EncoderChannelContextStruct *encoderChannelContext, int16_t inputFrame[], uint8_t bitStream[])
{
int i;
uint16_t parameters[NB_PARAMETERS]; /* the output parameters in an array */
/* internal buffers which we do not need to keep between calls */
word16_t LPCoefficients[NB_LSP_COEFF]; /* the LP coefficients in Q3.12 */
word16_t qLPCoefficients[2*NB_LSP_COEFF]; /* the quantized LP coefficients in Q3.12 computed from the qLSP one after interpolation: two sets, one for each subframe */
word16_t weightedqLPCoefficients[2*NB_LSP_COEFF]; /* the qLP coefficients in Q3.12 weighted according to spec A3.3.3 */
word16_t LSPCoefficients[NB_LSP_COEFF]; /* the LSP coefficients in Q15 */
word16_t qLSPCoefficients[NB_LSP_COEFF]; /* the quantized LSP coefficients in Q15 */
word16_t interpolatedqLSP[NB_LSP_COEFF]; /* the interpolated qLSP used for first subframe in Q15 */
/*****************************************************************************************/
/*** on frame basis : preProcessing, LP Analysis, Open-loop pitch search ***/
preProcessing(encoderChannelContext, inputFrame, encoderChannelContext->signalLastInputFrame); /* output of the function in the signal buffer */
computeLP(encoderChannelContext->signalBuffer, LPCoefficients); /* use the whole signal Buffer for windowing and autocorrelation */
/*** compute LSP: it might fail, get the previous one in this case ***/
if (!LP2LSPConversion(LPCoefficients, LSPCoefficients)) {
/* unable to find the 10 roots repeat previous LSP */
memcpy(LSPCoefficients, encoderChannelContext->previousLSPCoefficients, NB_LSP_COEFF*sizeof(word16_t));
}
/*** LSPQuantization and compute L0, L1, L2, L3: the first four parameters ***/
LSPQuantization(encoderChannelContext, LSPCoefficients, qLSPCoefficients, parameters);
/*** interpolate qLSP and convert to LP ***/
interpolateqLSP(encoderChannelContext->previousqLSPCoefficients, qLSPCoefficients, interpolatedqLSP);
/* copy the currentqLSP to previousqLSP buffer */
for (i=0; i<NB_LSP_COEFF; i++) {
encoderChannelContext->previousqLSPCoefficients[i] = qLSPCoefficients[i];
}
/* first subframe */
qLSP2LP(interpolatedqLSP, qLPCoefficients);
/* second subframe */
qLSP2LP(qLSPCoefficients, &(qLPCoefficients[NB_LSP_COEFF]));
/*** Compute the weighted Quantized LP Coefficients according to spec A3.3.3 ***/
/* weightedqLPCoefficients[0] = qLPCoefficients[0]*Gamma^(i+1) (i=0..9) with Gamma = 0.75 in Q15 */
weightedqLPCoefficients[0] = MULT16_16_P15(qLPCoefficients[0], GAMMA_E1);
weightedqLPCoefficients[1] = MULT16_16_P15(qLPCoefficients[1], GAMMA_E2);
weightedqLPCoefficients[2] = MULT16_16_P15(qLPCoefficients[2], GAMMA_E3);
weightedqLPCoefficients[3] = MULT16_16_P15(qLPCoefficients[3], GAMMA_E4);
weightedqLPCoefficients[4] = MULT16_16_P15(qLPCoefficients[4], GAMMA_E5);
weightedqLPCoefficients[5] = MULT16_16_P15(qLPCoefficients[5], GAMMA_E6);
weightedqLPCoefficients[6] = MULT16_16_P15(qLPCoefficients[6], GAMMA_E7);
weightedqLPCoefficients[7] = MULT16_16_P15(qLPCoefficients[7], GAMMA_E8);
weightedqLPCoefficients[8] = MULT16_16_P15(qLPCoefficients[8], GAMMA_E9);
weightedqLPCoefficients[9] = MULT16_16_P15(qLPCoefficients[9], GAMMA_E10);
weightedqLPCoefficients[10] = MULT16_16_P15(qLPCoefficients[10], GAMMA_E1);
weightedqLPCoefficients[11] = MULT16_16_P15(qLPCoefficients[11], GAMMA_E2);
weightedqLPCoefficients[12] = MULT16_16_P15(qLPCoefficients[12], GAMMA_E3);
weightedqLPCoefficients[13] = MULT16_16_P15(qLPCoefficients[13], GAMMA_E4);
weightedqLPCoefficients[14] = MULT16_16_P15(qLPCoefficients[14], GAMMA_E5);
weightedqLPCoefficients[15] = MULT16_16_P15(qLPCoefficients[15], GAMMA_E6);
weightedqLPCoefficients[16] = MULT16_16_P15(qLPCoefficients[16], GAMMA_E7);
weightedqLPCoefficients[17] = MULT16_16_P15(qLPCoefficients[17], GAMMA_E8);
weightedqLPCoefficients[18] = MULT16_16_P15(qLPCoefficients[18], GAMMA_E9);
weightedqLPCoefficients[19] = MULT16_16_P15(qLPCoefficients[19], GAMMA_E10);
/*** Compute weighted signal according to spec A3.3.3, this function also set LPResidualSignal(entire frame values) as specified in eq A.3 in excitationVector[L_PAST_EXCITATION] ***/
computeWeightedSpeech(encoderChannelContext->signalCurrentFrame, qLPCoefficients, weightedqLPCoefficients, &(encoderChannelContext->weightedInputSignal[MAXIMUM_INT_PITCH_DELAY]), &(encoderChannelContext->excitationVector[L_PAST_EXCITATION])); /* weightedInputSignal contains MAXIMUM_INT_PITCH_DELAY values from previous frame, points to current frame */
/*** find the open loop pitch delay ***/
uint16_t openLoopPitchDelay = findOpenLoopPitchDelay(&(encoderChannelContext->weightedInputSignal[MAXIMUM_INT_PITCH_DELAY]));
/* define boundaries for closed loop pitch delay search as specified in 3.7 */
int16_t intPitchDelayMin = openLoopPitchDelay-3;
if (intPitchDelayMin < 20) {
intPitchDelayMin = 20;
}
int16_t intPitchDelayMax = intPitchDelayMin + 6;
if (intPitchDelayMax > MAXIMUM_INT_PITCH_DELAY) {
intPitchDelayMax = MAXIMUM_INT_PITCH_DELAY;
intPitchDelayMin = MAXIMUM_INT_PITCH_DELAY - 6;
}
/*****************************************************************************************/
/* loop over the two subframes: Closed-loop pitch search(adaptative codebook), fixed codebook, memory update */
/* set index and buffers */
int subframeIndex;
int LPCoefficientsIndex = 0;
int parametersIndex = 4; /* index to insert parameters in the parameters output array */
word16_t impulseResponseInput[L_SUBFRAME]; /* input buffer for the impulse response computation: in Q12, 1 followed by all zeros see spec A3.5*/
impulseResponseInput[0] = ONE_IN_Q12;
memset(&(impulseResponseInput[1]), 0, (L_SUBFRAME-1)*sizeof(word16_t));
for (subframeIndex=0; subframeIndex<L_FRAME; subframeIndex+=L_SUBFRAME) {
/*** Compute the impulse response : filter a subframe long buffer filled with unit and only zero through the 1/weightedqLPCoefficients as in spec A.3.5 ***/
word16_t impulseResponseBuffer[NB_LSP_COEFF+L_SUBFRAME]; /* impulseResponseBuffer in Q12, need NB_LSP_COEFF as past value to go through filtering function */
memset(impulseResponseBuffer, 0, (NB_LSP_COEFF)*sizeof(word16_t)); /* set the past values to zero */
synthesisFilter(impulseResponseInput, &(weightedqLPCoefficients[LPCoefficientsIndex]), &(impulseResponseBuffer[NB_LSP_COEFF]));
/*** Compute the target signal (x[n]) as in spec A.3.6 in Q0 ***/
/* excitationVector[L_PAST_EXCITATION+subframeIndex] currently store in Q0 the LPResidualSignal as in spec A.3.3 eq A.3*/
synthesisFilter( &(encoderChannelContext->excitationVector[L_PAST_EXCITATION+subframeIndex]), &(weightedqLPCoefficients[LPCoefficientsIndex]), &(encoderChannelContext->targetSignal[NB_LSP_COEFF]));
/*** Adaptative Codebook search : compute the intPitchDelay, fracPitchDelay and associated parameter, compute also the adaptative codebook vector used to generate the excitation ***/
/* after this call, the excitationVector[L_PAST_EXCITATION + subFrameIndex] contains the adaptative codebook vector as in spec 3.7.1 */
int16_t intPitchDelay, fracPitchDelay;
adaptativeCodebookSearch(&(encoderChannelContext->excitationVector[L_PAST_EXCITATION + subframeIndex]), &intPitchDelayMin, &intPitchDelayMax, &(impulseResponseBuffer[NB_LSP_COEFF]), &(encoderChannelContext->targetSignal[NB_LSP_COEFF]),
&intPitchDelay, &fracPitchDelay, &(parameters[parametersIndex]), subframeIndex);
/*** Compute adaptative codebook gain spec 3.7.3, result in Q14 ***/
/* compute the filtered adaptative codebook vector spec 3.7.3 */
/* this computation makes use of two partial results used for gainQuantization too (yy and xy in eq63), they are part of the function output */
/* note spec 3.7.3 eq44 make use of convolution of impulseResponse and adaptative codebook vector to compute the filtered version */
/* in the Annex A, the filter being simpler, it's faster to directly filter the the vector using the weightedqLPCoefficients */
word16_t filteredAdaptativeCodebookVector[NB_LSP_COEFF+L_SUBFRAME]; /* in Q0, the first NB_LSP_COEFF words are set to zero and used by filter only */
memset(filteredAdaptativeCodebookVector, 0, NB_LSP_COEFF*sizeof(word16_t));
synthesisFilter(&(encoderChannelContext->excitationVector[L_PAST_EXCITATION + subframeIndex]), &(weightedqLPCoefficients[LPCoefficientsIndex]), &(filteredAdaptativeCodebookVector[NB_LSP_COEFF]));
word64_t gainQuantizationXy, gainQuantizationYy; /* used to store in Q0 values reused in gain quantization */
word16_t adaptativeCodebookGain = computeAdaptativeCodebookGain(&(encoderChannelContext->targetSignal[NB_LSP_COEFF]), &(filteredAdaptativeCodebookVector[NB_LSP_COEFF]), &gainQuantizationXy, &gainQuantizationYy); /* gain in Q14 */
/* increase parameters index and compute P0 if needed */
parametersIndex++;
if (subframeIndex==0) { /* first subframe compute P0, the parity bit of P1 */
parameters[parametersIndex] = computeParity(parameters[parametersIndex-1]);
parametersIndex++;
}
/*** Fixed Codebook Search : compute the parameters for fixed codebook and the regular and convolved version of the fixed codebook vector ***/
word16_t fixedCodebookVector[L_SUBFRAME]; /* in Q13 */
word16_t convolvedFixedCodebookVector[L_SUBFRAME]; /* in Q12 */
fixedCodebookSearch(&(encoderChannelContext->targetSignal[NB_LSP_COEFF]), &(impulseResponseBuffer[NB_LSP_COEFF]), intPitchDelay, encoderChannelContext->lastQuantizedAdaptativeCodebookGain, &(filteredAdaptativeCodebookVector[NB_LSP_COEFF]), adaptativeCodebookGain,
&(parameters[parametersIndex]), &(parameters[parametersIndex+1]), fixedCodebookVector, convolvedFixedCodebookVector);
parametersIndex+=2;
/*** gains Quantization ***/
word16_t quantizedAdaptativeCodebookGain; /* in Q14 */
word16_t quantizedFixedCodebookGain; /* in Q1 */
gainQuantization(encoderChannelContext, &(encoderChannelContext->targetSignal[NB_LSP_COEFF]), &(filteredAdaptativeCodebookVector[NB_LSP_COEFF]), convolvedFixedCodebookVector, fixedCodebookVector, gainQuantizationXy, gainQuantizationYy,
&quantizedAdaptativeCodebookGain, &quantizedFixedCodebookGain, &(parameters[parametersIndex]), &(parameters[parametersIndex+1]));
parametersIndex+=2;
/*** subframe basis indexes and memory updates ***/
LPCoefficientsIndex+= NB_LSP_COEFF;
encoderChannelContext->lastQuantizedAdaptativeCodebookGain = quantizedAdaptativeCodebookGain;
if (encoderChannelContext->lastQuantizedAdaptativeCodebookGain>ONE_POINT_2_IN_Q14) encoderChannelContext->lastQuantizedAdaptativeCodebookGain = ONE_POINT_2_IN_Q14;
if (encoderChannelContext->lastQuantizedAdaptativeCodebookGain<O2_IN_Q14) encoderChannelContext->lastQuantizedAdaptativeCodebookGain = O2_IN_Q14;
/* compute excitation for current subframe as in spec A.3.10 */
/* excitationVector[L_PAST_EXCITATION + subframeIndex] currently contains in Q0 the adaptative codebook vector, quantizedAdaptativeCodebookGain in Q14 */
/* fixedCodebookVector in Q13, quantizedFixedCodebookGain in Q1 */
for (i=0; i<L_SUBFRAME; i++) {
encoderChannelContext->excitationVector[L_PAST_EXCITATION + subframeIndex + i] = (word16_t)(SATURATE(PSHR(ADD32(MULT16_16(encoderChannelContext->excitationVector[L_PAST_EXCITATION + subframeIndex + i], quantizedAdaptativeCodebookGain),
MULT16_16(fixedCodebookVector[i], quantizedFixedCodebookGain)), 14), MAXINT16)); /* result in Q0 */
}
/* update targetSignal memory as in spec A.3.10 */
quantizedAdaptativeCodebookGain = PSHR(quantizedAdaptativeCodebookGain, 1); /* quantizedAdaptativeCodebookGain in Q13 */
for (i=0; i<NB_LSP_COEFF; i++) {
/* targetSignal[i] = targetSignal[L_SUBFRAME+i] - quantizedAdaptativeCodebookGain*filteredAdaptativeCodebookVector[L_SUBFRAME+i] - quantizedFixedCodebookGain*convolvedFixedCodebookVector[L_SUBFRAME-NB_LSP_COEFF+i]*/
word32_t acc = MAC16_16(MULT16_16(quantizedAdaptativeCodebookGain, filteredAdaptativeCodebookVector[L_SUBFRAME+i]), quantizedFixedCodebookGain, convolvedFixedCodebookVector[L_SUBFRAME-NB_LSP_COEFF+i]); /* acc in Q13 */
encoderChannelContext->targetSignal[i] = (word16_t)(SATURATE(SUB32(encoderChannelContext->targetSignal[L_SUBFRAME+i], PSHR(acc, 13)), MAXINT16));
}
}
/*****************************************************************************************/
/*** frame basis memory updates ***/
/* shift left by L_FRAME the signal buffer */
memmove(encoderChannelContext->signalBuffer, &(encoderChannelContext->signalBuffer[L_FRAME]), (L_LP_ANALYSIS_WINDOW-L_FRAME)*sizeof(word16_t));
/* update previousLSP coefficient buffer */
memcpy(encoderChannelContext->previousLSPCoefficients, LSPCoefficients, NB_LSP_COEFF*sizeof(word16_t));
memcpy(encoderChannelContext->previousqLSPCoefficients, qLSPCoefficients, NB_LSP_COEFF*sizeof(word16_t));
/* shift left by L_FRAME the weightedInputSignal buffer */
memmove(encoderChannelContext->weightedInputSignal, &(encoderChannelContext->weightedInputSignal[L_FRAME]), MAXIMUM_INT_PITCH_DELAY*sizeof(word16_t));
/* shift left by L_FRAME the excitationVector */
memmove(encoderChannelContext->excitationVector, &(encoderChannelContext->excitationVector[L_FRAME]), L_PAST_EXCITATION*sizeof(word16_t));
/*** Convert array of parameters into bitStream ***/
parametersArray2BitStream(parameters, bitStream);
return;
}
void SolventAccessibleSurface::compute()
{
preProcessing();
get();
}