DEF_TEST(DiscardablePixelRef_SecondLockColorTableCheck, r) { SkString resourceDir = GetResourcePath(); SkString path = SkOSPath::Join(resourceDir.c_str(), "randPixels.gif"); if (!sk_exists(path.c_str())) { return; } SkAutoDataUnref encoded(SkData::NewFromFileName(path.c_str())); SkBitmap bitmap; if (!SkInstallDiscardablePixelRef( SkDecodingImageGenerator::Create( encoded, SkDecodingImageGenerator::Options()), &bitmap)) { #ifndef SK_BUILD_FOR_WIN ERRORF(r, "SkInstallDiscardablePixelRef [randPixels.gif] failed."); #endif return; } if (kIndex_8_SkColorType != bitmap.colorType()) { return; } { SkAutoLockPixels alp(bitmap); REPORTER_ASSERT(r, bitmap.getColorTable() && "first pass"); } { SkAutoLockPixels alp(bitmap); REPORTER_ASSERT(r, bitmap.getColorTable() && "second pass"); } }
static int rates ( _threadargsprotocomma_ double _lv ) { double _la , _lb ; _la = alp ( _threadargscomma_ _lv , 0.0 ) ; _lb = bet ( _threadargscomma_ _lv , 0.0 ) ; mtau = 1.0 / ( _la + _lb ) ; minf = _la / ( _la + _lb ) ; _la = alp ( _threadargscomma_ _lv , 1.0 ) ; _lb = bet ( _threadargscomma_ _lv , 1.0 ) ; ntau = 1.0 / ( _la + _lb ) ; ninf = _la / ( _la + _lb ) ; return 0; }
// returns true and set color if the bitmap can be drawn as a single color // (for efficiency) static bool canUseColorShader(const SkBitmap& bm, SkColor* color) { if (1 != bm.width() || 1 != bm.height()) { return false; } SkAutoLockPixels alp(bm); if (!bm.readyToDraw()) { return false; } switch (bm.config()) { case SkBitmap::kARGB_8888_Config: *color = SkUnPreMultiply::PMColorToColor(*bm.getAddr32(0, 0)); return true; case SkBitmap::kRGB_565_Config: *color = SkPixel16ToColor(*bm.getAddr16(0, 0)); return true; case SkBitmap::kIndex8_Config: *color = SkUnPreMultiply::PMColorToColor(bm.getIndex8Color(0, 0)); return true; default: // just skip the other configs for now break; } return false; }
static void Bitmap_getPixels(JNIEnv* env, jobject, jlong bitmapHandle, jintArray pixelArray, jint offset, jint stride, jint x, jint y, jint width, jint height) { const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); SkAutoLockPixels alp(*bitmap); ToColorProc proc = ChooseToColorProc(*bitmap); if (NULL == proc) { return; } const void* src = bitmap->getAddr(x, y); if (NULL == src) { return; } SkColorTable* ctable = bitmap->getColorTable(); jint* dst = env->GetIntArrayElements(pixelArray, NULL); SkColor* d = (SkColor*)dst + offset; while (--height >= 0) { proc(d, src, width, ctable); d += stride; src = (void*)((const char*)src + bitmap->rowBytes()); } env->ReleaseIntArrayElements(pixelArray, dst, 0); }
void TextureCache::generateTexture(SkBitmap* bitmap, Texture* texture, bool regenerate) { SkAutoLockPixels alp(*bitmap); if (!bitmap->readyToDraw()) { ALOGE("Cannot generate texture from bitmap"); return; } const bool resize = !regenerate || bitmap->width() != int(texture->width) || bitmap->height() != int(texture->height); if (!regenerate) { glGenTextures(1, &texture->id); } texture->generation = bitmap->getGenerationID(); texture->width = bitmap->width(); texture->height = bitmap->height(); glBindTexture(GL_TEXTURE_2D, texture->id); if (!regenerate) { glPixelStorei(GL_UNPACK_ALIGNMENT, bitmap->bytesPerPixel()); } switch (bitmap->getConfig()) { case SkBitmap::kA8_Config: if (!regenerate) { glPixelStorei(GL_UNPACK_ALIGNMENT, 1); } uploadToTexture(resize, GL_ALPHA, bitmap->rowBytesAsPixels(), texture->height, GL_UNSIGNED_BYTE, bitmap->getPixels()); texture->blend = true; break; case SkBitmap::kRGB_565_Config: uploadToTexture(resize, GL_RGB, bitmap->rowBytesAsPixels(), texture->height, GL_UNSIGNED_SHORT_5_6_5, bitmap->getPixels()); texture->blend = false; break; case SkBitmap::kARGB_8888_Config: uploadToTexture(resize, GL_RGBA, bitmap->rowBytesAsPixels(), texture->height, GL_UNSIGNED_BYTE, bitmap->getPixels()); // Do this after calling getPixels() to make sure Skia's deferred // decoding happened texture->blend = !bitmap->isOpaque(); break; case SkBitmap::kARGB_4444_Config: case SkBitmap::kIndex8_Config: uploadLoFiTexture(resize, bitmap, texture->width, texture->height); texture->blend = !bitmap->isOpaque(); break; default: ALOGW("Unsupported bitmap config: %d", bitmap->getConfig()); break; } if (!regenerate) { texture->setFilter(GL_NEAREST); texture->setWrap(GL_CLAMP_TO_EDGE); } }
// Look at each pixel in bm, and if its color appears in colors[], find the // corresponding value in refs[] and append that ref into array, skipping // duplicates of the same value. static void gather_from_colors(const SkBitmap& bm, SkPixelRef* const refs[], int count, SkTDArray<SkPixelRef*>* array) { // Since we only want to return unique values in array, when we scan we just // set a bit for each index'd color found. In practice we only have a few // distinct colors, so we just use an int's bits as our array. Hence the // assert that count <= number-of-bits-in-our-int. SkASSERT((unsigned)count <= 32); uint32_t bitarray = 0; SkAutoLockPixels alp(bm); for (int y = 0; y < bm.height(); ++y) { for (int x = 0; x < bm.width(); ++x) { SkPMColor pmc = *bm.getAddr32(x, y); // the only good case where the color is not found would be if // the color is transparent, meaning no bitmap was drawn in that // pixel. if (pmc) { uint32_t index = SkGetPackedR32(pmc); SkASSERT(SkGetPackedG32(pmc) == index); SkASSERT(SkGetPackedB32(pmc) == index); SkASSERT(static_cast<int>(index) < count); bitarray |= 1 << index; } } } for (int i = 0; i < count; ++i) { if (bitarray & (1 << i)) { *array->append() = refs[i]; } } }
bool SkBitmapDevice::onReadPixels(const SkBitmap& bitmap, int x, int y, SkCanvas::Config8888 config8888) { SkASSERT(SkBitmap::kARGB_8888_Config == bitmap.config()); SkASSERT(!bitmap.isNull()); SkASSERT(SkIRect::MakeWH(this->width(), this->height()).contains(SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height()))); SkIRect srcRect = SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height()); const SkBitmap& src = this->accessBitmap(false); SkBitmap subset; if (!src.extractSubset(&subset, srcRect)) { return false; } if (kPMColor_SkColorType != subset.colorType()) { // It'd be preferable to do this directly to bitmap. subset.copyTo(&subset, kPMColor_SkColorType); } SkAutoLockPixels alp(bitmap); uint32_t* bmpPixels = reinterpret_cast<uint32_t*>(bitmap.getPixels()); SkCopyBitmapToConfig8888(bmpPixels, bitmap.rowBytes(), config8888, subset); return true; }
bool GraphicsJNI::SetPixels(JNIEnv* env, jintArray srcColors, int srcOffset, int srcStride, int x, int y, int width, int height, const SkBitmap& dstBitmap) { SkAutoLockPixels alp(dstBitmap); void* dst = dstBitmap.getPixels(); FromColorProc proc = ChooseFromColorProc(dstBitmap.config()); if (NULL == dst || NULL == proc) { return false; } const jint* array = env->GetIntArrayElements(srcColors, NULL); const SkColor* src = (const SkColor*)array + srcOffset; // reset to to actual choice from caller dst = dstBitmap.getAddr(x, y); // now copy/convert each scanline for (int y = 0; y < height; y++) { proc(dst, src, width, x, y); src += srcStride; dst = (char*)dst + dstBitmap.rowBytes(); } dstBitmap.notifyPixelsChanged(); env->ReleaseIntArrayElements(srcColors, const_cast<jint*>(array), JNI_ABORT); return true; }
static void pre_dither(const SkBitmap& bm) { SkAutoLockPixels alp(bm); for (int y = 0; y < bm.height(); y++) { DITHER_4444_SCAN(y); SkPMColor* p = bm.getAddr32(0, y); for (int x = 0; x < bm.width(); x++) { SkPMColor c = *p; unsigned a = SkGetPackedA32(c); unsigned r = SkGetPackedR32(c); unsigned g = SkGetPackedG32(c); unsigned b = SkGetPackedB32(c); unsigned d = DITHER_VALUE(x); a = SkDITHER_A32To4444(a, d); r = SkDITHER_R32To4444(r, d); g = SkDITHER_G32To4444(g, d); b = SkDITHER_B32To4444(b, d); a = SkA4444ToA32(a); r = SkR4444ToR32(r); g = SkG4444ToG32(g); b = SkB4444ToB32(b); *p++ = SkPackARGB32(a, r, g, b); } } }
void skia_draw_transp_sprite(const sprite_t *sprite, int x, int y, int use_off, int y_off, int color_off, frame_t *dest) { // if(1) return; // LOGI("skia_draw_transp_sprite x=%d y=%d use_off=%d y_off=%d", x, y, use_off, y_off); if (use_off) { x += le16toh(sprite->x); y += le16toh(sprite->y); } void *data = (uint8_t *)sprite + sizeof(sprite_t); size_t width = le16toh(sprite->w); size_t height = le16toh(sprite->h); std::shared_ptr<SkBitmap> bitmap; bitmap_cache_t::iterator it = g_bitmap_cache.find(sprite); if( it != g_bitmap_cache.end() ) { bitmap = it->second; } else { LOGI("create transparent sprite = %d", sprite); // Create bitmap and add to cache bitmap.reset(new SkBitmap()); g_bitmap_cache[sprite] = bitmap; bitmap->setConfig(SkBitmap::kIndex8_Config, width, height); bitmap->allocPixels(g_color_table.get()); { SkAutoLockPixels alp(*bitmap); size_t unpack_size = width * height; gfx_unpack_transparent_sprite(bitmap->getPixels(), data, unpack_size, color_off); } bitmap->notifyPixelsChanged(); } SkRect src_rect; src_rect.fLeft = 0; src_rect.fTop = y_off; src_rect.fRight = SkIntToScalar(width); src_rect.fBottom = - y_off + SkIntToScalar(height); SkRect dst_rect; dst_rect.fLeft = x; dst_rect.fTop = y + y_off; dst_rect.fRight = x + SkIntToScalar(width); dst_rect.fBottom = y - y_off + SkIntToScalar(height); ((SkCanvas*)dest->skCanvas)->drawBitmapRectToRect(*bitmap, &src_rect, dst_rect, NULL); #if 0 /* Bounding box */ skia_draw_rect(x, y + y_off, width, height - y_off, 72, dest); #endif }
// Ensure that repeated color gradients behave like drawing a single color static void TestConstantGradient(skiatest::Reporter*) { const SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(10), 0 } }; SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE }; const SkScalar pos[] = { 0, SK_Scalar1 }; SkAutoTUnref<SkShader> s(SkGradientShader::CreateLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode)); SkBitmap outBitmap; outBitmap.allocN32Pixels(10, 1); SkPaint paint; paint.setShader(s.get()); SkCanvas canvas(outBitmap); canvas.drawPaint(paint); SkAutoLockPixels alp(outBitmap); for (int i = 0; i < 10; i++) { // The following is commented out because it currently fails // Related bug: https://code.google.com/p/skia/issues/detail?id=1098 // REPORTER_ASSERT(reporter, SK_ColorBLUE == outBitmap.getColor(i, 0)); } }
// returns true and set color if the bitmap can be drawn as a single color // (for efficiency) static bool can_use_color_shader(const SkBitmap& bm, SkColor* color) { #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK // HWUI does not support color shaders (see b/22390304) return false; #endif if (1 != bm.width() || 1 != bm.height()) { return false; } SkAutoLockPixels alp(bm); if (!bm.readyToDraw()) { return false; } switch (bm.colorType()) { case kN32_SkColorType: *color = SkUnPreMultiply::PMColorToColor(*bm.getAddr32(0, 0)); return true; case kRGB_565_SkColorType: *color = SkPixel16ToColor(*bm.getAddr16(0, 0)); return true; case kIndex_8_SkColorType: *color = SkUnPreMultiply::PMColorToColor(bm.getIndex8Color(0, 0)); return true; default: // just skip the other configs for now break; } return false; }
bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream); if (NULL == imageSrc) { return false; } SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc); CGImageRef image = CGImageSourceCreateImageAtIndex(imageSrc, 0, NULL); if (NULL == image) { return false; } SkAutoTCallVProc<CGImage, CGImageRelease> arimage(image); const int width = SkToInt(CGImageGetWidth(image)); const int height = SkToInt(CGImageGetHeight(image)); bm->setInfo(SkImageInfo::MakeN32Premul(width, height)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } if (!this->allocPixelRef(bm, NULL)) { return false; } SkAutoLockPixels alp(*bm); if (!SkCopyPixelsFromCGImage(bm->info(), bm->rowBytes(), bm->getPixels(), image)) { return false; } CGImageAlphaInfo info = CGImageGetAlphaInfo(image); switch (info) { case kCGImageAlphaNone: case kCGImageAlphaNoneSkipLast: case kCGImageAlphaNoneSkipFirst: SkASSERT(SkBitmap::ComputeIsOpaque(*bm)); bm->setAlphaType(kOpaque_SkAlphaType); break; default: // we don't know if we're opaque or not, so compute it. if (SkBitmap::ComputeIsOpaque(*bm)) { bm->setAlphaType(kOpaque_SkAlphaType); } } if (!bm->isOpaque() && this->getRequireUnpremultipliedColors()) { // CGBitmapContext does not support unpremultiplied, so the image has been premultiplied. // Convert to unpremultiplied. for (int i = 0; i < width; ++i) { for (int j = 0; j < height; ++j) { uint32_t* addr = bm->getAddr32(i, j); *addr = SkUnPreMultiply::UnPreMultiplyPreservingByteOrder(*addr); } } bm->setAlphaType(kUnpremul_SkAlphaType); } return true; }
static void setBitmapOpaque(SkBitmap* bm, bool isOpaque) { SkAutoLockPixels alp(*bm); // needed for ctable bm->setIsOpaque(isOpaque); SkColorTable* ctable = bm->getColorTable(); if (ctable) { ctable->setIsOpaque(isOpaque); } }
DEF_TEST(WebP, reporter) { const unsigned char encodedWebP[] = { 0x52, 0x49, 0x46, 0x46, 0x2c, 0x01, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50, 0x56, 0x50, 0x38, 0x4c, 0x20, 0x01, 0x00, 0x00, 0x2f, 0x07, 0xc0, 0x01, 0x00, 0xff, 0x01, 0x45, 0x03, 0x00, 0xe2, 0xd5, 0xae, 0x60, 0x2b, 0xad, 0xd9, 0x68, 0x76, 0xb6, 0x8d, 0x6a, 0x1d, 0xc0, 0xe6, 0x19, 0xd6, 0x16, 0xb7, 0xb4, 0xef, 0xcf, 0xc3, 0x15, 0x6c, 0xb3, 0xbd, 0x77, 0x0d, 0x85, 0x6d, 0x1b, 0xa9, 0xb1, 0x2b, 0xdc, 0x3d, 0x83, 0xdb, 0x00, 0x00, 0xc8, 0x26, 0xe5, 0x01, 0x99, 0x8a, 0xd5, 0xdd, 0xfc, 0x82, 0xcd, 0xcd, 0x9a, 0x8c, 0x13, 0xcc, 0x1b, 0xba, 0xf5, 0x05, 0xdb, 0xee, 0x6a, 0xdb, 0x38, 0x60, 0xfe, 0x43, 0x2c, 0xd4, 0x6a, 0x99, 0x4d, 0xc6, 0xc0, 0xd3, 0x28, 0x1b, 0xc1, 0xb1, 0x17, 0x4e, 0x43, 0x0e, 0x3d, 0x27, 0xe9, 0xe4, 0x84, 0x4f, 0x24, 0x62, 0x69, 0x85, 0x43, 0x8d, 0xc2, 0x04, 0x00, 0x07, 0x59, 0x60, 0xfd, 0x8b, 0x4d, 0x60, 0x32, 0x72, 0xcf, 0x88, 0x0c, 0x2f, 0x2f, 0xad, 0x62, 0xbd, 0x27, 0x09, 0x16, 0x70, 0x78, 0x6c, 0xd9, 0x82, 0xef, 0x1a, 0xa2, 0xcc, 0xf0, 0xf1, 0x6f, 0xd8, 0x78, 0x2e, 0x39, 0xa1, 0xcf, 0x14, 0x4b, 0x89, 0xb4, 0x1b, 0x48, 0x15, 0x7c, 0x48, 0x6f, 0x8c, 0x20, 0xb7, 0x00, 0xcf, 0xfc, 0xdb, 0xd0, 0xe9, 0xe7, 0x42, 0x09, 0xa4, 0x03, 0x40, 0xac, 0xda, 0x40, 0x01, 0x00, 0x5f, 0xa1, 0x3d, 0x64, 0xe1, 0xf4, 0x03, 0x45, 0x29, 0xe0, 0xe2, 0x4a, 0xc3, 0xa2, 0xe8, 0xe0, 0x25, 0x12, 0x74, 0xc6, 0xe8, 0xfb, 0x93, 0x4f, 0x9f, 0x5e, 0xc0, 0xa6, 0x91, 0x1b, 0xa4, 0x24, 0x82, 0xc3, 0x61, 0x07, 0x4c, 0x49, 0x4f, 0x53, 0xae, 0x5f, 0x5d, 0x39, 0x36, 0xc0, 0x5b, 0x57, 0x54, 0x60, 0x10, 0x00, 0x00, 0xd1, 0x68, 0xb6, 0x6d, 0xdb, 0x36, 0x22, 0xfa, 0x1f, 0x35, 0x75, 0x22, 0xec, 0x31, 0xbc, 0x5d, 0x8f, 0x87, 0x53, 0xa2, 0x05, 0x8c, 0x2f, 0xcd, 0xa8, 0xa7, 0xf3, 0xa3, 0xbd, 0x83, 0x8b, 0x2a, 0xc8, 0x58, 0xf5, 0xac, 0x80, 0xe3, 0xfe, 0x66, 0xa4, 0x7c, 0x1b, 0x6c, 0xd1, 0xa9, 0xd8, 0x14, 0xd0, 0xc5, 0xb5, 0x39, 0x71, 0x97, 0x19, 0x19, 0x1b }; SkAutoDataUnref encoded(SkData::NewWithCopy(encodedWebP, sizeof(encodedWebP))); SkBitmap bm; bool success = SkInstallDiscardablePixelRef( SkDecodingImageGenerator::Create(encoded, SkDecodingImageGenerator::Options()), &bm); REPORTER_ASSERT(reporter, success); if (!success) { return; } SkAutoLockPixels alp(bm); bool rightSize = ((kExpectedWidth == bm.width()) && (kExpectedHeight == bm.height())); REPORTER_ASSERT(reporter, rightSize); if (rightSize) { bool error = false; const SkColor* correctPixel = kExpectedPixels; for (int y = 0; y < bm.height(); ++y) { for (int x = 0; x < bm.width(); ++x) { error |= (*correctPixel != bm.getColor(x, y)); ++correctPixel; } } REPORTER_ASSERT(reporter, !error); } }
static void _hoc_alp(void) { double _r; double* _p; Datum* _ppvar; Datum* _thread; _NrnThread* _nt; if (_extcall_prop) {_p = _extcall_prop->param; _ppvar = _extcall_prop->dparam;}else{ _p = (double*)0; _ppvar = (Datum*)0; } _thread = _extcall_thread; _nt = nrn_threads; _r = alp ( _p, _ppvar, _thread, _nt, *getarg(1) , *getarg(2) ); hoc_retpushx(_r); }
bool SkMatrixConvolutionImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source, const Context& ctx, SkBitmap* result, SkIPoint* offset) const { SkBitmap src = source; SkIPoint srcOffset = SkIPoint::Make(0, 0); if (!this->filterInput(0, proxy, source, ctx, &src, &srcOffset)) { return false; } if (src.colorType() != kN32_SkColorType) { return false; } SkIRect bounds; if (!this->applyCropRect(ctx, proxy, src, &srcOffset, &bounds, &src)) { return false; } if (!fConvolveAlpha && !src.isOpaque()) { src = unpremultiplyBitmap(proxy, src); } SkAutoLockPixels alp(src); if (!src.getPixels()) { return false; } SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height())); if (!device) { return false; } *result = device->accessBitmap(false); SkAutoLockPixels alp_result(*result); offset->fX = bounds.fLeft; offset->fY = bounds.fTop; bounds.offset(-srcOffset); SkIRect interior = SkIRect::MakeXYWH(bounds.left() + fKernelOffset.fX, bounds.top() + fKernelOffset.fY, bounds.width() - fKernelSize.fWidth + 1, bounds.height() - fKernelSize.fHeight + 1); SkIRect top = SkIRect::MakeLTRB(bounds.left(), bounds.top(), bounds.right(), interior.top()); SkIRect bottom = SkIRect::MakeLTRB(bounds.left(), interior.bottom(), bounds.right(), bounds.bottom()); SkIRect left = SkIRect::MakeLTRB(bounds.left(), interior.top(), interior.left(), interior.bottom()); SkIRect right = SkIRect::MakeLTRB(interior.right(), interior.top(), bounds.right(), interior.bottom()); filterBorderPixels(src, result, top, bounds); filterBorderPixels(src, result, left, bounds); filterInteriorPixels(src, result, interior, bounds); filterBorderPixels(src, result, right, bounds); filterBorderPixels(src, result, bottom, bounds); return true; }
void FlightControl::calibrateAccZ() { int16_t az = 0; LowPassFilter alp(100); for(uint8_t i=0;i<100;i++) { delay(1); az = alp.filter(AccelGyro.getAccelerationZ()); } accZbias = az; }
void ImageBuffer::putUnmultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint) { GraphicsContext* gc = this->context(); if (!gc) { return; } const SkBitmap& dst = imageBufferCanvas(this)->getDevice()->accessBitmap(true); SkAutoLockPixels alp(dst); if (!dst.getPixels()) { return; } ASSERT(sourceRect.width() > 0); ASSERT(sourceRect.height() > 0); int originx = sourceRect.x(); int destx = destPoint.x() + sourceRect.x(); ASSERT(destx >= 0); ASSERT(destx < m_size.width()); ASSERT(originx >= 0); ASSERT(originx <= sourceRect.maxX()); int endx = destPoint.x() + sourceRect.maxX(); ASSERT(endx <= m_size.width()); int numColumns = endx - destx; int originy = sourceRect.y(); int desty = destPoint.y() + sourceRect.y(); ASSERT(desty >= 0); ASSERT(desty < m_size.height()); ASSERT(originy >= 0); ASSERT(originy <= sourceRect.maxY()); int endy = destPoint.y() + sourceRect.maxY(); ASSERT(endy <= m_size.height()); int numRows = endy - desty; unsigned srcBytesPerRow = 4 * sourceSize.width(); unsigned dstPixelsPerRow = dst.rowBytesAsPixels(); unsigned char* srcRows = source->data() + originy * srcBytesPerRow + originx * 4; SkPMColor* dstRows = dst.getAddr32(destx, desty); for (int y = 0; y < numRows; ++y) { for (int x = 0; x < numColumns; x++) { int basex = x * 4; dstRows[x] = SkPackARGB32(srcRows[basex + 3], srcRows[basex + 0], srcRows[basex + 1], srcRows[basex + 2]); } dstRows += dstPixelsPerRow; srcRows += srcBytesPerRow; } }
static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject, const SkBitmap* bitmap, jobject jbuffer) { SkAutoLockPixels alp(*bitmap); void* dst = bitmap->getPixels(); if (NULL != dst) { android::AutoBufferPointer abp(env, jbuffer, JNI_FALSE); // the java side has already checked that buffer is large enough memcpy(dst, abp.pointer(), bitmap->getSize()); <<<<<<< HEAD
void onDrawContent(SkCanvas* canvas) override { SkPaint paint; paint.setAntiAlias(true); paint.setTextSize(SkIntToScalar(24)); SkAutoTUnref<SkBlurDrawLooper> looper( SkBlurDrawLooper::Create(SK_ColorBLUE, SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(2)), 0, 0)); paint.setLooper(looper); SkScalar height = paint.getFontMetrics(nullptr); if (!fDecodeSucceeded) { SkString failure; if (fResPath.size() == 0) { failure.printf("resource path is required!"); } else { failure.printf("Failed to decode %s", fCurrFile.c_str()); } canvas->drawText(failure.c_str(), failure.size(), 0, height, paint); return; } // Name, size of the file, and whether or not it is premultiplied. SkString header(SkOSPath::Basename(fCurrFile.c_str())); header.appendf(" [%dx%d] %s", fBitmap.width(), fBitmap.height(), (fPremul ? "premultiplied" : "unpremultiplied")); canvas->drawText(header.c_str(), header.size(), 0, height, paint); canvas->translate(0, height); // Help messages header.printf("Press '%c' to move to the next image.'", fNextImageChar); canvas->drawText(header.c_str(), header.size(), 0, height, paint); canvas->translate(0, height); header.printf("Press '%c' to toggle premultiplied decode.", fTogglePremulChar); canvas->drawText(header.c_str(), header.size(), 0, height, paint); // Now draw the image itself. canvas->translate(height * 2, height * 2); if (!fPremul) { // A premultiplied bitmap cannot currently be drawn. SkAutoLockPixels alp(fBitmap); // Copy it to a bitmap which can be drawn, converting // to premultiplied: SkBitmap bm; bm.allocN32Pixels(fBitmap.width(), fBitmap.height()); for (int i = 0; i < fBitmap.width(); ++i) { for (int j = 0; j < fBitmap.height(); ++j) { *bm.getAddr32(i, j) = premultiply_unpmcolor(*fBitmap.getAddr32(i, j)); } } canvas->drawBitmap(bm, 0, 0); } else { canvas->drawBitmap(fBitmap, 0, 0); } }
PassRefPtr<ByteArray> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const { GraphicsContext* gc = this->context(); if (!gc) { return 0; } const SkBitmap& src = imageBufferCanvas(this)->getDevice()->accessBitmap(false); SkAutoLockPixels alp(src); if (!src.getPixels()) { return 0; } RefPtr<ByteArray> result = ByteArray::create(rect.width() * rect.height() * 4); unsigned char* data = result->data(); if (rect.x() < 0 || rect.y() < 0 || rect.maxX() > m_size.width() || rect.maxY() > m_size.height()) memset(data, 0, result->length()); int originx = rect.x(); int destx = 0; if (originx < 0) { destx = -originx; originx = 0; } int endx = rect.x() + rect.width(); if (endx > m_size.width()) endx = m_size.width(); int numColumns = endx - originx; int originy = rect.y(); int desty = 0; if (originy < 0) { desty = -originy; originy = 0; } int endy = rect.y() + rect.height(); if (endy > m_size.height()) endy = m_size.height(); int numRows = endy - originy; unsigned srcPixelsPerRow = src.rowBytesAsPixels(); unsigned destBytesPerRow = 4 * rect.width(); /// M: change process to read pixel @{ /* fix w3c pixel manipulation relative test case */ SkBitmap destBitmap; destBitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height(), destBytesPerRow); destBitmap.setPixels(data); SkCanvas* canvas = imageBufferCanvas(this); canvas->readPixels(&destBitmap, rect.x(), rect.y(), SkCanvas::kRGBA_Unpremul_Config8888); return result.release(); /// @} }
static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx, const SkBitmap& origBitmap, const GrUniqueKey& optionalKey) { if (origBitmap.width() < ctx->caps()->minTextureSize() || origBitmap.height() < ctx->caps()->minTextureSize()) { return nullptr; } SkBitmap tmpBitmap; const SkBitmap* bitmap = &origBitmap; GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap->info()); const GrCaps* caps = ctx->caps(); if (kIndex_8_SkColorType == bitmap->colorType()) { if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) { size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig, bitmap->width(), bitmap->height()); SkAutoMalloc storage(imageSize); build_index8_data(storage.get(), origBitmap); // our compressed data will be trimmed, so pass width() for its // "rowBytes", since they are the same now. return GrCreateTextureForPixels(ctx, optionalKey, desc, origBitmap.pixelRef(), storage.get(), bitmap->width()); } else { origBitmap.copyTo(&tmpBitmap, kN32_SkColorType); // now bitmap points to our temp, which has been promoted to 32bits bitmap = &tmpBitmap; desc.fConfig = SkImageInfo2GrPixelConfig(bitmap->info()); } } else if (!bitmap->readyToDraw()) { // If the bitmap had compressed data and was then uncompressed, it'll still return // compressed data on 'refEncodedData' and upload it. Probably not good, since if // the bitmap has available pixels, then they might not be what the decompressed // data is. GrTexture *texture = load_etc1_texture(ctx, optionalKey, *bitmap, desc); if (texture) { return texture; } } GrTexture *texture = load_yuv_texture(ctx, optionalKey, *bitmap, desc); if (texture) { return texture; } SkAutoLockPixels alp(*bitmap); if (!bitmap->readyToDraw()) { return nullptr; } return GrCreateTextureForPixels(ctx, optionalKey, desc, origBitmap.pixelRef(), bitmap->getPixels(), bitmap->rowBytes()); }
static int rate ( double _lv ) { double _la , _lb , _lqt ; _lqt = pow( q10 , ( ( celsius - 25.0 ) / 10.0 ) ) ; _la = alp ( _threadargscomma_ _lv ) ; _lb = 1.0 / ( ( _la + bet ( _threadargscomma_ _lv ) ) ) ; minf = _la * _lb ; tau = betmt ( _threadargscomma_ _lv ) / ( _lqt * a0m * ( 1.0 + alpmt ( _threadargscomma_ _lv ) ) ) ; if ( tau < mmin / _lqt ) { tau = mmin / _lqt ; } return 0; }
GrTexture* GrUploadBitmapToTexture(GrContext* ctx, const SkBitmap& bmp) { SkASSERT(!bmp.getTexture()); SkBitmap tmpBitmap; const SkBitmap* bitmap = &bmp; GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap->info()); const GrCaps* caps = ctx->caps(); if (kIndex_8_SkColorType == bitmap->colorType()) { if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) { size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig, bitmap->width(), bitmap->height()); SkAutoMalloc storage(imageSize); build_index8_data(storage.get(), bmp); // our compressed data will be trimmed, so pass width() for its // "rowBytes", since they are the same now. return ctx->textureProvider()->createTexture(desc, true, storage.get(), bitmap->width()); } else { bmp.copyTo(&tmpBitmap, kN32_SkColorType); // now bitmap points to our temp, which has been promoted to 32bits bitmap = &tmpBitmap; desc.fConfig = SkImageInfo2GrPixelConfig(bitmap->info()); } } else if (!bitmap->readyToDraw()) { // If the bitmap had compressed data and was then uncompressed, it'll still return // compressed data on 'refEncodedData' and upload it. Probably not good, since if // the bitmap has available pixels, then they might not be what the decompressed // data is. // Really?? We aren't doing this with YUV. GrTexture *texture = load_etc1_texture(ctx, *bitmap, desc); if (texture) { return texture; } } GrTexture *texture = create_texture_from_yuv(ctx, *bitmap, desc); if (texture) { return texture; } SkAutoLockPixels alp(*bitmap); if (!bitmap->readyToDraw()) { return nullptr; } return ctx->textureProvider()->createTexture(desc, true, bitmap->getPixels(), bitmap->rowBytes()); }
/** * A test for the SkDecodingImageGenerator::Create and * SkInstallDiscardablePixelRef functions. */ DEF_TEST(ImprovedBitmapFactory, reporter) { SkString pngFilename = GetResourcePath("randPixels.png"); SkAutoTDelete<SkStreamRewindable> stream(SkStream::NewFromFile(pngFilename.c_str())); if (sk_exists(pngFilename.c_str())) { SkBitmap bm; SkAssertResult(bm.setInfo(SkImageInfo::MakeN32Premul(1, 1))); REPORTER_ASSERT(reporter, install_pixel_ref(&bm, stream.detach(), 1, true)); SkAutoLockPixels alp(bm); REPORTER_ASSERT(reporter, bm.getPixels()); } }
static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject, const SkBitmap* bitmap, jobject jbuffer) { SkAutoLockPixels alp(*bitmap); const void* src = bitmap->getPixels(); if (NULL != src) { android::AutoBufferPointer abp(env, jbuffer, JNI_TRUE); // the java side has already checked that buffer is large enough memcpy(abp.pointer(), src, bitmap->getSize()); } }
bool SkBlurImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source, const SkMatrix& ctm, SkBitmap* dst, SkIPoint* offset) { SkBitmap src = this->getInputResult(proxy, source, ctm, offset); if (src.config() != SkBitmap::kARGB_8888_Config) { return false; } SkAutoLockPixels alp(src); if (!src.getPixels()) { return false; } dst->setConfig(src.config(), src.width(), src.height()); dst->allocPixels(); int kernelSizeX, kernelSizeX3, lowOffsetX, highOffsetX; int kernelSizeY, kernelSizeY3, lowOffsetY, highOffsetY; getBox3Params(fSigma.width(), &kernelSizeX, &kernelSizeX3, &lowOffsetX, &highOffsetX); getBox3Params(fSigma.height(), &kernelSizeY, &kernelSizeY3, &lowOffsetY, &highOffsetY); if (kernelSizeX < 0 || kernelSizeY < 0) { return false; } if (kernelSizeX == 0 && kernelSizeY == 0) { src.copyTo(dst, dst->config()); return true; } SkBitmap temp; temp.setConfig(dst->config(), dst->width(), dst->height()); if (!temp.allocPixels()) { return false; } if (kernelSizeX > 0 && kernelSizeY > 0) { boxBlurX(src, &temp, kernelSizeX, lowOffsetX, highOffsetX); boxBlurY(temp, dst, kernelSizeY, lowOffsetY, highOffsetY); boxBlurX(*dst, &temp, kernelSizeX, highOffsetX, lowOffsetX); boxBlurY(temp, dst, kernelSizeY, highOffsetY, lowOffsetY); boxBlurX(*dst, &temp, kernelSizeX3, highOffsetX, highOffsetX); boxBlurY(temp, dst, kernelSizeY3, highOffsetY, highOffsetY); } else if (kernelSizeX > 0) { boxBlurX(src, dst, kernelSizeX, lowOffsetX, highOffsetX); boxBlurX(*dst, &temp, kernelSizeX, highOffsetX, lowOffsetX); boxBlurX(temp, dst, kernelSizeX3, highOffsetX, highOffsetX); } else if (kernelSizeY > 0) { boxBlurY(src, dst, kernelSizeY, lowOffsetY, highOffsetY); boxBlurY(*dst, &temp, kernelSizeY, highOffsetY, lowOffsetY); boxBlurY(temp, dst, kernelSizeY3, highOffsetY, highOffsetY); } return true; }
static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject, jlong bitmapHandle, jobject jbuffer) { SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); SkAutoLockPixels alp(*bitmap); void* dst = bitmap->getPixels(); if (NULL != dst) { android::AutoBufferPointer abp(env, jbuffer, JNI_FALSE); // the java side has already checked that buffer is large enough memcpy(dst, abp.pointer(), bitmap->getSize()); bitmap->notifyPixelsChanged(); } }
static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextShader) { const BitmapShaderRec& rec = static_cast<const BitmapShaderRec&>(baseRec); SkAutoTUnref<SkShader>* result = reinterpret_cast<SkAutoTUnref<SkShader>*>(contextShader); result->reset(SkRef(rec.fShader.get())); SkBitmap tile; rec.fShader.get()->asABitmap(&tile, NULL, NULL); // FIXME: this doesn't protect the pixels from being discarded as soon as we unlock. // Should be handled via a pixel ref generator instead // (https://code.google.com/p/skia/issues/detail?id=3220). SkAutoLockPixels alp(tile, true); return tile.getPixels() != NULL; }