/*********************************************** Get the inner product of vectors from start row(sr), last rowLength-length input: the number of subjects, the number of blocks, the start row, the number of voxels of masked matrix one that involved in the computing, the trials information, the first masked data array, the second masked data array output: the partial similarity matrix based on the selected rows of first matrices and the whole second matrices ************************************************/ float* GetPartialInnerSimMatrixWithMasks(int nSubs, int nTrials, int sr, int rowLength, Trial* trials, RawMatrix** masked_matrices1, RawMatrix** masked_matrices2) // compute the correlation between masked matrices { int i; int row1 = masked_matrices1[0]->row; int row2 = masked_matrices2[0]->row; //rows should be the same across subjects since we are using the same mask file to filter out voxels float* values= new float[nTrials*rowLength*row2]; float* simMatrix = new float[nTrials*nTrials]; memset((void*)simMatrix, 0, nTrials*nTrials*sizeof(float)); for (i=0; i<nTrials; i++) { int sc = trials[i].sc; int ec = trials[i].ec; int sid = trials[i].sid; int col = masked_matrices1[sid]->col; // the column of 1 and 2 should be the same, i.e. the number of TRs of a block; columns may be different, since different subjects have different TRs float* mat1 = masked_matrices1[sid]->matrix; float* mat2 = masked_matrices2[sid]->matrix; float* buf1 = new float[row1*col]; // col is more than what really need, just in case float* buf2 = new float[row2*col]; // col is more than what really need, just in case int ml1 = getBuf(sc, ec, row1, col, mat1, buf1); // get the normalized matrix, return the length of time points to be computed int ml2 = getBuf(sc, ec, row2, col, mat2, buf2); // get the normalized matrix, return the length of time points to be computed, m1==m2 cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, rowLength, row2, ml1, 1.0, buf1+sr*ml1, ml1, buf2, ml2, 0.0, values+i*rowLength*row2, row2); delete[] buf1; delete[] buf2; } NormalizeCorrValues(values, nTrials, rowLength, row2, nSubs); GetDotProductUsingMatMul(simMatrix, values, nTrials, rowLength, row2); delete[] values; return simMatrix; }
/****************************** compute a corr-matrix based on trial, starting row and step input: a trial struct, starting row id, step (the row of the correlation matrix, whose column is row), the raw matrix struct array output: the corr-matrix struct *******************************/ CorrMatrix* CorrMatrixComputation(Trial trial, int sr, int step, RawMatrix** matrices1, RawMatrix** matrices2) { int sid = trial.sid; int sc = trial.sc; int ec = trial.ec; int row1 = matrices1[sid]->row; int row2 = matrices2[sid]->row; int col = matrices1[sid]->col; // the column of 1 and 2 should be the same, i.e. the number of TRs of a block float* mat1 = matrices1[sid]->matrix; float* mat2 = matrices2[sid]->matrix; float* buf1 = new float[row1*col]; // col is more than what really need, just in case float* buf2 = new float[row2*col]; // col is more than what really need, just in case int ml1 = getBuf(sc, ec, row1, col, mat1, buf1); // get the normalized matrix, return the length of time points to be computed int ml2 = getBuf(sc, ec, row2, col, mat2, buf2); // get the normalized matrix, return the length of time points to be computed, m1==m2 CorrMatrix* c_matrix = new CorrMatrix(); c_matrix->sid = sid; c_matrix->tlabel = trial.label; c_matrix->sr = sr; c_matrix->step = step; c_matrix->nVoxels = row2; // float* corrs = new float[step*row2]; cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, step, row2, ml1, 1.0, buf1+sr*ml1, ml1, buf2, ml2, 0.0, corrs, row2); c_matrix->matrix = corrs; delete[] buf1; delete[] buf2; return c_matrix; }
ossimDataObjectStatus ossimS16ImageData::validate() const { if (getBuf() == NULL) { setDataObjectStatus(OSSIM_NULL); return OSSIM_NULL; } ossim_uint32 count = 0; const ossim_uint32 SIZE = getSize(); const ossim_uint32 BOUNDS = getSizePerBand(); const ossim_uint32 NUMBER_OF_BANDS = getNumberOfBands(); for(ossim_uint32 band = 0; band < NUMBER_OF_BANDS; ++band) { ossim_sint16 np = (ossim_sint16)m_nullPixelValue[band]; const ossim_sint16* p = getSshortBuf(band); for (ossim_uint32 i=0; i<BOUNDS; i++) { // check if the band is null if (p[i] != np) count++; } } if (!count) setDataObjectStatus(OSSIM_EMPTY); else if (count == SIZE) setDataObjectStatus(OSSIM_FULL); else setDataObjectStatus(OSSIM_PARTIAL); return getDataObjectStatus(); }
void ossimU11ImageData::copyTileToNormalizedBuffer(ossim_uint32 band, float* buf) const { if (!buf) { ossimSetError(getClassName(), ossimErrorCodes::OSSIM_ERROR, "ossimU11ImageData::copyTileToNormalizedBuffer File %s line %d\nNull pointer passed to method!", __FILE__, __LINE__); return; } if(!getBuf(band)) return; ossim_uint32 size = getSizePerBand(); if(size > 0) { const ossim_uint16* s = getUshortBuf(band); // source float* d = buf; // destination for(ossim_uint32 index = 0; index < size; ++index) { *d = m_remapTable.normFromPix(static_cast<ossim_int32>(*s)); } } }
// row here is nTops, get the inner product of vectors from start row(sr), last rowLength-length float* GetPartialInnerSimMatrix(int row, int col, int nSubs, int nTrials, int sr, int rowLength, Trial* trials, RawMatrix** r_matrices) // only compute the correlation among the selected voxels { int i; float* values = new float[nTrials*rowLength*row]; float* simMatrix = new float[nTrials*nTrials]; for (i=0; i<nTrials*nTrials; i++) simMatrix[i] = 0.0; for (i=0; i<nTrials; i++) { int sc = trials[i].sc; int ec = trials[i].ec; int sid = trials[i].sid; float* mat = r_matrices[sid]->matrix; //if (i==0 && sr==0) cout<<mat[1000*col]<<" "<<mat[1000*col+1]<<" "<<mat[1000*col+2]<<" "<<mat[1000*col+3]<<endl; //else if (i==0 && sr!=0) cout<<mat[0]<<" "<<mat[1]<<" "<<mat[2]<<" "<<mat[3]<<endl; float* buf = new float[row*col]; // col is more than what really need, just in case int ml = getBuf(sc, ec, row, col, mat, buf); // get the normalized matrix, return the length of time points to be computed //cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, step, row, ml, 1.0, buf+sr*ml, ml, buf, ml, 0.0, corrs, row); cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, rowLength, row, ml, 1.0, buf+sr*ml, ml, buf, ml, 0.0, values+i*rowLength*row, row); delete[] buf; } NormalizeCorrValues(values, nTrials, rowLength, row, nSubs); GetDotProductUsingMatMul(simMatrix, values, nTrials, rowLength, row); delete[] values; return simMatrix; }
/********************************************************* Decompress Method *********************************************************/ int Compression::decompress(void *dest, int destLen, int sourceLen) { void *source = getBuf(); int compressingMethod = gConfig->networkCompression; uLongf newSource = sourceLen; uLongf newDest = destLen; int ret = 0; if(sourceLen > 4) { if(compressingMethod == 1) ret = uncompress((Bytef*) dest, (uLongf*) &newDest, (const Bytef*)source, newSource); else if(compressingMethod == 2) ret = lzo1b_decompress((const Bytef*)source, newSource, (Bytef*) dest, &newDest, NULL); else if(compressingMethod == 3) ret = lzo1x_decompress((const Bytef*)source, newSource, (Bytef*) dest, &newDest, NULL); if(compressingMethod == 1) { if(ret != Z_OK) { if(ret == Z_MEM_ERROR){ LOG("ERROR decompressing: memory error\n"); }else if(ret == Z_BUF_ERROR){ LOG("ERROR decompressing: buffer error\n"); }else if(ret == Z_DATA_ERROR){ LOG("ERROR decompressing: data error,\n"); } } } } else { memcpy(dest, source, sourceLen); } return (int)newDest; }
void ossimU11ImageData::copyNormalizedBufferToTile(ossim_uint32 band, float* buf) { if (!buf) { ossimSetError(getClassName(), ossimErrorCodes::OSSIM_ERROR, "ossimU11ImageData::copyTileToNormalizedBuffer File %s line %d\nNull pointer passed to method!", __FILE__, __LINE__); return; } ossim_uint32 size = getSizePerBand(); if((size > 0)&&getBuf(band)) { float* s = buf; // source ossim_uint16* d = getUshortBuf(band); // destination for(ossim_uint32 index = 0; index < size; ++index) { *d = m_remapTable.pixFromNorm(*s); ++d; ++s; } } }
bool SMSSendRequestPacket::getPacketContents(int conversion, char* &senderPhone, char* &recipientPhone, int &dataLength, byte* &data) { int position = REQUEST_HEADER_SIZE; dataLength = incReadShort(position); incReadByte(position); // smsType, currently not used here incReadString(position, senderPhone); incReadString(position, recipientPhone); data = getBuf() + position; char* tempBuf = new char[dataLength*6]; // Check if we should convert the SMS if ( conversion == CONVERSION_TEXT ) { dataLength = SMSConvUtil::gsmToMc2(tempBuf, (const char*)data, dataLength); } else { // Do not convert memcpy(tempBuf, data, dataLength); } // Swap data = reinterpret_cast<byte*>(tempBuf); return true; }
void USRTTask::_printStack( int bp ) { if( bp>=FIFOSIZE ) printf("Error too big bp\n"); printf("digraph G {\n"); int i; if( bp<getHead()->sp ) for( i=bp;i<getHead()->sp;i++ ) dump( (task_t*)getBuf(getHead()->fifo[i],0LL) ); else { for( i=getHead()->sp;i<FIFOSIZE;i++ ) dump( (task_t*)getBuf(getHead()->fifo[i],0LL) ); for( i=0;i<bp;i++ ) dump( (task_t*)getBuf(getHead()->fifo[i],0LL) ); } printf("}\n"); }
void CopyrightBoxReplyPacket:: getCopyrightHolder( CopyrightHolder& holder ) const { // load copyrights from packet BitBuffer buff( getBuf() + REPLY_HEADER_SIZE, MAX_PACKET_SIZE - REPLY_HEADER_SIZE ); holder.load( buff ); }
void ossimS16ImageData::fill(ossim_uint32 band, double value) { void* s = getBuf(band); if (s == NULL) return; // nothing to do... ossim_uint32 size_in_pixels = getSizePerBand(); ossim_sint16* p = getSshortBuf(band); for (ossim_uint32 i=0; i<size_in_pixels; i++) p[i] = (ossim_sint16)value; // Set the status to unknown since we don't know about the other bands. setDataObjectStatus(OSSIM_STATUS_UNKNOWN); }
unsigned int VFSFileZip::read(void *dst, unsigned int bytes) { VFS_GUARD_OPT(this); char *mem = (char*)getBuf(); char *startptr = mem + _pos; char *endptr = mem + size(); bytes = std::min((unsigned int)(endptr - startptr), bytes); // limit in case reading over buffer size if(_mode.find('b') == std::string::npos) strnNLcpy((char*)dst, (const char*)startptr, bytes); // non-binary == text mode else memcpy(dst, startptr, bytes); // binary copy _pos += bytes; return bytes; }
void ossimS16ImageData::copyTileToNormalizedBuffer(ossim_uint32 band, double* buf) const { if (!buf) { ossimSetError(getClassName(), ossimErrorCodes::OSSIM_ERROR, "ossimS16ImageData::copyTileToNormalizedBuffer File %s line %d\nNull pointer passed to method!", __FILE__, __LINE__); return; } if(!getBuf(band)) return; const ossim_uint32 SIZE = getSizePerBand(); if(SIZE) { const ossim_float64 RANGE = (getMaxPix(band)-getMinPix(band)+1); const ossim_sint16* s = getSshortBuf(band); // source double* d = buf; // destination for(ossim_uint32 index = 0; index < SIZE; ++index) { ossim_float64 p = s[index]; if (p == m_nullPixelValue[band]) { d[index] = 0.0; } else if (p >= m_maxPixelValue[band]) { d[index] = 1.0; } else { //--- // Normalize... // Note that this will shift any negatives to positive prior // to dividing. //--- d[index] = ((p-m_minPixelValue[band]+1) / RANGE); } } } }
CopyrightBoxReplyPacket:: CopyrightBoxReplyPacket( const CopyrightBoxRequestPacket* req, const CopyrightHolder& copyrights ): ReplyPacket( MAX_PACKET_SIZE, Packet::PACKETTYPE_COPYRIGHTBOX_REPLY, req, StringTable::OK ) { // write copyrights to packet BitBuffer buff( getBuf() + REPLY_HEADER_SIZE, MAX_PACKET_SIZE - REPLY_HEADER_SIZE ); copyrights.save( buff, 2 ); // 2 = include supplier ids // update size according to the buffer setLength( REPLY_HEADER_SIZE + buff.getCurrentOffset() ); }
void UART_isr(void) { int Source=U0IIR; // have to cache the interrupt id register // as the 'if' clause below were reading it // and hence changing its contents. if (Source & BIT2) // RX Interrupt { putBuf(&RXBuffer,U0RBR); } if (Source & BIT1) // TX Interrupt { if (TXBuffer.count > 0) U0THR = getBuf(&TXBuffer); } }
/** * Send a serialized error back to the client. * For a header server, this means serializing the exception, and setting * an error flag in the header. */ void HeaderServerChannel::HeaderRequest::sendError( std::exception_ptr ep, std::string exCode, MessageChannel::SendCallback* cb) { try { std::rethrow_exception(ep); } catch (const TApplicationException& ex) { channel_->header_->setHeader("ex", exCode); std::unique_ptr<folly::IOBuf> exbuf( serializeError(channel_->header_->getProtocolId(), ex, getBuf())); sendReply(std::move(exbuf), cb); } catch (const std::exception& ex) { // Other types are unimplemented. DCHECK(false); } }
int Compression::compress(void *input, int nByte) { void *output = getBuf(); int compressingMethod = gConfig->networkCompression; uLongf CompBuffSize = 0; if(compressingMethod == 1) CompBuffSize = (uLongf)(nByte + (nByte * 0.1) + 12); else CompBuffSize = (uLongf)(nByte + (nByte/1024 * 16 ) + 16); unsigned char * workingMemory = NULL; if(compressingMethod == 2) workingMemory = (unsigned char*)malloc(LZO1B_MEM_COMPRESS); else if(compressingMethod == 3) workingMemory = (unsigned char*)malloc(LZO1X_1_15_MEM_COMPRESS); int ret = 0; if(nByte > 4) { int compressLevel = 1; if(compressingMethod == 1) ret = compress2((Bytef *) output, &CompBuffSize, (Bytef *) input, nByte, compressLevel); else if(compressingMethod == 2) ret = lzo1b_compress((Bytef *) input, nByte, (Bytef *) output, &CompBuffSize, workingMemory, compressLevel); else if(compressingMethod == 3) ret = lzo1x_1_15_compress((Bytef *) input, nByte, (Bytef *) output, &CompBuffSize, workingMemory); if(compressingMethod == 1) { if(ret != Z_OK) { if(ret == Z_MEM_ERROR){ LOG("ERROR compressing: memory error\n"); }else if(ret == Z_BUF_ERROR){ LOG("ERROR compressing: buffer error\n"); }else if(ret == Z_STREAM_ERROR){ LOG("ERROR compressing: compressLevel not (1-9), %d\n", compressLevel); } } } } else { memcpy(output, input, nByte); CompBuffSize = nByte; } if(compressingMethod == 2 || compressingMethod == 3) free(workingMemory); return CompBuffSize; }
void ossimS16ImageData::setValue(ossim_int32 x, ossim_int32 y, double color) { if(getBuf() != NULL && isWithin(x, y)) { //*** // Compute the offset into the buffer for (x,y). This should always // come out positive. //*** ossim_uint32 ux = static_cast<ossim_uint32>(x - m_origin.x); ossim_uint32 uy = static_cast<ossim_uint32>(y - m_origin.y); ossim_uint32 offset = uy * m_spatialExtents[0] + ux; for(ossim_uint32 band = 0; band < m_numberOfDataComponents; band++) { ossim_sint16* buf = getSshortBuf(band)+offset; *buf = (ossim_sint16)color; } } }
// row here is nTops, most of the time is function is not practical due to out of memory float* GetInnerSimMatrix(int row, int col, int nTrials, Trial* trials, RawMatrix** r_matrices) // only compute the correlation among the selected voxels { int i; float* values = new float[nTrials*row*row]; float* simMatrix = new float[nTrials*nTrials]; for (i=0; i<nTrials*nTrials; i++) simMatrix[i] = 0.0; for (i=0; i<nTrials; i++) { int sc = trials[i].sc; int ec = trials[i].ec; int sid = trials[i].sid; float* mat = r_matrices[sid]->matrix; float* buf = new float[row*col]; // col is more than what really need, just in case int ml = getBuf(sc, ec, row, col, mat, buf); // get the normalized matrix, return the length of time points to be computed cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, row, row, ml, 1.0, buf, ml, buf, ml, 0.0, values+i*row*row, row); delete[] buf; } GetDotProductUsingMatMul(simMatrix, values, nTrials, row, row); delete[] values; return simMatrix; }
void HeaderServerChannel::HeaderRequest::sendReplyWithStreams( std::unique_ptr<folly::IOBuf>&& data, std::unique_ptr<StreamManager>&& manager, MessageChannel::SendCallback* sendCallback) { if (clientExpectsStreams_) { CHECK(outOfOrder_); Stream* stream = nullptr; try { stream = new Stream(channel_, seqId_, transforms_, headers_, streamTimeout_, getBuf()->clone(), std::move(manager), sendCallback); channel_->header_->setSequenceNumber(seqId_); channel_->header_->setTransforms(transforms_); channel_->sendStreamingMessage(stream, std::move(data), HEADER_FLAG_STREAM_BEGIN); // since this function is never called across threads // streamPtrReturn_ will always remain valid *streamPtrReturn_ = stream; } catch (const std::exception& e) { LOG(ERROR) << "Failed to send message: " << e.what(); delete stream; } } else { manager->cancel(); sendReply(std::move(data)); } }
bool SMSSendRequestPacket::getPacketContents(int conversion, char* &senderPhone, char* &recipientPhone, int &dataLength, byte* &data, int& smsNumber, int& nbrParts, int& partNbr) { int position = REQUEST_HEADER_SIZE; dataLength = incReadShort(position); incReadByte(position); // skip smsType incReadString(position, senderPhone); incReadString(position, recipientPhone); data = getBuf() + position; position += dataLength; char* tempBuf = new char[dataLength*6]; // Check if we should convert the SMS if ( conversion == CONVERSION_TEXT ) { dataLength = SMSConvUtil::gsmToMc2(tempBuf, (const char*)data, dataLength); } else { // Do not convert memcpy(tempBuf, data, dataLength); } // Swap data = reinterpret_cast<byte*>(tempBuf); if ( position < (int)getLength() ) { smsNumber = incReadByte(position); nbrParts = incReadByte(position); partNbr = incReadByte(position); } else { smsNumber = nbrParts = partNbr = -1; } return true; }
int L4Handler::onWriteEx() { bool full = ((getBuf()->available() == 0) ? true : false); int length; while ((length = getBuf()->blockSize()) > 0 ) { int n = getStream()->write(getBuf()->begin(), length); if ( D_ENABLED( DL_LESS ) ) LOG_D ((getLogger(), "[%s] L4Handler: write [%d of %d]", getLogId(), n, length )); if (n > 0) getBuf()->pop_front(n); else if ( n == 0 ) break; else // if (n < 0) { closeBothConnection(); return -1; } } if (getBuf()->available() != 0) { if (full) m_pL4conn->continueRead(); if ( getBuf()->empty() ) { suspendWrite(); if ( D_ENABLED( DL_LESS ) ) { LOG_D(( getLogger(), "[%s] [L4conn] m_pL4conn->continueRead", getLogId() )); } } } return 0; }
int ExynosJpegDecoder::getInBuf(char **pcBuf, int *piInputSize) { return getBuf(t_bFlagCreateInBuf, &t_stJpegInbuf, pcBuf, piInputSize, \ NUM_JPEG_DEC_IN_PLANES, NUM_JPEG_DEC_IN_PLANES); }
int ExynosJpegDecoder::getOutBuf(char **pcBuf, int *piOutputSize, int iSize) { return getBuf(t_bFlagCreateOutBuf, &t_stJpegOutbuf, pcBuf, piOutputSize, iSize, t_iPlaneNum); }
char egetc() { return getBuf(&RXBuffer); }
void * BufPair::getBufData(ATADataPacketHeader::PolarizationCode pol) { Buffer *buf = getBuf(pol); return (buf->getData()); }
/** * Wrap sqlite3_column_blob and sqlite3_column_bytes to return a new Blob. * @param column The column. * @return The new Blob. */ Blob getBlob(int column) { return Blob(getBuf(column), getSize(column)); }