void BaseAnimationState::handleScreenChanged() { #ifndef BACKEND_8BIT const int screenW = _sys->getOverlayWidth(); const int screenH = _sys->getOverlayHeight(); int newScale = MIN(screenW / _movieWidth, screenH / _movieHeight); assert(newScale >= 1); if (newScale > 3) newScale = 3; if (newScale != _movieScale) { // HACK: Since frames generally do not cover the entire screen, // We need to undraw the old frame. This is a very hacky // way of doing that. OverlayColor *buf = (OverlayColor *)calloc(screenW * screenH, sizeof(OverlayColor)); _sys->copyRectToOverlay(buf, screenW, 0, 0, screenW, screenH); free(buf); free(_overlay); _movieScale = newScale; _overlay = (OverlayColor *)calloc(_movieScale * _movieWidth * _movieScale * _movieHeight, sizeof(OverlayColor)); } buildLookup(); #endif }
ControlSeqParser::ControlSeqParser() { m_seq = NULL; m_savedPos = 0; m_values = (int *)malloc(sizeof(int) * MAX_NUM_VALUES); reset(); buildLookup(); }
bool BaseAnimationState::decodeFrame() { #ifdef USE_MPEG2 mpeg2_state_t state; const mpeg2_sequence_t *sequence_i; size_t size = (size_t) -1; static byte buf[BUFFER_SIZE]; do { state = mpeg2_parse(_mpegDecoder); sequence_i = _mpegInfo->sequence; switch (state) { case STATE_BUFFER: size = _mpegFile->read(buf, BUFFER_SIZE); mpeg2_buffer(_mpegDecoder, buf, buf + size); break; case STATE_SLICE: case STATE_END: if (_mpegInfo->display_fbuf) { checkPaletteSwitch(); drawYUV(sequence_i->width, sequence_i->height, _mpegInfo->display_fbuf->buf); #ifdef BACKEND_8BIT buildLookup(_palNum + 1, _lutCalcNum); #endif _frameNum++; return true; } break; default: break; } } while (size); #endif return false; }
ControlSeqParser::ControlSeqParser() : m_state(ST_START), m_seq(NULL), m_mode(MODE_UTF8), m_utf8_remlen(0), m_vt52(false) { buildLookup(); }
// [E,ind,segs] = mexFunction(model,I,chns,chnsSs) - helper for edgesDetect.m void mexFunction( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) { // get inputs mxArray *model = (mxArray*) pr[0]; float *I = (float*) mxGetData(pr[1]); float *feats = (float*) mxGetData(pr[2]); // extract relevant fields from model and options float *thrs = (float*) mxGetData(mxGetField(model,0,"thrs")); uint32 *fids = (uint32*) mxGetData(mxGetField(model,0,"fids")); uint32 *child = (uint32*) mxGetData(mxGetField(model,0,"child")); uint8 *segs = (uint8*) mxGetData(mxGetField(pr[0],0,"segs")); uint8 *nSegs = (uint8*) mxGetData(mxGetField(pr[0],0,"nSegs")); uint16 *eBins = (uint16*) mxGetData(mxGetField(model,0,"eBins")); uint32 *eBnds = (uint32*) mxGetData(mxGetField(model,0,"eBnds")); mxArray *opts = mxGetField(model,0,"opts"); const int shrink = (int) mxGetScalar(mxGetField(opts,0,"shrink")); const int imWidth = (int) mxGetScalar(mxGetField(opts,0,"imWidth")); const int gtWidth = (int) mxGetScalar(mxGetField(opts,0,"gtWidth")); const int nChns = (int) mxGetScalar(mxGetField(opts,0,"nChns")); const int nCells = (int) mxGetScalar(mxGetField(opts,0,"nCells")); const uint32 nTotFtrs = (uint32) mxGetScalar(mxGetField(opts,0,"nTotFtrs")); const int stride = (int) mxGetScalar(mxGetField(opts,0,"stride")); const int nTreesEval = (int) mxGetScalar(mxGetField(opts,0,"nTreesEval")); int sharpen = (int) mxGetScalar(mxGetField(opts,0,"sharpen")); int nThreads = (int) mxGetScalar(mxGetField(opts,0,"nThreads")); const int nBnds = int(mxGetNumberOfElements(mxGetField(model,0,"eBnds"))-1)/ int(mxGetNumberOfElements(mxGetField(model,0,"thrs"))); const char *msgSharpen="Model supports sharpening of at most %i pixels!\n"; if( sharpen>nBnds-1 ) { sharpen=nBnds-1; mexPrintf(msgSharpen,sharpen); } // get dimensions and constants const mwSize *imgSize = mxGetDimensions(pr[1]); const int h = (int) imgSize[0]; const int w = (int) imgSize[1]; const int Z = mxGetNumberOfDimensions(pr[1])<=2 ? 1 : imgSize[2]; const mwSize *fidsSize = mxGetDimensions(mxGetField(model,0,"fids")); const int nTreeNodes = (int) fidsSize[0]; const int nTrees = (int) fidsSize[1]; const int h1 = (int) ceil(double(h-imWidth)/stride); const int w1 = (int) ceil(double(w-imWidth)/stride); const int h2 = h1*stride+gtWidth; const int w2 = w1*stride+gtWidth; const int imgDims[3] = {h,w,Z}; const int chnDims[3] = {h/shrink,w/shrink,nChns}; const int indDims[3] = {h1,w1,nTreesEval}; const int outDims[3] = {h2,w2,1}; const int segDims[5] = {gtWidth,gtWidth,h1,w1,nTreesEval}; // construct lookup tables uint32 *iids, *eids, *cids; iids = buildLookup( (int*)imgDims, gtWidth ); eids = buildLookup( (int*)outDims, gtWidth ); cids = buildLookup( (int*)chnDims, floor((double)2/shrink + 0.5)); //cids = buildLookup( (int*)chnDims, 1 ); // create outputs pl[0] = mxCreateNumericArray(3,outDims,mxSINGLE_CLASS,mxREAL); float *E = (float*) mxGetData(pl[0]); pl[1] = mxCreateNumericArray(3,indDims,mxUINT32_CLASS,mxREAL); uint32 *ind = (uint32*) mxGetData(pl[1]); if(nl>2) pl[2] = mxCreateNumericArray(5,segDims,mxUINT8_CLASS,mxREAL); uint8 *segsOut; if(nl>2) segsOut = (uint8*) mxGetData(pl[2]); // apply forest to all patches and store leaf inds #ifdef USEOMP nThreads = min(nThreads,omp_get_max_threads()); #pragma omp parallel for num_threads(nThreads) #endif for( int c=0; c<w1; c++ ) for( int t=0; t<nTreesEval; t++ ) { for( int r0=0; r0<2; r0++ ) for( int r=r0; r<h1; r+=2 ) { int o = (r*stride/shrink) + (c*stride/shrink)*h/shrink; // select tree to evaluate int t1 = ((r+c)%2*nTreesEval+t)%nTrees; uint32 k = t1*nTreeNodes; while( child[k] ) { // compute feature (either channel or self-similarity feature) uint32 f = fids[k]; float ftr; ftr = feats[cids[f]+o]; // compare ftr to threshold and move left or right accordingly if( ftr < thrs[k] ) k = child[k]-1; else k = child[k]; k += t1*nTreeNodes; } // store leaf index and update edge maps ind[ r + c*h1 + t*h1*w1 ] = k; } } // compute edge maps (avoiding collisions from parallel executions) if( !sharpen ) for( int c0=0; c0<gtWidth/stride; c0++ ) { #ifdef USEOMP #pragma omp parallel for num_threads(nThreads) #endif for( int c=c0; c<w1; c+=gtWidth/stride ) { for( int r=0; r<h1; r++ ) for( int t=0; t<nTreesEval; t++ ) { uint32 k = ind[ r + c*h1 + t*h1*w1 ]; float *E1 = E + (r*stride) + (c*stride)*h2; int b0=eBnds[k*nBnds], b1=eBnds[k*nBnds+1]; if(b0==b1) continue; for( int b=b0; b<b1; b++ ) E1[eids[eBins[b]]]++; if(nl>2) memcpy(segsOut+(r+c*h1+t*h1*w1)*gtWidth*gtWidth, segs+k*gtWidth*gtWidth,gtWidth*gtWidth*sizeof(uint8)); } } } // computed sharpened edge maps, snapping to local color values if( sharpen ) { // compute neighbors array const int g=gtWidth; uint16 N[4096*4]; for( int c=0; c<g; c++ ) for( int r=0; r<g; r++ ) { int i=c*g+r; uint16 *N1=N+i*4; N1[0] = c>0 ? i-g : i; N1[1] = c<g-1 ? i+g : i; N1[2] = r>0 ? i-1 : i; N1[3] = r<g-1 ? i+1 : i; } #ifdef USEOMP #pragma omp parallel for num_threads(nThreads) #endif for( int c=0; c<w1; c++ ) for( int r=0; r<h1; r++ ) { for( int t=0; t<nTreesEval; t++ ) { // get current segment and copy into S uint32 k = ind[ r + c*h1 + t*h1*w1 ]; int m = nSegs[k]; if( m==1 ) continue; uint8 S0[4096], *S=(nl<=2) ? S0 : segsOut+(r+c*h1+t*h1*w1)*g*g; memcpy(S,segs+k*g*g, g*g*sizeof(uint8)); // compute color model for each segment using every other pixel int ci, ri, s, z; float ns[100], mus[1000]; const float *I1 = I+(c*stride+(imWidth-g)/2)*h+r*stride+(imWidth-g)/2; for( s=0; s<m; s++ ) { ns[s]=0; for( z=0; z<Z; z++ ) mus[s*Z+z]=0; } for( ci=0; ci<g; ci+=2 ) for( ri=0; ri<g; ri+=2 ) { s = S[ci*g+ri]; ns[s]++; for( z=0; z<Z; z++ ) mus[s*Z+z]+=I1[z*h*w+ci*h+ri]; } for(s=0; s<m; s++) for( z=0; z<Z; z++ ) mus[s*Z+z]/=ns[s]; // update segment S according to local color values int b0=eBnds[k*nBnds], b1=eBnds[k*nBnds+sharpen]; for( int b=b0; b<b1; b++ ) { float vs[10], d, e, eBest=1e10f; int i, sBest=-1, ss[4]; for( i=0; i<4; i++ ) ss[i]=S[N[eBins[b]*4+i]]; for( z=0; z<Z; z++ ) vs[z]=I1[iids[eBins[b]]+z*h*w]; for( i=0; i<4; i++ ) { s=ss[i]; if(s==sBest) continue; e=0; for( z=0; z<Z; z++ ) { d=mus[s*Z+z]-vs[z]; e+=d*d; } if( e<eBest ) { eBest=e; sBest=s; } } S[eBins[b]]=sBest; } // convert mask to edge maps (examining expanded set of pixels) float *E1 = E + c*stride*h2 + r*stride; b1=eBnds[k*nBnds+sharpen+1]; for( int b=b0; b<b1; b++ ) { int i=eBins[b]; uint8 s=S[i]; uint16 *N1=N+i*4; if( s!=S[N1[0]] || s!=S[N1[1]] || s!=S[N1[2]] || s!=S[N1[3]] ) E1[eids[i]]++; } } } } // free memory delete [] iids; delete [] eids; delete [] cids; }
/** * Encodes a set of data with DC's version of huffman encoding.. * @todo Use real streams maybe? or something else than string (operator[] contains a compare, slow...) */ void CryptoManager::encodeHuffman(const string& is, string& os) { // We might as well expect this much data as huffman encoding doesn't go very far... os.reserve(is.size()); if(is.length() == 0) { os.append("HE3\x0d"); // Nada... os.append(7, '\0'); return; } // First, we count all characters u_int8_t csum = 0; int count[256]; memset(count, 0, sizeof(count)); int chars = countChars(is, count, csum); // Next, we create a set of nodes and add it to a list, removing all characters that never occur. list<Node*> nodes; int i; for(i=0; i<256; i++) { if(count[i] > 0) { nodes.push_back(new Node(i, count[i])); } } nodes.sort(greaterNode()); #ifdef _DEBUG for(list<Node*>::iterator it = nodes.begin(); it != nodes.end(); ++it) dcdebug("%.02x:%d, ", (*it)->chr, (*it)->weight); dcdebug("\n"); #endif walkTree(nodes); dcassert(nodes.size() == 1); Node* root = nodes.front(); vector<u_int8_t> lookup[256]; // Build a lookup table for fast character lookups buildLookup(lookup, root); delete root; // Reserve some memory to avoid all those copies when appending... os.reserve(is.size() * 3 / 4); os.append("HE3\x0d"); // Checksum os.append(1, csum); string::size_type sz = is.size(); os.append((char*)&sz, 4); // Character count os.append((char*)&chars, 2); // The characters and their bitlengths for(i=0; i<256; i++) { if(count[i] > 0) { os.append(1, (u_int8_t)i); os.append(1, (u_int8_t)lookup[i].size()); } } BitOutputStream bos(os); // The tree itself, ie the bits of each character for(i=0; i<256; i++) { if(count[i] > 0) { bos.put(lookup[i]); } } dcdebug("u_int8_ts: %d\n", os.size()); bos.skipToByte(); for(string::size_type j=0; j<is.size(); j++) { dcassert(lookup[(u_int8_t)is[j]].size() != 0); bos.put(lookup[(u_int8_t)is[j]]); } bos.skipToByte(); }
bool BaseAnimationState::init(const char *name) { #ifdef USE_MPEG2 char tempFile[512]; _mpegDecoder = NULL; _mpegFile = NULL; #ifdef BACKEND_8BIT uint i, p; // Load lookup palettes sprintf(tempFile, "%s.pal", name); Common::File f; if (!f.open(tempFile)) { warning("Cutscene: %s palette missing", tempFile); return false; } p = 0; while (!f.eos()) { _palettes[p].end = f.readUint16LE(); _palettes[p].cnt = f.readUint16LE(); for (i = 0; i < _palettes[p].cnt; i++) { _palettes[p].pal[4 * i] = f.readByte(); _palettes[p].pal[4 * i + 1] = f.readByte(); _palettes[p].pal[4 * i + 2] = f.readByte(); _palettes[p].pal[4 * i + 3] = 0; } for (; i < 256; i++) { _palettes[p].pal[4 * i] = 0; _palettes[p].pal[4 * i + 1] = 0; _palettes[p].pal[4 * i + 2] = 0; _palettes[p].pal[4 * i + 3] = 0; } p++; } f.close(); _palNum = 0; _maxPalNum = p; setPalette(_palettes[_palNum].pal); _lut = _lut2 = _yuvLookup[0]; _curPal = -1; _cr = 0; buildLookup(_palNum, 256); _lut2 = _yuvLookup[1]; _lutCalcNum = (BITDEPTH + _palettes[_palNum].end + 2) / (_palettes[_palNum].end + 2); #else buildLookup(); _overlay = (OverlayColor *)calloc(_movieScale * _movieWidth * _movieScale * _movieHeight, sizeof(OverlayColor)); _sys->showOverlay(); #endif // Open MPEG2 stream _mpegFile = new Common::File(); sprintf(tempFile, "%s.mp2", name); if (!_mpegFile->open(tempFile)) { warning("Cutscene: Could not open %s", tempFile); return false; } // Load and configure decoder _mpegDecoder = mpeg2_init(); if (_mpegDecoder == NULL) { warning("Cutscene: Could not allocate an MPEG2 decoder"); return false; } _mpegInfo = mpeg2_info(_mpegDecoder); _frameNum = 0; return true; #else /* USE_MPEG2 */ return false; #endif }
// ind = mexFunction(model,chns,chnsSs) void mexFunction( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) { // get inputs mxArray *model = (mxArray*) pr[0]; float *chns = (float*) mxGetData(pr[1]); float *chnsSs = (float*) mxGetData(pr[2]); // extract relevant fields from model and options float *thrs = (float*) mxGetData(mxGetField(model,0,"thrs")); uint32 *fids = (uint32*) mxGetData(mxGetField(model,0,"fids")); uint32 *child = (uint32*) mxGetData(mxGetField(model,0,"child")); mxArray *opts = mxGetField(model,0,"opts"); const int shrink = (int) mxGetScalar(mxGetField(opts,0,"shrink")); const int imWidth = (int) mxGetScalar(mxGetField(opts,0,"imWidth")); const int nChns = (int) mxGetScalar(mxGetField(opts,0,"nChns")); const int nCells = (int) mxGetScalar(mxGetField(opts,0,"nCells")); const uint32 nChnFtrs = (uint32) mxGetScalar(mxGetField(opts,0,"nChnFtrs")); const int stride = (int) mxGetScalar(mxGetField(opts,0,"stride")); const int nTreesEval = (int) mxGetScalar(mxGetField(opts,0,"nTreesEval")); int nThreads = (int) mxGetScalar(mxGetField(opts,0,"nThreads")); // get dimensions and constants const mwSize *chnsSize = mxGetDimensions(pr[1]); const int h = (int) chnsSize[0]*shrink; const int w = (int) chnsSize[1]*shrink; const mwSize *fidsSize = mxGetDimensions(mxGetField(model,0,"fids")); const int nTreeNodes = (int) fidsSize[0]; const int nTrees = (int) fidsSize[1]; const int h1 = (int) ceil(double(h-imWidth)/stride); const int w1 = (int) ceil(double(w-imWidth)/stride); const int chnDims[3] = {h/shrink,w/shrink,nChns}; const int indDims[3] = {h1,w1,nTreesEval}; // construct lookup tables uint32 *cids, *cids1, *cids2; cids = buildLookup( (int*)chnDims, imWidth/shrink ); buildLookupSs( cids1, cids2, (int*)chnDims, imWidth/shrink, nCells ); // create output pl[0] = mxCreateNumericArray(3,indDims,mxUINT32_CLASS,mxREAL); uint32 *ind = (uint32*) mxGetData(pl[0]); // apply forest to all patches and store leaf inds #ifdef USEOMP nThreads = min(nThreads,omp_get_max_threads()); #pragma omp parallel for num_threads(nThreads) #endif for( int c=0; c<w1; c++ ) for( int t=0; t<nTreesEval; t++ ) { for( int r0=0; r0<2; r0++ ) for( int r=r0; r<h1; r+=2 ) { int o = (r*stride/shrink) + (c*stride/shrink)*h/shrink; // select tree to evaluate int t1 = ((r+c)%2*nTreesEval+t)%nTrees; uint32 k = t1*nTreeNodes; while( child[k] ) { // compute feature (either channel or self-similarity feature) uint32 f = fids[k]; float ftr; if( f<nChnFtrs ) ftr = chns[cids[f]+o]; else ftr = chnsSs[cids1[f-nChnFtrs]+o]-chnsSs[cids2[f-nChnFtrs]+o]; // compare ftr to threshold and move left or right accordingly if( ftr < thrs[k] ) k = child[k]-1; else k = child[k]; k += t1*nTreeNodes; } // store leaf index ind[ r + c*h1 + t*h1*w1 ] = k; } } delete [] cids; delete [] cids1; delete [] cids2; }
// [E,ind] = mexFunction(model,chns,chnsSsi, chnsNormal) - helper for edgesDetect.m void mexFunction( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) { // get inputs mxArray *model = (mxArray*) pr[0]; float *chns = (float*) mxGetData(pr[1]); float *chnsSs = (float*) mxGetData(pr[2]); float *chnsNormal = (float*) mxGetData(pr[3]); // extract relevant fields from model and options float *thrs = (float*) mxGetData(mxGetField(model,0,"thrs")); uint32 *fids = (uint32*) mxGetData(mxGetField(model,0,"fids")); uint32 *child = (uint32*) mxGetData(mxGetField(model,0,"child")); uint16 *eBins = (uint16*) mxGetData(mxGetField(model,0,"eBins")); uint32 *eBnds = (uint32*) mxGetData(mxGetField(model,0,"eBnds")); mxArray *opts = mxGetField(model,0,"opts"); const int shrink = (int) mxGetScalar(mxGetField(opts,0,"shrink")); const int imWidth = (int) mxGetScalar(mxGetField(opts,0,"imWidth")); const int gtWidth = (int) mxGetScalar(mxGetField(opts,0,"gtWidth")); const int nChns = (int) mxGetScalar(mxGetField(opts,0,"nChns")); const int nCells = (int) mxGetScalar(mxGetField(opts,0,"nCells")); const int nNormalCells = (int) mxGetScalar(mxGetField(opts,0,"nNormalCells")); const int nNormalFtrs = nNormalCells*nNormalCells*(nNormalCells*nNormalCells-1)/2; const uint32 nChnFtrs = (uint32) mxGetScalar(mxGetField(opts,0,"nChnFtrs")); const uint32 nSimFtrs = (uint32) mxGetScalar(mxGetField(opts,0,"nSimFtrs")); const uint32 nNormalFtrsAll = (uint32) mxGetScalar(mxGetField(opts,0,"nNormalFtrs")); const int nEdgeBins = (int) mxGetScalar(mxGetField(opts,0,"nEdgeBins")); const int stride = (int) mxGetScalar(mxGetField(opts,0,"stride")); const int nTreesEval = (int) mxGetScalar(mxGetField(opts,0,"nTreesEval")); int nThreads = (int) mxGetScalar(mxGetField(opts,0,"nThreads")); // get dimensions and constants const mwSize *chnsSize = mxGetDimensions(pr[1]); const int h = (int) chnsSize[0]*shrink; const int w = (int) chnsSize[1]*shrink; const mwSize *fidsSize = mxGetDimensions(mxGetField(model,0,"fids")); const int nTreeNodes = (int) fidsSize[0]; const int nTrees = (int) fidsSize[1]; const int h1 = (int) ceil(double(h-imWidth)/stride); const int w1 = (int) ceil(double(w-imWidth)/stride); const int h2 = h1*stride+gtWidth; const int w2 = w1*stride+gtWidth; const int chnDims[3] = {h/shrink,w/shrink,nChns}; const int normalDims[3] = {h/shrink,w/shrink,nNormalFtrs}; const int indDims[3] = {h1,w1,nTreesEval}; const int outDims[3] = {h2,w2,nEdgeBins}; // construct lookup tables uint32 *eids, *cids, *cids1, *cids2; eids = buildLookup( (int*)outDims, gtWidth ); cids = buildLookup( (int*)chnDims, imWidth/shrink ); buildLookupSs( cids1, cids2, (int*)chnDims, imWidth/shrink, nCells ); uint32 *nids; nids = buildLookup( (int*)normalDims, 1); // mexPrintf("Computed all look up tables.\n"); // mexPrintf("Size of normalDims - %d, %d, %d\n", normalDims[0], normalDims[1], normalDims[2]); // create outputs pl[0] = mxCreateNumericArray(3,outDims,mxSINGLE_CLASS,mxREAL); float *E = (float*) mxGetData(pl[0]); pl[1] = mxCreateNumericArray(3,indDims,mxUINT32_CLASS,mxREAL); uint32 *ind = (uint32*) mxGetData(pl[1]); // apply forest to all patches and store leaf inds // #ifdef USEOMP // nThreads = min(nThreads,omp_get_max_threads()); // #pragma omp parallel for num_threads(nThreads) // #endif for( int c=0; c<w1; c++ ) for( int t=0; t<nTreesEval; t++ ) { for( int r0=0; r0<2; r0++ ) for( int r=r0; r<h1; r+=2 ) { int o = (r*stride/shrink) + (c*stride/shrink)*h/shrink; // select tree to evaluate int t1 = ((r+c)%2*nTreesEval+t)%nTrees; uint32 k = t1*nTreeNodes; while( child[k] ) { // compute feature (either channel or self-similarity feature) uint32 f = fids[k]; float ftr; if( f<nChnFtrs ) ftr = chns[cids[f]+o]; else { if(f<nChnFtrs+nSimFtrs){ ftr = chnsSs[cids1[f-nChnFtrs]+o]-chnsSs[cids2[f-nChnFtrs]+o]; } else{ // for(int i = 0; i < 300; i++) mexPrintf("%d: %d\n", i, nids[i]); mexPrintf("\n\n\n"); // normal self similarity features // mexPrintf("%d, ", f); uint32 ff = f-nChnFtrs-nSimFtrs; while(ff >= nNormalFtrs) ff = ff-nNormalFtrs; // mexPrintf("%d, nids: %d, ", ff, nids[ff]); ftr = chnsNormal[nids[ff]+o]; } } // compare ftr to threshold and move left or right accordingly if( ftr < thrs[k] ) k = child[k]-1; else k = child[k]; k += t1*nTreeNodes; } // store leaf index and update edge maps ind[ r + c*h1 + t*h1*w1 ] = k; } } // compute edge maps (avoiding collisions from parallel executions) for( int c0=0; c0<gtWidth/stride; c0++ ) { #ifdef USEOMP #pragma omp parallel for num_threads(nThreads) #endif for( int c=c0; c<w1; c+=gtWidth/stride ) { for( int r=0; r<h1; r++ ) for( int t=0; t<nTreesEval; t++ ) { uint32 k = ind[ r + c*h1 + t*h1*w1 ]; float *E1 = E + (r*stride) + (c*stride)*h2; int b0=eBnds[k], b1=eBnds[k+1]; if(b0==b1) continue; for( int b=b0; b<b1; b++ ) E1[eids[eBins[b]]]++; } } } delete [] eids; delete [] cids; delete [] cids1; delete [] cids2; delete [] nids; }