void Texture::setTransparentColor(unsigned char r, unsigned char g, unsigned char b) { assert( m_data != 0 ); GLenum fmt; if( getBytesPerPixel() == 4 ) { fmt = GL_RGBA; for( int y=0; y<getHeight(); ++y ) { for( int x=0; x<getWidth(); ++x ) { unsigned char* data = getPixel(x,y); if( data[0] == r && data[1] == g && data[2] == b ) { data[3] = 0; } } } } else if( getBytesPerPixel() == 3 ) { unsigned char* newData = new unsigned char[m_width*m_height*4]; for( int y=0; y<getHeight(); ++y ) { for( int x=0; x<getWidth(); ++x ) { unsigned char* data = getPixel(x,y); unsigned char* d = &newData[(y*getWidth()+x)*4]; d[0] = data[0]; d[1] = data[1]; d[2] = data[2]; d[3] = 0xff; if( data[0] == r && data[1] == g && data[2] == b ) { d[3] = 0x00; } } } m_bpp = 4; fmt = GL_RGBA; delete [] m_data; m_data = newData; } else { esLogEngineError("[%s] Unsupported bytes per pixel: %d", __FUNCTION__, m_bpp); return; } glBindTexture(GL_TEXTURE_2D, getNativeId()); glTexImage2D(GL_TEXTURE_2D, 0, fmt, m_width, m_height, 0, fmt, GL_UNSIGNED_BYTE, m_data ); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); }
void Bitmap::setInfo(uint32_t w, uint32_t h, Format c, Alpha a, uint32_t stride) { _width = w; _height = h; _stride = max(stride, w * getBytesPerPixel(c)); _color = c; _alpha = a; }
void egl_server_platform_display( uint32_t win, KHRN_IMAGE_T* image, uint32_t cb_arg) { #ifdef DIRECT_RENDERING assert(0); return; #else assert(win != EGL_PLATFORM_WIN_NONE); if (!displaying) { displaying = true; current_win = win; } assert(win == current_win); //Can only display on a single window { android_native_buffer_t* buffer; void* bits; if (!nativeWindow) nativeWindow = get_android_native_window(); if (nativeWindow) { int fenceFd; nativeWindow->dequeueBuffer(nativeWindow, &buffer,&fenceFd); if(fenceFd >= 0) close(fenceFd); module->lock(module, buffer->handle, GRALLOC_USAGE_SW_WRITE_OFTEN, 0, 0, buffer->width, buffer->height, &bits); if (!bpp) bpp = getBytesPerPixel(buffer->format); if (check_color_format_khrn_image_vs_native_window(image, buffer)) { VC_IMAGE_T vc_image; khrn_image_fill_vcimage(image, &vc_image); vc_image_to_RSO_memory(&vc_image, buffer, bits); } else { khrn_image_to_native_buffer(image, buffer, bits); } module->unlock(module, buffer->handle); nativeWindow->queueBuffer(nativeWindow, buffer,&fenceFd); if(fenceFd >= 0) close(fenceFd); } } /* May as well call callback immediately */ if (egl_callback) egl_callback(cb_arg); #endif }
bool ofPixels_<PixelType>::pasteInto(ofPixels_<PixelType> &dst, int xTo, int yTo) const{ if (!(isAllocated()) || !(dst.isAllocated()) || getBytesPerPixel() != dst.getBytesPerPixel() || xTo + getWidth()>dst.getWidth() || yTo + getHeight()>dst.getHeight()) return false; int bytesToCopyPerRow = (xTo + getWidth()<=dst.getWidth() ? getWidth() : dst.getWidth()-xTo) * getBytesPerPixel(); int columnsToCopy = yTo + getHeight() <= dst.getHeight() ? getHeight() : dst.getHeight()-yTo; PixelType * dstPix = dst.getData() + ((xTo + yTo*dst.getWidth())*dst.getBytesPerPixel()); const PixelType * srcPix = getData(); int srcStride = getWidth()*getBytesPerPixel(); int dstStride = dst.getWidth()*dst.getBytesPerPixel(); for(int y=0;y<columnsToCopy; y++){ memcpy(dstPix,srcPix,bytesToCopyPerRow); dstPix += dstStride; srcPix += srcStride; } return true; }
uint32 Texture::getPixelNearest(int x, int y) const { if (m_data.empty() || x >= m_width || y >= m_height || x < 0 || y < 0 || getBytesPerPixel() != 4) { return 0; } return *(uint32*)&m_data[(x + y * m_width) * 4]; }
//! Sets the position of the next read. bool MrcFileImpl::protectedSetPosition(unsigned int variable, unsigned int timeStep, qulonglong offset) { if (variable>=m_NumVariables || timeStep>=m_NumTimeSteps) { return false; } else { m_File.at(1024 + (m_DimX*m_DimY*m_DimZ*timeStep + offset)*getBytesPerPixel(variable)); return true; } }
void ofPixels_<PixelType>::setFromAlignedPixels(const PixelType * newPixels, int width, int height, int channels, int stride) { allocate(width, height, channels); int dstStride = width * getBytesPerPixel(); const unsigned char* src = (unsigned char*) newPixels; unsigned char* dst = (unsigned char*) pixels; for(int i = 0; i < height; i++) { memcpy(dst, src, dstStride); src += stride; dst += dstStride; } }
void Image::crop(Rectangle roi, Image* orgImg) { // Crop from own image if (orgImg == NULL && isValid()) { assert(roi.getTop() >= 0 && roi.getBottom() <= getHeight() && roi.getLeft() >= 0 && roi.getRight() <= getWidth()); // Temp buffer unsigned char* newBuff = new unsigned char[(int)(roi.getWidth() * roi.getHeight() * getBytesPerPixel())]; unsigned char* newBuffPtr = newBuff; LOG_DEBUG("Crop from own buffer"); for (int h = roi.getTop(); h < roi.getBottom(); h++) { memcpy(newBuffPtr, getPtr<unsigned char>(h,roi.getLeft()), getBytesPerPixel() * roi.getWidth()); newBuffPtr += (int)(getBytesPerPixel() * roi.getWidth()); } if (m_ownMem) releaseData(); m_data = newBuff; m_ownMem = true; m_width = roi.getWidth(); m_height = roi.getHeight(); } // Crop from other image else if(orgImg != NULL){ assert( roi.getTop() >= 0 && roi.getBottom() <= orgImg->getHeight() && roi.getLeft() >= 0 && roi.getRight() <= orgImg->getWidth()); init(roi.getWidth(), roi.getHeight(), orgImg->getFormat()); for (int h = roi.getTop(); h < roi.getBottom(); h++) { memcpy(getPtr<unsigned char>(h), orgImg->getPtr<unsigned char>(h,roi.getLeft()), orgImg->getBytesPerPixel() * roi.getWidth()); } }else{ LOG_ERROR("Can't crop from my own buffer. Not initialized!"); } }
void ofPixels_<PixelType>::setFromAlignedPixels(const PixelType * newPixels, int width, int height, ofPixelFormat _pixelFormat, int stride) { int channels = channelsFromPixelFormat(_pixelFormat); if(channels==0) return; if(width*channels==stride){ setFromPixels(newPixels,width,height,_pixelFormat); return; } allocate(width, height, _pixelFormat); int dstStride = width * getBytesPerPixel(); const unsigned char* src = (unsigned char*) newPixels; unsigned char* dst = (unsigned char*) pixels; for(int i = 0; i < height; i++) { memcpy(dst, src, dstStride); src += stride; dst += dstStride; } }
bool ofPixels_<PixelType>::blendInto(ofPixels_<PixelType> &dst, int xTo, int yTo) const{ if (!(isAllocated()) || !(dst.isAllocated()) || getBytesPerPixel() != dst.getBytesPerPixel() || xTo + getWidth()>dst.getWidth() || yTo + getHeight()>dst.getHeight() || getNumChannels()==0) return false; std::function<void(const ConstPixel&,Pixel&)> blendFunc; switch(getNumChannels()){ case 1: blendFunc = [](const ConstPixel&src, Pixel&dst){ dst[0] = clampedAdd(src[0], dst[0]); }; break; case 2: blendFunc = [](const ConstPixel&src, Pixel&dst){ dst[0] = clampedAdd(src[0], dst[0] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[1])); dst[1] = clampedAdd(src[1], dst[1] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[1])); }; break; case 3: blendFunc = [](const ConstPixel&src, Pixel&dst){ dst[0] = clampedAdd(src[0], dst[0]); dst[1] = clampedAdd(src[1], dst[1]); dst[2] = clampedAdd(src[2], dst[2]); }; break; case 4: blendFunc = [](const ConstPixel&src, Pixel&dst){ dst[0] = clampedAdd(src[0], dst[0] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[3])); dst[1] = clampedAdd(src[1], dst[1] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[3])); dst[2] = clampedAdd(src[2], dst[2] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[3])); dst[3] = clampedAdd(src[3], dst[3] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[3])); }; break; } auto dstLine = dst.getLine(yTo); for(auto line: getConstLines()){ auto dstPixel = dstLine.getPixels().begin() + xTo; for(auto p: line.getPixels()){ blendFunc(p,dstPixel); dstPixel++; } dstLine++; } return true; }
void ImageDecoder::getRawBytes(unsigned char *image_buffer) { ERR err = WMP_errSuccess; I32 width, height, bytesPerPixel; PKRect rc; bytesPerPixel = (I32) getBytesPerPixel(); Call(pDecoder->GetSize(pDecoder, &width, &height)); rc.X = 0; rc.Y = 0; rc.Width = width; rc.Height = height; Call(pDecoder->Copy(pDecoder, &rc, image_buffer, width * bytesPerPixel)); return; Cleanup: std::stringstream msg; msg << "ERROR: Could not get image bytes: " << err; std::string errMsg = msg.str(); throw FormatError(errMsg); }
bool OGLTextDriver::init(const char* fontTextureName, int charStep, int fontWidth, int fontHeight, int screenWidth, int screenHeight) { if(!fontTextureName) return false; texName_ = fontTextureName; //fontTexture_ = SDL_LoadBMP(texName_.c_str()); //if(!fontTexture_) return false; fontTexture_ = new Image(); if( false == fontTexture_->loadFromFile( texName_.c_str() ) ) return false; // support only 32bit textures :P //int bpp = fontTexture_->format->BytesPerPixel; //if(4 != bpp) return false; if( 4 != getBytesPerPixel(fontTexture_->getFormat())) return false; glGenTextures(1, &texID_); glBindTexture(GL_TEXTURE_2D, texID_); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fontTexture_->getWidth(), fontTexture_->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, fontTexture_->getPixels()); fontWidth_ = fontWidth; fontHeight_ = fontHeight; scrWidth_ = screenWidth; scrHeight_ = screenHeight; charStep_ = charStep; return true; }
void ImagesLoader::saveToFile(const Image* object, const std::string& fileName){ Image img(object->getSize(), PXF_A8R8G8B8); img.copyImage(*object); img.flip(); ILuint tx; ilGenImages(1, &tx); ilBindImage(tx); const glm::ivec2& size = img.getSize(); if(!ilTexImage(size.x, size.y, 1, getBytesPerPixel(img.getFormat()), IL_BGRA, IL_UNSIGNED_BYTE, (void*)img.getData())) throw LoadingFailed(fileName); if(!ilSaveImage(const_cast<ILstring>(fileName.c_str()))) throw LoadingFailed(fileName); ilBindImage(0); ilDeleteImages(1, &tx); }
BitmapPtr FWCamera::getImage(bool bWait) { #ifdef AVG_ENABLE_1394_2 bool bGotFrame = false; unsigned char * pCaptureBuffer = 0; dc1394video_frame_t * pFrame; dc1394error_t err; if (bWait) { err = dc1394_capture_dequeue(m_pCamera, DC1394_CAPTURE_POLICY_WAIT, &pFrame); } else { err = dc1394_capture_dequeue(m_pCamera, DC1394_CAPTURE_POLICY_POLL, &pFrame); } if (err == DC1394_SUCCESS && pFrame) { bGotFrame = true; pCaptureBuffer = pFrame->image; } if (bGotFrame) { int lineLen; if (getCamPF() == YCbCr411) { lineLen = getImgSize().x*1.5; } else { lineLen = getImgSize().x*getBytesPerPixel(getCamPF()); } BitmapPtr pCamBmp(new Bitmap(getImgSize(), getCamPF(), pCaptureBuffer, lineLen, false, "TempCameraBmp")); BitmapPtr pDestBmp = convertCamFrameToDestPF(pCamBmp); // cerr << "CamBmp: " << pCamBmp->getPixelFormat() << ", DestBmp: " // << pDestBmp->getPixelFormat() << endl; dc1394_capture_enqueue(m_pCamera, pFrame); return pDestBmp; } else { return BitmapPtr(); } #else return BitmapPtr(); #endif }
void Mem2Native::updateTexture() { int SIZE = _size; if (!SIZE) SIZE = RECT_SIZE; MemoryTexture* src = _opt->src.get(); NativeTexture* dest = _opt->dest.get(); Point& prev = _prev; bool done = false; if (isCompressedFormat(src->getFormat())) { dest->init(src->lock(), false); done = true; } else { Rect textureRect(0, 0, src->getWidth(), src->getHeight()); if (dest->getHandle() == 0) dest->init(textureRect.getWidth(), textureRect.getHeight(), src->getFormat()); Rect srcRect(prev.x, prev.y, std::min(SIZE, textureRect.getWidth()), std::min(SIZE, textureRect.getHeight())); srcRect.clip(textureRect); ImageData srcim = src->lock(&srcRect); ImageData destim; if (srcRect != textureRect) { int pitch = srcRect.getWidth() * getBytesPerPixel(dest->getFormat()); _buffer.resize(srcRect.getHeight() * pitch); destim = ImageData( srcRect.getWidth(), srcRect.getHeight(), pitch, dest->getFormat(), &_buffer[0] ); operations::copy(srcim, destim); } else { destim = srcim; } dest->updateRegion(srcRect.pos.x, srcRect.pos.y, destim); prev.x += SIZE; if (prev.x >= textureRect.getWidth()) { prev.x = 0; prev.y += SIZE; } if (prev.y >= textureRect.getBottom()) { _buffer.clear(); prev = Point(0, 0); done = true; } } if (done) { textureDone(); } }
Bitmap::Bitmap(Bytes &&d, uint32_t width, uint32_t height, Format c, Alpha a, uint32_t stride) : _color(c), _alpha(a), _width(width), _height(height), _stride(max(stride, width * getBytesPerPixel(c))), _data(std::move(d)) { }
Bitmap::Bitmap(const uint8_t *d, uint32_t width, uint32_t height, Format c, Alpha a, uint32_t stride) : _color(c), _alpha(a), _width(width), _height(height), _stride(max(stride, width * getBytesPerPixel(c))), _data(d, d + _stride * height) { }
int AdobeSurface::estimateLength( const QSize surf_size, QImage::Format format ) { return getBytesPerPixel( format ) * surf_size.width() * surf_size.height(); }
const string CompressedImage::toString() const { stringstream sstr; sstr << "name = " << getName() << ", width = " << getWidth() << ", height = " << getHeight() << ", bytes per pixel = " << getBytesPerPixel() << ", compressed size = " << getCompressedSize(); return sstr.str(); }
void ofPixels_<PixelType>::setFromPixels(const PixelType * newPixels,int w, int h, int channels){ allocate(w, h, channels); memcpy(pixels, newPixels, w * h * getBytesPerPixel()); }
TexturesInspector::TexturesInspector(const Vector2& size) { setSize(size); spSlidingActor slide = new SlidingActor; slide->setSize(size); addChild(slide); float offsetY = 0; std::vector<spNativeTexture> textures = NativeTexture::getCreatedTextures(); spTextField text = initActor(new TextField, arg_color = Color::White, arg_pos = Vector2(1, 1), arg_w = itemSize.x * 3.0f, arg_h = 30.0f, arg_vAlign = TextStyle::VALIGN_TOP, arg_hAlign = TextStyle::HALIGN_LEFT, arg_multiline = true, arg_attachTo = slide ); offsetY += text->getTextRect().getBottom() + 5; spActor content = new Actor; content->setX(2); int numX = (int)(size.x / itemSize.x); int n = 0; int mem = 0; for (std::vector<spNativeTexture>::reverse_iterator i = textures.rbegin(); i != textures.rend(); ++i) { spNativeTexture t = *i; TextureLine* line = new TextureLine(t); float x = (n % numX) * (itemSize.x + 5.0f); float y = (n / numX) * (itemSize.y + 5.0f); line->setX(x); line->setY(y + offsetY); content->addChild(line); ++n; if (t->getHandle()) { TextureFormat fmt = t->getFormat(); int ram = t->getWidth() * t->getHeight(); if (isCompressedFormat(fmt)) { switch (fmt) { case TF_PVRTC_4RGBA: ram /= 2; break; case TF_ETC1: ram /= 2; break; default: break; } } else ram *= getBytesPerPixel(fmt); mem += ram; } } char txt[255]; safe_sprintf(txt, "created textures: %d, vram: %d kb", textures.size(), mem / 1024); text->setText(txt); if (numX > n) numX = n; content->setSize( (itemSize.x + 5.0f) * numX, (itemSize.y + 5.0f) * (n + numX - 1.0f) / numX + offsetY); setWidth(content->getWidth()); slide->setWidth(content->getWidth()); //slide->setSize() slide->setContent(content); }
void ofPixels_<PixelType>::setFromPixels(const PixelType * newPixels, int w, int h, ofPixelFormat format){ allocate(w,h,format); memcpy(pixels, newPixels, w * h * getBytesPerPixel()); }
bool Bitmap::convert(Format color, const StrideFn &strideFn) { bool ret = false; Bytes out; uint32_t outStride = (strideFn)?max(strideFn(color, _width), _width*getBytesPerPixel(color)):_width*getBytesPerPixel(color); if (_color == color && outStride != _stride) { out.resize(_height * outStride); size_t minStride = _width * getBytesPerPixel(_color); for (size_t j = 0; j < _height; j ++) { memcpy(out.data() + j * outStride, _data.data() + j * _stride, minStride); } _data = std::move(out); _stride = outStride; return true; } switch (_color) { case Format::A8: switch (color) { case Format::A8: return true; break; case Format::I8: _color = color; return true; break; case Format::IA88: ret = convertData<Format::A8, Format::IA88>(_data, out, _stride, outStride); break; case Format::RGB888: ret = convertData<Format::A8, Format::RGB888>(_data, out, _stride, outStride); break; case Format::RGBA8888: ret = convertData<Format::A8, Format::RGBA8888>(_data, out, _stride, outStride); break; } break; case Format::I8: switch (color) { case Format::A8: _color = color; return true; break; case Format::I8: return true; break; case Format::IA88: ret = convertData<Format::I8, Format::IA88>(_data, out, _stride, outStride); break; case Format::RGB888: ret = convertData<Format::I8, Format::RGB888>(_data, out, _stride, outStride); break; case Format::RGBA8888: ret = convertData<Format::I8, Format::RGBA8888>(_data, out, _stride, outStride); break; } break; case Format::IA88: switch (color) { case Format::A8: ret = convertData<Format::IA88, Format::A8>(_data, out, _stride, outStride); break; case Format::I8: ret = convertData<Format::IA88, Format::I8>(_data, out, _stride, outStride); break; case Format::IA88: return true; break; case Format::RGB888: ret = convertData<Format::IA88, Format::RGB888>(_data, out, _stride, outStride); break; case Format::RGBA8888: ret = convertData<Format::IA88, Format::RGBA8888>(_data, out, _stride, outStride); break; } break; case Format::RGB888: switch (color) { case Format::A8: ret = convertData<Format::RGB888, Format::A8>(_data, out, _stride, outStride); break; case Format::I8: ret = convertData<Format::RGB888, Format::I8>(_data, out, _stride, outStride); break; case Format::IA88: ret = convertData<Format::RGB888, Format::IA88>(_data, out, _stride, outStride); break; case Format::RGB888: return true; break; case Format::RGBA8888: ret = convertData<Format::RGB888, Format::RGBA8888>(_data, out, _stride, outStride); break; } break; case Format::RGBA8888: switch (color) { case Format::A8: ret = convertData<Format::RGBA8888, Format::A8>(_data, out, _stride, outStride); break; case Format::I8: ret = convertData<Format::RGBA8888, Format::I8>(_data, out, _stride, outStride); break; case Format::IA88: ret = convertData<Format::RGBA8888, Format::IA88>(_data, out, _stride, outStride); break; case Format::RGB888: ret = convertData<Format::RGBA8888, Format::RGB888>(_data, out, _stride, outStride); break; case Format::RGBA8888: return true; break; } break; } if (ret) { _color = color; _data = std::move(out); _stride = outStride; } return ret; }
ImageData::ImageData(int W, int H, int Pitch, TextureFormat Format, void *Data):w(W), h(H), pitch(Pitch), format(Format), data((unsigned char *)Data) { bytespp = getBytesPerPixel(Format); }
bool ofPixels_<PixelType>::resizeTo(ofPixels_<PixelType>& dst, ofInterpolationMethod interpMethod) const{ if(&dst == this){ return true; } if (!(isAllocated()) || !(dst.isAllocated()) || getBytesPerPixel() != dst.getBytesPerPixel()) return false; int srcWidth = getWidth(); int srcHeight = getHeight(); int dstWidth = dst.getWidth(); int dstHeight = dst.getHeight(); int bytesPerPixel = getBytesPerPixel(); PixelType * dstPixels = dst.getData(); switch (interpMethod){ //---------------------------------------- case OF_INTERPOLATE_NEAREST_NEIGHBOR:{ int dstIndex = 0; float srcxFactor = (float)srcWidth/dstWidth; float srcyFactor = (float)srcHeight/dstHeight; float srcy = 0.5; for (int dsty=0; dsty<dstHeight; dsty++){ float srcx = 0.5; int srcIndex = int(srcy)*srcWidth; for (int dstx=0; dstx<dstWidth; dstx++){ int pixelIndex = int(srcIndex + srcx) * bytesPerPixel; for (int k=0; k<bytesPerPixel; k++){ dstPixels[dstIndex] = pixels[pixelIndex]; dstIndex++; pixelIndex++; } srcx+=srcxFactor; } srcy+=srcyFactor; } }break; //---------------------------------------- case OF_INTERPOLATE_BILINEAR: // not implemented yet ofLogError("ofPixels") << "resizeTo(): bilinear resize not implemented, not resizing"; break; //---------------------------------------- case OF_INTERPOLATE_BICUBIC: float px1, py1; float px2, py2; float px3, py3; float srcColor = 0; float interpCol; int patchRow; int patchIndex; float patch[16]; int srcRowBytes = srcWidth*bytesPerPixel; int loIndex = (srcRowBytes)+1; int hiIndex = (srcWidth*srcHeight*bytesPerPixel)-(srcRowBytes)-1; for (int dsty=0; dsty<dstHeight; dsty++){ for (int dstx=0; dstx<dstWidth; dstx++){ int dstIndex0 = (dsty*dstWidth + dstx) * bytesPerPixel; float srcxf = srcWidth * (float)dstx/(float)dstWidth; float srcyf = srcHeight * (float)dsty/(float)dstHeight; int srcx = (int) MIN(srcWidth-1, srcxf); int srcy = (int) MIN(srcHeight-1, srcyf); int srcIndex0 = (srcy*srcWidth + srcx) * bytesPerPixel; px1 = srcxf - srcx; py1 = srcyf - srcy; px2 = px1 * px1; px3 = px2 * px1; py2 = py1 * py1; py3 = py2 * py1; for (int k=0; k<bytesPerPixel; k++){ int dstIndex = dstIndex0+k; int srcIndex = srcIndex0+k; for (int dy=0; dy<4; dy++) { patchRow = srcIndex + ((dy-1)*srcRowBytes); for (int dx=0; dx<4; dx++) { patchIndex = patchRow + (dx-1)*bytesPerPixel; if ((patchIndex >= loIndex) && (patchIndex < hiIndex)) { srcColor = pixels[patchIndex]; } patch[dx*4 + dy] = srcColor; } } interpCol = (PixelType)bicubicInterpolate(patch, px1,py1, px2,py2, px3,py3); dstPixels[dstIndex] = interpCol; } } } break; } return true; }