void KisColorSelectorComponent::paintEvent(QPainter* painter)
{
painter->save();
painter->translate(m_x, m_y);
paint(painter);
painter->restore();
m_dirty=false;
m_lastColorSpace=colorSpace();
}
void KisColorSelectorSimple::paint(QPainter* painter)
{
if(isDirty()) {
m_kocolor.convertTo(colorSpace());
m_pixelCache=QImage(width(), height(), QImage::Format_ARGB32_Premultiplied);
for(int x=0; x<width(); x++) {
for(int y=0; y<height(); y++) {
m_kocolor.fromQColor(colorAt(x, y));
m_kocolor.toQColor(&m_qcolor);
m_pixelCache.setPixel(x, y, m_qcolor.rgb());
}
}
}
painter->drawImage(0,0, m_pixelCache);
// draw blip
if(m_lastClickPos!=QPointF(-1,-1) && m_parent->displayBlip()) {
switch (m_parameter) {
case KisColorSelector::H:
case KisColorSelector::hsvS:
case KisColorSelector::hslS:
case KisColorSelector::V:
case KisColorSelector::L:
if(width()>height()) {
painter->setPen(QColor(0,0,0));
painter->drawLine(m_lastClickPos.x()*width()-1, 0, m_lastClickPos.x()*width()-1, height());
painter->setPen(QColor(255,255,255));
painter->drawLine(m_lastClickPos.x()*width()+1, 0, m_lastClickPos.x()*width()+1, height());
}
else {
painter->setPen(QColor(0,0,0));
painter->drawLine(0, m_lastClickPos.x()*height()-1, width(), m_lastClickPos.x()*height()-1);
painter->setPen(QColor(255,255,255));
painter->drawLine(0, m_lastClickPos.x()*height()+1, width(), m_lastClickPos.x()*height()+1);
}
break;
case KisColorSelector::SL:
case KisColorSelector::SV:
case KisColorSelector::SV2:
case KisColorSelector::hslSH:
case KisColorSelector::hsvSH:
case KisColorSelector::VH:
case KisColorSelector::LH:
painter->setPen(QColor(0,0,0));
painter->drawEllipse(m_lastClickPos.x()*width()-5, m_lastClickPos.y()*height()-5, 10, 10);
painter->setPen(QColor(255,255,255));
painter->drawEllipse(m_lastClickPos.x()*width()-4, m_lastClickPos.y()*height()-4, 8, 8);
break;
}
}
}
void KisCloneLayer::copyOriginalToProjection(const KisPaintDeviceSP original,
KisPaintDeviceSP projection,
const QRect& rect) const
{
QRect copyRect = rect;
copyRect.translate(-m_d->x, -m_d->y);
KisPainter gc(projection);
gc.setCompositeOp(colorSpace()->compositeOp(COMPOSITE_COPY));
gc.bitBlt(rect.topLeft(), original, copyRect);
}
PassOwnPtr<GraphicsContext> BackingStore::createGraphicsContext()
{
RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
RetainPtr<CGContextRef> bitmapContext(AdoptCF, CGBitmapContextCreate(data(), m_size.width(), m_size.height(), 8, m_size.width() * 4, colorSpace.get(),
kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host));
// We want the origin to be in the top left corner so flip the backing store context.
CGContextTranslateCTM(bitmapContext.get(), 0, m_size.height());
CGContextScaleCTM(bitmapContext.get(), 1, -1);
return adoptPtr(new GraphicsContext(bitmapContext.get()));
}
void ChunkedUpdateDrawingArea::paintIntoUpdateChunk(UpdateChunk* updateChunk)
{
RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
RetainPtr<CGContextRef> bitmapContext(AdoptCF, CGBitmapContextCreate(updateChunk->data(), updateChunk->rect().width(), updateChunk->rect().height(), 8, updateChunk->rect().width() * 4, colorSpace.get(), kCGImageAlphaPremultipliedLast));
// WebCore expects a flipped coordinate system.
CGContextTranslateCTM(bitmapContext.get(), 0.0, updateChunk->rect().height());
CGContextScaleCTM(bitmapContext.get(), 1.0, -1.0);
// Now paint into the backing store.
GraphicsContext graphicsContext(bitmapContext.get());
graphicsContext.translate(-updateChunk->rect().x(), -updateChunk->rect().y());
m_webPage->drawRect(graphicsContext, updateChunk->rect());
}
bool WEBPImageDecoder::initFrameBuffer(size_t frameIndex) {
ImageFrame& buffer = m_frameBufferCache[frameIndex];
if (buffer.getStatus() != ImageFrame::FrameEmpty) // Already initialized.
return true;
const size_t requiredPreviousFrameIndex = buffer.requiredPreviousFrameIndex();
if (requiredPreviousFrameIndex == kNotFound) {
// This frame doesn't rely on any previous data.
if (!buffer.setSizeAndColorSpace(size().width(), size().height(),
colorSpace()))
return setFailed();
m_frameBackgroundHasAlpha =
!buffer.originalFrameRect().contains(IntRect(IntPoint(), size()));
} else {
ImageFrame& prevBuffer = m_frameBufferCache[requiredPreviousFrameIndex];
ASSERT(prevBuffer.getStatus() == ImageFrame::FrameComplete);
// Preserve the last frame as the starting state for this frame. We try
// to reuse |prevBuffer| as starting state to avoid copying.
// For BlendAtopPreviousFrame, both frames are required, so we can't
// take over its image data using takeBitmapDataIfWritable.
if ((buffer.getAlphaBlendSource() == ImageFrame::BlendAtopPreviousFrame ||
!buffer.takeBitmapDataIfWritable(&prevBuffer)) &&
!buffer.copyBitmapData(prevBuffer))
return setFailed();
if (prevBuffer.getDisposalMethod() == ImageFrame::DisposeOverwriteBgcolor) {
// We want to clear the previous frame to transparent, without
// affecting pixels in the image outside of the frame.
const IntRect& prevRect = prevBuffer.originalFrameRect();
ASSERT(!prevRect.contains(IntRect(IntPoint(), size())));
buffer.zeroFillFrameRect(prevRect);
}
m_frameBackgroundHasAlpha =
prevBuffer.hasAlpha() ||
(prevBuffer.getDisposalMethod() == ImageFrame::DisposeOverwriteBgcolor);
}
buffer.setStatus(ImageFrame::FramePartial);
// The buffer is transparent outside the decoded area while the image is
// loading. The correct alpha value for the frame will be set when it is fully
// decoded.
buffer.setHasAlpha(true);
return true;
}
void KisColorSelectorRing::paint(QPainter* painter)
{
if(isDirty()) {
m_cachedColorSpace = colorSpace();
m_cachedSize=qMin(width(), height());
colorCache();
paintCache();
}
int size = qMin(width(), height());
if(m_cachedSize!=size) {
m_cachedSize=size;
paintCache();
}
painter->drawImage(width()/2-m_pixelCache.width()/2,
height()/2-m_pixelCache.height()/2,
m_pixelCache);
// paint blip
if(m_parent->displayBlip()) {
qreal angle;
int y_start, y_end, x_start, x_end;
angle=m_lastHue*2.*M_PI+(M_PI);
y_start=innerRadius()*sin(angle)+height()/2;
y_end=outerRadius()*sin(angle)+height()/2;
x_start=innerRadius()*cos(angle)+width()/2;
x_end=outerRadius()*cos(angle)+width()/2;
painter->setPen(QColor(0,0,0));
painter->drawLine(x_start, y_start, x_end, y_end);
angle+=M_PI/180.;
y_start=innerRadius()*sin(angle)+height()/2;
y_end=outerRadius()*sin(angle)+height()/2;
x_start=innerRadius()*cos(angle)+width()/2;
x_end=outerRadius()*cos(angle)+width()/2;
painter->setPen(QColor(255,255,255));
painter->drawLine(x_start, y_start, x_end, y_end);
}
}
QVector<QPolygon> KisPixelSelection::outline()
{
QRect selectionExtent = selectedExactRect();
qint32 xOffset = selectionExtent.x();
qint32 yOffset = selectionExtent.y();
qint32 width = selectionExtent.width();
qint32 height = selectionExtent.height();
quint8* buffer = new quint8[width*height];
readBytes(buffer, xOffset, yOffset, width, height);
KisOutlineGenerator generator(colorSpace(), *defaultPixel());
QVector<QPolygon> paths = generator.outline(buffer, xOffset, yOffset, width, height);
delete[] buffer;
return paths;
}
KoColor KisColorSelectorTriangle::colorAt(int x, int y) const
{
Q_ASSERT(x>=0 && x<=triangleWidth());
Q_ASSERT(y>=0 && y<=triangleHeight());
int triangleHeight = this->triangleHeight();
int horizontalLineLength = y*(2./sqrt(3.));
int horizontalLineStart = triangleWidth()/2.-horizontalLineLength/2.;
int horizontalLineEnd = horizontalLineStart+horizontalLineLength;
if(x<horizontalLineStart || x>horizontalLineEnd || y>triangleHeight)
return KoColor(Qt::transparent, colorSpace());
qreal relativeX = x-horizontalLineStart;
qreal value = (y)/qreal(triangleHeight);
qreal saturation = relativeX/qreal(horizontalLineLength);
return m_parent->converter()->fromHsvF(m_hue, saturation, value);
}
void GraphicsContext3D::paintToCanvas(const unsigned char* imagePixels, int imageWidth, int imageHeight, int canvasWidth, int canvasHeight, CGContextRef context)
{
if (!imagePixels || imageWidth <= 0 || imageHeight <= 0 || canvasWidth <= 0 || canvasHeight <= 0 || !context)
return;
int rowBytes = imageWidth * 4;
RetainPtr<CGDataProviderRef> dataProvider(AdoptCF, CGDataProviderCreateWithData(0, imagePixels, rowBytes * imageHeight, 0));
RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
RetainPtr<CGImageRef> cgImage(AdoptCF, CGImageCreate(imageWidth, imageHeight, 8, 32, rowBytes, colorSpace.get(), kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
dataProvider.get(), 0, false, kCGRenderingIntentDefault));
// CSS styling may cause the canvas's content to be resized on
// the page. Go back to the Canvas to figure out the correct
// width and height to draw.
CGRect rect = CGRectMake(0, 0, canvasWidth, canvasHeight);
// We want to completely overwrite the previous frame's
// rendering results.
CGContextSaveGState(context);
CGContextSetBlendMode(context, kCGBlendModeCopy);
CGContextSetInterpolationQuality(context, kCGInterpolationNone);
CGContextDrawImage(context, rect, cgImage.get());
CGContextRestoreGState(context);
}
PassRefPtr<BitmapContext> createBitmapContextFromWebView(bool onscreen, bool incrementalRepaint, bool sweepHorizontally, bool drawSelectionRect)
{
RECT frame;
if (!GetWindowRect(webViewWindow, &frame))
return 0;
BITMAPINFO bmp = {0};
bmp.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmp.bmiHeader.biWidth = frame.right - frame.left;
bmp.bmiHeader.biHeight = -(frame.bottom - frame.top);
bmp.bmiHeader.biPlanes = 1;
bmp.bmiHeader.biBitCount = 32;
bmp.bmiHeader.biCompression = BI_RGB;
void* bits = 0;
HBITMAP bitmap = CreateDIBSection(0, &bmp, DIB_RGB_COLORS, &bits, 0, 0);
HDC memoryDC = CreateCompatibleDC(0);
SelectObject(memoryDC, bitmap);
SendMessage(webViewWindow, WM_PRINT, reinterpret_cast<WPARAM>(memoryDC), PRF_CLIENT | PRF_CHILDREN | PRF_OWNED);
DeleteDC(memoryDC);
BITMAP info = {0};
GetObject(bitmap, sizeof(info), &info);
ASSERT(info.bmBitsPixel == 32);
#if USE(CG)
RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
CGContextRef context = CGBitmapContextCreate(info.bmBits, info.bmWidth, info.bmHeight, 8,
info.bmWidthBytes, colorSpace.get(), kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
#elif USE(CAIRO)
cairo_surface_t* image = cairo_image_surface_create_for_data((unsigned char*)info.bmBits, CAIRO_FORMAT_ARGB32,
info.bmWidth, info.bmHeight, info.bmWidthBytes);
cairo_t* context = cairo_create(image);
cairo_surface_destroy(image);
#endif
return BitmapContext::createByAdoptingBitmapAndContext(bitmap, context);
}
//depth->color
void KinectSensor::create_rgbd(cv::Mat& depth_im, cv::Mat& rgb_im, cv::Mat* rgbd_im)
{
// Depth座標系に対応するカラー座標系の一覧を取得する
std::vector<ColorSpacePoint> colorSpace(KINECT_WIDTH * KINECT_HEIGHT);
pCoordinateMapper->MapDepthFrameToColorSpace(
KINECT_WIDTH*KINECT_HEIGHT, (UINT16*)depth_im.data, colorSpace.size(), &colorSpace[0]);
for (int y = 0; y < KINECT_HEIGHT; y++) {
for (int x = 0; x < KINECT_WIDTH; x++) {
if (depth_im.at<short>(y, x)>0) {
ColorSpacePoint colorPoint = colorSpace[y*KINECT_WIDTH + x];
int colorX = (int)colorPoint.X;
int colorY = (int)colorPoint.Y;
if ((colorX >= 0) && (colorX < KINECT_COLOR_WIDTH) && (colorY >= 0) && (colorY < KINECT_COLOR_HEIGHT)) {
rgbd_im->at<cv::Vec4b>(y, x) = rgb_im.at<cv::Vec4b>(colorY, colorX);
}
}
else {
rgbd_im->at<cv::Vec4b>(y, x) = 0;
}
}
}
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
//
// Modality VOILUT transform
//
//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
modalityVOILUT::modalityVOILUT(ptr<dataSet> pDataSet):
m_pDataSet(pDataSet), m_voiLut(pDataSet->getLut(0x0028, 0x3000, 0)), m_rescaleIntercept(pDataSet->getDouble(0x0028, 0, 0x1052, 0x0)), m_rescaleSlope(1.0), m_bEmpty(true)
{
// Only monochrome images can have the modality voi-lut
///////////////////////////////////////////////////////
std::wstring colorSpace(pDataSet->getUnicodeString(0x0028, 0x0, 0x0004, 0x0));
if(!colorTransforms::colorTransformsFactory::isMonochrome(colorSpace))
{
return;
}
ptr<handlers::dataHandler> rescaleHandler(m_pDataSet->getDataHandler(0x0028, 0, 0x1053, 0x0, false));
if(rescaleHandler != 0)
{
m_rescaleSlope = rescaleHandler->getDouble(0);
m_bEmpty = false;
}
if(m_voiLut != 0 && m_voiLut->getSize() != 0)
{
m_bEmpty = false;
}
}
static CGContextRef createCGContextFromImage(WKImageRef wkImage, FlipGraphicsContextOrNot flip = DontFlipGraphicsContext)
{
RetainPtr<CGImageRef> image(AdoptCF, WKImageCreateCGImage(wkImage));
size_t pixelsWide = CGImageGetWidth(image.get());
size_t pixelsHigh = CGImageGetHeight(image.get());
size_t rowBytes = (4 * pixelsWide + 63) & ~63;
// Creating this bitmap in the device color space should prevent any color conversion when the image of the web view is drawn into it.
RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
CGContextRef context = CGBitmapContextCreate(0, pixelsWide, pixelsHigh, 8, rowBytes, colorSpace.get(), kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host);
if (flip == FlipGraphicsContext) {
CGContextSaveGState(context);
CGContextScaleCTM(context, 1, -1);
CGContextTranslateCTM(context, 0, -static_cast<CGFloat>(pixelsHigh));
}
CGContextDrawImage(context, CGRectMake(0, 0, pixelsWide, pixelsHigh), image.get());
if (flip == FlipGraphicsContext)
CGContextRestoreGState(context);
return context;
}
void KisCloneLayer::updateProjection(const QRect& r)
{
if (!m_d->copyFrom) return;
if (!r.isValid()) return ;
// XXX: update only the overlap of r and the rects in the dirty region
// if there are effect masks, apply them to the either original or
// to the original's projection.
if (hasEffectMasks()) {
if (m_d->projection == 0) {
m_d->projection = new KisPaintDevice(m_d->copyFrom->colorSpace());
}
qint32 deltaX = m_d->copyFrom->x() - m_d->x;
qint32 deltaY = m_d->copyFrom->y() - m_d->y;
QRect rc = r.translated(deltaX, deltaY);
KisPainter gc(m_d->projection);
gc.setCompositeOp(colorSpace()->compositeOp(COMPOSITE_COPY));
// TODO don't copy
KisPaintDeviceSP src = 0;
switch (m_d->type) {
case COPY_PROJECTION:
gc.bitBlt(rc.topLeft(), m_d->copyFrom->projection(), rc);
src = m_d->copyFrom->projection();
break;
case COPY_ORIGINAL:
default:
gc.bitBlt(rc.topLeft(), m_d->copyFrom->original(), rc);
src = m_d->copyFrom->original();
}
applyEffectMasks(m_d->copyFrom->original(), m_d->projection, r);
}
}
void ContentLayerChromium::updateContents()
{
RenderLayerBacking* backing = static_cast<RenderLayerBacking*>(m_owner->client());
if (!backing || backing->paintingGoesToWindow())
return;
ASSERT(drawsContent());
ASSERT(layerRenderer());
void* pixels = 0;
IntRect dirtyRect;
IntRect updateRect;
IntSize requiredTextureSize;
IntSize bitmapSize;
// FIXME: Remove this test when tiled layers are implemented.
if (requiresClippedUpdateRect()) {
// A layer with 3D transforms could require an arbitrarily large number
// of texels to be repainted, so ignore these layers until tiling is
// implemented.
if (!drawTransform().isIdentityOrTranslation()) {
m_skipsDraw = true;
return;
}
calculateClippedUpdateRect(dirtyRect, m_largeLayerDrawRect);
if (!layerRenderer()->checkTextureSize(m_largeLayerDrawRect.size())) {
m_skipsDraw = true;
return;
}
// If the portion of the large layer that's visible hasn't changed
// then we don't need to update it, _unless_ its contents have changed
// in which case we only update the dirty bits.
if (m_largeLayerDirtyRect == dirtyRect) {
if (!m_dirtyRect.intersects(dirtyRect))
return;
dirtyRect.intersect(IntRect(m_dirtyRect));
updateRect = dirtyRect;
requiredTextureSize = m_largeLayerDirtyRect.size();
} else {
m_largeLayerDirtyRect = dirtyRect;
requiredTextureSize = dirtyRect.size();
updateRect = IntRect(IntPoint(0, 0), dirtyRect.size());
}
} else {
dirtyRect = IntRect(m_dirtyRect);
IntRect boundsRect(IntPoint(0, 0), m_bounds);
requiredTextureSize = m_bounds;
// If the texture needs to be reallocated then we must redraw the entire
// contents of the layer.
if (requiredTextureSize != m_allocatedTextureSize)
dirtyRect = boundsRect;
else {
// Clip the dirtyRect to the size of the layer to avoid drawing
// outside the bounds of the backing texture.
dirtyRect.intersect(boundsRect);
}
updateRect = dirtyRect;
}
if (dirtyRect.isEmpty())
return;
#if PLATFORM(SKIA)
const SkBitmap* skiaBitmap = 0;
OwnPtr<skia::PlatformCanvas> canvas;
OwnPtr<PlatformContextSkia> skiaContext;
OwnPtr<GraphicsContext> graphicsContext;
canvas.set(new skia::PlatformCanvas(dirtyRect.width(), dirtyRect.height(), false));
skiaContext.set(new PlatformContextSkia(canvas.get()));
// This is needed to get text to show up correctly.
// FIXME: Does this take us down a very slow text rendering path?
skiaContext->setDrawingToImageBuffer(true);
graphicsContext.set(new GraphicsContext(reinterpret_cast<PlatformGraphicsContext*>(skiaContext.get())));
// Bring the canvas into the coordinate system of the paint rect.
canvas->translate(static_cast<SkScalar>(-dirtyRect.x()), static_cast<SkScalar>(-dirtyRect.y()));
m_owner->paintGraphicsLayerContents(*graphicsContext, dirtyRect);
const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(false);
skiaBitmap = &bitmap;
ASSERT(skiaBitmap);
SkAutoLockPixels lock(*skiaBitmap);
SkBitmap::Config skiaConfig = skiaBitmap->config();
// FIXME: do we need to support more image configurations?
if (skiaConfig == SkBitmap::kARGB_8888_Config) {
pixels = skiaBitmap->getPixels();
bitmapSize = IntSize(skiaBitmap->width(), skiaBitmap->height());
}
#elif PLATFORM(CG)
Vector<uint8_t> tempVector;
int rowBytes = 4 * dirtyRect.width();
tempVector.resize(rowBytes * dirtyRect.height());
memset(tempVector.data(), 0, tempVector.size());
RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
RetainPtr<CGContextRef> contextCG(AdoptCF, CGBitmapContextCreate(tempVector.data(),
dirtyRect.width(), dirtyRect.height(), 8, rowBytes,
colorSpace.get(),
kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host));
CGContextTranslateCTM(contextCG.get(), 0, dirtyRect.height());
CGContextScaleCTM(contextCG.get(), 1, -1);
GraphicsContext graphicsContext(contextCG.get());
// Translate the graphics context into the coordinate system of the dirty rect.
graphicsContext.translate(-dirtyRect.x(), -dirtyRect.y());
m_owner->paintGraphicsLayerContents(graphicsContext, dirtyRect);
pixels = tempVector.data();
bitmapSize = dirtyRect.size();
#else
#error "Need to implement for your platform."
#endif
unsigned textureId = m_contentsTexture;
if (!textureId)
textureId = layerRenderer()->createLayerTexture();
if (pixels)
updateTextureRect(pixels, bitmapSize, requiredTextureSize, updateRect, textureId);
}
std::unique_ptr<GraphicsContext> ShareableBitmap::createGraphicsContext()
{
ref(); // Balanced by deref in releaseBitmapContextData.
RetainPtr<CGContextRef> bitmapContext = adoptCF(CGBitmapContextCreateWithData(data(), m_size.width(), m_size.height(), m_bytesPerPixel * 8 / 4, m_size.width() * m_bytesPerPixel, colorSpace(m_flags), bitmapInfo(m_flags), releaseBitmapContextData, this));
ASSERT(bitmapContext.get());
// We want the origin to be in the top left corner so we flip the backing store context.
CGContextTranslateCTM(bitmapContext.get(), 0, m_size.height());
CGContextScaleCTM(bitmapContext.get(), 1, -1);
return std::make_unique<GraphicsContext>(bitmapContext.get());
}
RetainPtr<CGImageRef> ShareableBitmap::createCGImage(CGDataProviderRef dataProvider) const
{
ASSERT_ARG(dataProvider, dataProvider);
RetainPtr<CGImageRef> image = adoptCF(CGImageCreate(m_size.width(), m_size.height(), m_bytesPerPixel * 8 / 4, m_bytesPerPixel * 8, m_size.width() * m_bytesPerPixel, colorSpace(m_flags), bitmapInfo(m_flags), dataProvider, 0, false, kCGRenderingIntentDefault));
return image;
}
void KoColor::fromKoColor(const KoColor& src)
{
src.colorSpace()->convertPixelsTo(src.d->data, d->data, colorSpace(), 1);
}
bool KoColor::operator==(const KoColor &other) const
{
if (!(*colorSpace() == *other.colorSpace()))
return false;
return memcmp(d->data, other.d->data, d->colorSpace->pixelSize()) == 0;
}
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
bool SkImageShader::onAppendStages(const StageRec& rec) const {
SkRasterPipeline* p = rec.fPipeline;
SkArenaAlloc* alloc = rec.fAlloc;
SkMatrix matrix;
if (!this->computeTotalInverse(rec.fCTM, rec.fLocalM, &matrix)) {
return false;
}
auto quality = rec.fPaint.getFilterQuality();
SkBitmapProvider provider(fImage.get(), rec.fDstCS);
SkDefaultBitmapController controller;
std::unique_ptr<SkBitmapController::State> state {
controller.requestBitmap(provider, matrix, quality)
};
if (!state) {
return false;
}
const SkPixmap& pm = state->pixmap();
matrix = state->invMatrix();
quality = state->quality();
auto info = pm.info();
// When the matrix is just an integer translate, bilerp == nearest neighbor.
if (quality == kLow_SkFilterQuality &&
matrix.getType() <= SkMatrix::kTranslate_Mask &&
matrix.getTranslateX() == (int)matrix.getTranslateX() &&
matrix.getTranslateY() == (int)matrix.getTranslateY()) {
quality = kNone_SkFilterQuality;
}
// See skia:4649 and the GM image_scale_aligned.
if (quality == kNone_SkFilterQuality) {
if (matrix.getScaleX() >= 0) {
matrix.setTranslateX(nextafterf(matrix.getTranslateX(),
floorf(matrix.getTranslateX())));
}
if (matrix.getScaleY() >= 0) {
matrix.setTranslateY(nextafterf(matrix.getTranslateY(),
floorf(matrix.getTranslateY())));
}
}
p->append(SkRasterPipeline::seed_shader);
struct MiscCtx {
std::unique_ptr<SkBitmapController::State> state;
SkColor4f paint_color;
};
auto misc = alloc->make<MiscCtx>();
misc->state = std::move(state); // Extend lifetime to match the pipeline's.
misc->paint_color = SkColor4f_from_SkColor(rec.fPaint.getColor(), rec.fDstCS);
p->append_matrix(alloc, matrix);
auto gather = alloc->make<SkJumper_GatherCtx>();
gather->pixels = pm.addr();
gather->stride = pm.rowBytesAsPixels();
gather->width = pm.width();
gather->height = pm.height();
auto limit_x = alloc->make<SkJumper_TileCtx>(),
limit_y = alloc->make<SkJumper_TileCtx>();
limit_x->scale = pm.width();
limit_x->invScale = 1.0f / pm.width();
limit_y->scale = pm.height();
limit_y->invScale = 1.0f / pm.height();
bool is_srgb = rec.fDstCS && (!info.colorSpace() || info.gammaCloseToSRGB());
SkJumper_DecalTileCtx* decal_ctx = nullptr;
bool decal_x_and_y = fTileModeX == kDecal_TileMode && fTileModeY == kDecal_TileMode;
if (fTileModeX == kDecal_TileMode || fTileModeY == kDecal_TileMode) {
decal_ctx = alloc->make<SkJumper_DecalTileCtx>();
decal_ctx->limit_x = limit_x->scale;
decal_ctx->limit_y = limit_y->scale;
}
auto append_tiling_and_gather = [&] {
if (decal_x_and_y) {
p->append(SkRasterPipeline::decal_x_and_y, decal_ctx);
} else {
switch (fTileModeX) {
case kClamp_TileMode: /* The gather_xxx stage will clamp for us. */ break;
case kMirror_TileMode: p->append(SkRasterPipeline::mirror_x, limit_x); break;
case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_x, limit_x); break;
case kDecal_TileMode: p->append(SkRasterPipeline::decal_x, decal_ctx); break;
}
switch (fTileModeY) {
case kClamp_TileMode: /* The gather_xxx stage will clamp for us. */ break;
case kMirror_TileMode: p->append(SkRasterPipeline::mirror_y, limit_y); break;
case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_y, limit_y); break;
case kDecal_TileMode: p->append(SkRasterPipeline::decal_y, decal_ctx); break;
}
}
void* ctx = gather;
switch (info.colorType()) {
case kAlpha_8_SkColorType: p->append(SkRasterPipeline::gather_a8, ctx); break;
case kGray_8_SkColorType: p->append(SkRasterPipeline::gather_g8, ctx); break;
case kRGB_565_SkColorType: p->append(SkRasterPipeline::gather_565, ctx); break;
case kARGB_4444_SkColorType: p->append(SkRasterPipeline::gather_4444, ctx); break;
case kBGRA_8888_SkColorType: p->append(SkRasterPipeline::gather_bgra, ctx); break;
case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); break;
case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); break;
case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::gather_f16, ctx); break;
case kRGB_888x_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx);
p->append(SkRasterPipeline::force_opaque ); break;
case kRGB_101010x_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx);
p->append(SkRasterPipeline::force_opaque ); break;
default: SkASSERT(false);
}
if (decal_ctx) {
p->append(SkRasterPipeline::check_decal_mask, decal_ctx);
}
if (is_srgb) {
p->append(SkRasterPipeline::from_srgb);
}
};
auto append_misc = [&] {
if (info.colorType() == kAlpha_8_SkColorType) {
p->append(SkRasterPipeline::set_rgb, &misc->paint_color);
}
if (info.colorType() == kAlpha_8_SkColorType ||
info.alphaType() == kUnpremul_SkAlphaType) {
p->append(SkRasterPipeline::premul);
}
if (quality > kLow_SkFilterQuality) {
// Bicubic filtering naturally produces out of range values on both sides.
p->append(SkRasterPipeline::clamp_0);
p->append(fClampAsIfUnpremul ? SkRasterPipeline::clamp_1
: SkRasterPipeline::clamp_a);
}
append_gamut_transform(p, alloc, info.colorSpace(), rec.fDstCS,
fClampAsIfUnpremul ? kUnpremul_SkAlphaType : kPremul_SkAlphaType);
return true;
};
// We've got a fast path for 8888 bilinear clamp/clamp non-color-managed sampling.
auto ct = info.colorType();
if (true
&& (ct == kRGBA_8888_SkColorType || ct == kBGRA_8888_SkColorType)
&& quality == kLow_SkFilterQuality
&& fTileModeX == SkShader::kClamp_TileMode
&& fTileModeY == SkShader::kClamp_TileMode
&& !is_srgb) {
p->append(SkRasterPipeline::bilerp_clamp_8888, gather);
if (ct == kBGRA_8888_SkColorType) {
p->append(SkRasterPipeline::swap_rb);
}
return append_misc();
}
SkJumper_SamplerCtx* sampler = nullptr;
if (quality != kNone_SkFilterQuality) {
sampler = alloc->make<SkJumper_SamplerCtx>();
}
auto sample = [&](SkRasterPipeline::StockStage setup_x,
SkRasterPipeline::StockStage setup_y) {
p->append(setup_x, sampler);
p->append(setup_y, sampler);
append_tiling_and_gather();
p->append(SkRasterPipeline::accumulate, sampler);
};
if (quality == kNone_SkFilterQuality) {
append_tiling_and_gather();
} else if (quality == kLow_SkFilterQuality) {
p->append(SkRasterPipeline::save_xy, sampler);
sample(SkRasterPipeline::bilinear_nx, SkRasterPipeline::bilinear_ny);
sample(SkRasterPipeline::bilinear_px, SkRasterPipeline::bilinear_ny);
sample(SkRasterPipeline::bilinear_nx, SkRasterPipeline::bilinear_py);
sample(SkRasterPipeline::bilinear_px, SkRasterPipeline::bilinear_py);
p->append(SkRasterPipeline::move_dst_src);
} else {
p->append(SkRasterPipeline::save_xy, sampler);
sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_n3y);
sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_n3y);
sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_n3y);
sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_n3y);
sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_n1y);
sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_n1y);
sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_n1y);
sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_n1y);
sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_p1y);
sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_p1y);
sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_p1y);
sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_p1y);
sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_p3y);
sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_p3y);
sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_p3y);
sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_p3y);
p->append(SkRasterPipeline::move_dst_src);
}
return append_misc();
}
bool WEBPImageDecoder::decodeSingleFrame(const uint8_t* dataBytes,
size_t dataSize,
size_t frameIndex) {
if (failed())
return false;
ASSERT(isDecodedSizeAvailable());
ASSERT(m_frameBufferCache.size() > frameIndex);
ImageFrame& buffer = m_frameBufferCache[frameIndex];
ASSERT(buffer.getStatus() != ImageFrame::FrameComplete);
if (buffer.getStatus() == ImageFrame::FrameEmpty) {
if (!buffer.setSizeAndColorSpace(size().width(), size().height(),
colorSpace()))
return setFailed();
buffer.setStatus(ImageFrame::FramePartial);
// The buffer is transparent outside the decoded area while the image is
// loading. The correct alpha value for the frame will be set when it is
// fully decoded.
buffer.setHasAlpha(true);
buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
}
const IntRect& frameRect = buffer.originalFrameRect();
if (!m_decoder) {
WEBP_CSP_MODE mode = outputMode(m_formatFlags & ALPHA_FLAG);
if (!m_premultiplyAlpha)
mode = outputMode(false);
if (colorTransform()) {
// Swizzling between RGBA and BGRA is zero cost in a color transform.
// So when we have a color transform, we should decode to whatever is
// easiest for libwebp, and then let the color transform swizzle if
// necessary.
// Lossy webp is encoded as YUV (so RGBA and BGRA are the same cost).
// Lossless webp is encoded as BGRA. This means decoding to BGRA is
// either faster or the same cost as RGBA.
mode = MODE_BGRA;
}
WebPInitDecBuffer(&m_decoderBuffer);
m_decoderBuffer.colorspace = mode;
m_decoderBuffer.u.RGBA.stride =
size().width() * sizeof(ImageFrame::PixelData);
m_decoderBuffer.u.RGBA.size =
m_decoderBuffer.u.RGBA.stride * frameRect.height();
m_decoderBuffer.is_external_memory = 1;
m_decoder = WebPINewDecoder(&m_decoderBuffer);
if (!m_decoder)
return setFailed();
}
m_decoderBuffer.u.RGBA.rgba =
reinterpret_cast<uint8_t*>(buffer.getAddr(frameRect.x(), frameRect.y()));
switch (WebPIUpdate(m_decoder, dataBytes, dataSize)) {
case VP8_STATUS_OK:
applyPostProcessing(frameIndex);
buffer.setHasAlpha((m_formatFlags & ALPHA_FLAG) ||
m_frameBackgroundHasAlpha);
buffer.setStatus(ImageFrame::FrameComplete);
clearDecoder();
return true;
case VP8_STATUS_SUSPENDED:
if (!isAllDataReceived() && !frameIsCompleteAtIndex(frameIndex)) {
applyPostProcessing(frameIndex);
return false;
}
// FALLTHROUGH
default:
clear();
return setFailed();
}
}
void TFT_ILI9163C::chipInit() {
uint8_t i;
#if defined(__GAMMASET1)
const uint8_t pGammaSet[15]= {0x36,0x29,0x12,0x22,0x1C,0x15,0x42,0xB7,0x2F,0x13,0x12,0x0A,0x11,0x0B,0x06};
const uint8_t nGammaSet[15]= {0x09,0x16,0x2D,0x0D,0x13,0x15,0x40,0x48,0x53,0x0C,0x1D,0x25,0x2E,0x34,0x39};
#elif defined(__GAMMASET2)
const uint8_t pGammaSet[15]= {0x3F,0x21,0x12,0x22,0x1C,0x15,0x42,0xB7,0x2F,0x13,0x02,0x0A,0x01,0x00,0x00};
const uint8_t nGammaSet[15]= {0x09,0x18,0x2D,0x0D,0x13,0x15,0x40,0x48,0x53,0x0C,0x1D,0x25,0x2E,0x24,0x29};
#elif defined(__GAMMASET3)
const uint8_t pGammaSet[15]= {0x3F,0x26,0x23,0x30,0x28,0x10,0x55,0xB7,0x40,0x19,0x10,0x1E,0x02,0x01,0x00};
//&const uint8_t nGammaSet[15]= {0x00,0x19,0x1C,0x0F,0x14,0x0F,0x2A,0x48,0x3F,0x06,0x1D,0x21,0x3D,0x3F,0x3F};
const uint8_t nGammaSet[15]= {0x09,0x18,0x2D,0x0D,0x13,0x15,0x40,0x48,0x53,0x0C,0x1D,0x25,0x2E,0x24,0x29};
#else
const uint8_t pGammaSet[15]= {0x3F,0x25,0x1C,0x1E,0x20,0x12,0x2A,0x90,0x24,0x11,0x00,0x00,0x00,0x00,0x00};
const uint8_t nGammaSet[15]= {0x20,0x20,0x20,0x20,0x05,0x15,0x00,0xA7,0x3D,0x18,0x25,0x2A,0x2B,0x2B,0x3A};
#endif
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_cont(CMD_SWRESET);//software reset
delay(500);
writecommand_cont(CMD_SLPOUT);//exit sleep
delay(5);
writecommand_cont(CMD_PIXFMT);//Set Color Format 16bit
writedata8_cont(0x05);
delay(5);
writecommand_cont(CMD_GAMMASET);//default gamma curve 3
writedata8_cont(0x08);//0x04
delay(1);
writecommand_cont(CMD_GAMRSEL);//Enable Gamma adj
writedata8_cont(0x01);
delay(1);
writecommand_cont(CMD_NORML);
writecommand_cont(CMD_DFUNCTR);
writedata8_cont(0b11111111);//
writedata8_cont(0b00000110);//
writecommand_cont(CMD_PGAMMAC);//Positive Gamma Correction Setting
for (i=0;i<15;i++){
writedata8_cont(pGammaSet[i]);
}
writecommand_cont(CMD_NGAMMAC);//Negative Gamma Correction Setting
for (i=0;i<15;i++){
writedata8_cont(nGammaSet[i]);
}
writecommand_cont(CMD_FRMCTR1);//Frame Rate Control (In normal mode/Full colors)
writedata8_cont(0x08);//0x0C//0x08
writedata8_cont(0x02);//0x14//0x08
delay(1);
writecommand_cont(CMD_DINVCTR);//display inversion
writedata8_cont(0x07);
delay(1);
writecommand_cont(CMD_PWCTR1);//Set VRH1[4:0] & VC[2:0] for VCI1 & GVDD
writedata8_cont(0x0A);//4.30 - 0x0A
writedata8_cont(0x02);//0x05
delay(1);
writecommand_cont(CMD_PWCTR2);//Set BT[2:0] for AVDD & VCL & VGH & VGL
writedata8_cont(0x02);
delay(1);
writecommand_cont(CMD_VCOMCTR1);//Set VMH[6:0] & VML[6:0] for VOMH & VCOML
writedata8_cont(0x50);//0x50
writedata8_cont(99);//0x5b
delay(1);
writecommand_cont(CMD_VCOMOFFS);
writedata8_cont(0);//0x40
delay(1);
writecommand_cont(CMD_CLMADRS);//Set Column Address
/*
writedata8_cont(0x00);
writedata8_cont(0X00);
writedata8_cont(0X00);
writedata8_cont(_GRAMWIDTH);
*/
writedata16_cont(0x00);
writedata16_cont(_GRAMWIDTH);
writecommand_cont(CMD_PGEADRS);//Set Page Address
/*
writedata8_cont(0x00);
writedata8_cont(0X00);
writedata8_cont(0X00);
writedata8_last(_GRAMHEIGH);
*/
writedata16_cont(0x00);
writedata16_last(_GRAMHEIGH);
endProc();
colorSpace(_colorspaceData);
setRotation(0);
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_cont(CMD_DISPON);//display ON
delay(1);
writecommand_last(CMD_RAMWR);//Memory Write
SPI.endTransaction();
delay(1);
#else
writecommand(CMD_SWRESET);//software reset
delay(500);
writecommand(CMD_SLPOUT);//exit sleep
delay(5);
writecommand(CMD_PIXFMT);//Set Color Format 16bit
writedata(0x05);
delay(5);
writecommand(CMD_GAMMASET);//default gamma curve 3
writedata(0x04);//0x04
delay(1);
writecommand(CMD_GAMRSEL);//Enable Gamma adj
writedata(0x01);
delay(1);
writecommand(CMD_NORML);
writecommand(CMD_DFUNCTR);
writedata(0b11111111);//
writedata(0b00000110);//
writecommand(CMD_PGAMMAC);//Positive Gamma Correction Setting
for (i=0;i<15;i++){
writedata(pGammaSet[i]);
}
writecommand(CMD_NGAMMAC);//Negative Gamma Correction Setting
for (i=0;i<15;i++){
writedata(nGammaSet[i]);
}
writecommand(CMD_FRMCTR1);//Frame Rate Control (In normal mode/Full colors)
writedata(0x08);//0x0C//0x08
writedata(0x02);//0x14//0x08
delay(1);
writecommand(CMD_DINVCTR);//display inversion
writedata(0x07);
delay(1);
writecommand(CMD_PWCTR1);//Set VRH1[4:0] & VC[2:0] for VCI1 & GVDD
writedata(0x0A);//4.30 - 0x0A
writedata(0x02);//0x05
delay(1);
writecommand(CMD_PWCTR2);//Set BT[2:0] for AVDD & VCL & VGH & VGL
writedata(0x02);
delay(1);
writecommand(CMD_VCOMCTR1);//Set VMH[6:0] & VML[6:0] for VOMH & VCOML
writedata(0x50);//0x50
writedata(99);//0x5b
delay(1);
writecommand(CMD_VCOMOFFS);
writedata(0);//0x40
delay(1);
writecommand(CMD_CLMADRS);//Set Column Address
//writedata(0x00);
//writedata(0X00);
//writedata(0X00);
//writedata(_GRAMWIDTH);
writedata16(0x00);
writedata16(_GRAMWIDTH);
writecommand(CMD_PGEADRS);//Set Page Address
//writedata(0x00);
//writedata(0X00);
//writedata(0X00);
//writedata(_GRAMHEIGH);
writedata16(0X00);
writedata16(_GRAMHEIGH);
colorSpace(_colorspaceData);
setRotation(0);
writecommand(CMD_DISPON);//display ON
delay(1);
writecommand(CMD_RAMWR);//Memory Write
delay(1);
#endif
fillScreen(BLACK);
}
bool KisColorSelectorComponent::isDirty() const
{
return m_dirty || m_lastColorSpace!=colorSpace();
}
void KoColor::fromKoColor(const KoColor& src)
{
src.colorSpace()->convertPixelsTo(src.d->data, d->data, colorSpace(), 1, KoColorConversionTransformation::InternalRenderingIntent, KoColorConversionTransformation::InternalConversionFlags);
}