SkImageFilter::SkImageFilter(SkImageFilter* input1, SkImageFilter* input2)
: fInputCount(2), fInputs(new SkImageFilter*[2]) {
fInputs[0] = input1;
fInputs[1] = input2;
SkSafeRef(fInputs[0]);
SkSafeRef(fInputs[1]);
}
PlatformContextSkia::State::State(const State& other)
: m_alpha(other.m_alpha)
, m_xferMode(other.m_xferMode)
, m_useAntialiasing(other.m_useAntialiasing)
, m_looper(other.m_looper)
, m_fillColor(other.m_fillColor)
, m_fillShader(other.m_fillShader)
, m_strokeStyle(other.m_strokeStyle)
, m_strokeColor(other.m_strokeColor)
, m_strokeShader(other.m_strokeShader)
, m_strokeThickness(other.m_strokeThickness)
, m_dashRatio(other.m_dashRatio)
, m_miterLimit(other.m_miterLimit)
, m_lineCap(other.m_lineCap)
, m_lineJoin(other.m_lineJoin)
, m_dash(other.m_dash)
, m_textDrawingMode(other.m_textDrawingMode)
#if OS(LINUX) || OS(WINDOWS)
, m_imageBufferClip(other.m_imageBufferClip)
, m_clip(other.m_clip)
#endif
{
// Up the ref count of these. saveRef does nothing if 'this' is NULL.
SkSafeRef(m_looper);
SkSafeRef(m_dash);
SkSafeRef(m_fillShader);
SkSafeRef(m_strokeShader);
}
SkBlendImageFilter::SkBlendImageFilter(SkBlendImageFilter::Mode mode, SkImageFilter* background, SkImageFilter* foreground)
: fMode(mode), fBackground(background), fForeground(foreground)
{
SkASSERT(NULL != background);
SkSafeRef(fBackground);
SkSafeRef(fForeground);
}
SkImageFilter::SkImageFilter(SkImageFilter* input1, SkImageFilter* input2, const CropRect* cropRect)
: fInputCount(2), fInputs(new SkImageFilter*[2]),
fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)) {
fInputs[0] = input1;
fInputs[1] = input2;
SkSafeRef(fInputs[0]);
SkSafeRef(fInputs[1]);
}
SkDeferredCanvas::DeferredDevice::DeferredDevice(
SkDevice* immediateDevice, DeviceContext* deviceContext) :
SkDevice(SkBitmap::kNo_Config, immediateDevice->width(),
immediateDevice->height(), immediateDevice->isOpaque())
{
fDeviceContext = deviceContext;
SkSafeRef(fDeviceContext);
fImmediateDevice = immediateDevice; // ref counted via fImmediateCanvas
fImmediateCanvas = SkNEW_ARGS(SkCanvas, (fImmediateDevice));
SkSafeRef(fImmediateCanvas);
fRecordingCanvas = fPicture.beginRecording(fImmediateDevice->width(),
fImmediateDevice->height(),
SkPicture::kUsePathBoundsForClip_RecordingFlag);
}
SkGrPixelRef::SkGrPixelRef(const SkImageInfo& info, GrSurface* surface) : INHERITED(info) {
// For surfaces that are both textures and render targets, the texture owns the
// render target but not vice versa. So we ref the texture to keep both alive for
// the lifetime of this pixel ref.
fSurface = SkSafeRef(surface->asTexture());
if (NULL == fSurface) {
fSurface = SkSafeRef(surface);
}
if (fSurface) {
SkASSERT(info.width() <= fSurface->width());
SkASSERT(info.height() <= fSurface->height());
}
}
CanvasLayer::CanvasLayer(const CanvasLayer& layer)
: LayerAndroid(layer)
, m_canvas(0)
, m_bitmap(0)
{
init();
if (!layer.m_canvas) {
// The canvas has already been destroyed - this shouldn't happen
ALOGW("Creating a CanvasLayer for a destroyed canvas!");
m_visibleContentRect = IntRect();
m_offsetFromRenderer = IntSize();
m_texture->setHwAccelerated(false);
return;
}
// We are making a copy for the UI, sync the interesting bits
m_visibleContentRect = layer.visibleContentRect();
m_offsetFromRenderer = layer.offsetFromRenderer();
bool previousState = m_texture->hasValidTexture();
if (!previousState && layer.m_dirtyCanvas.isEmpty()) {
// We were previously in software and don't have anything new to draw,
// so stay in software
m_bitmap = layer.bitmap();
SkSafeRef(m_bitmap);
} else {
// Attempt to upload to a surface texture
if (!m_texture->uploadImageBuffer(layer.m_canvas->buffer())) {
// Blargh, no surface texture or ImageBuffer - fall back to software
m_bitmap = layer.bitmap();
SkSafeRef(m_bitmap);
// Merge the canvas invals with the layer's invals to repaint the needed
// tiles.
SkRegion::Iterator iter(layer.m_dirtyCanvas);
const IntPoint& offset = m_visibleContentRect.location();
for (; !iter.done(); iter.next()) {
SkIRect diff = iter.rect();
diff.fLeft += offset.x();
diff.fRight += offset.x();
diff.fTop += offset.y();
diff.fBottom += offset.y();
m_dirtyRegion.op(diff, SkRegion::kUnion_Op);
}
}
if (previousState != m_texture->hasValidTexture()) {
// Need to do a full inval of the canvas content as we are mode switching
m_dirtyRegion.op(m_visibleContentRect.x(), m_visibleContentRect.y(),
m_visibleContentRect.maxX(), m_visibleContentRect.maxY(), SkRegion::kUnion_Op);
}
}
}
MCRec(const MCRec* prev, int flags) {
if (NULL != prev) {
if (flags & SkCanvas::kMatrix_SaveFlag) {
fMatrixStorage = *prev->fMatrix;
fMatrix = &fMatrixStorage;
} else {
fMatrix = prev->fMatrix;
}
if (flags & SkCanvas::kClip_SaveFlag) {
fRegionStorage = *prev->fRegion;
fRegion = &fRegionStorage;
} else {
fRegion = prev->fRegion;
}
fFilter = prev->fFilter;
SkSafeRef(fFilter);
fTopLayer = prev->fTopLayer;
} else { // no prev
fMatrixStorage.reset();
fMatrix = &fMatrixStorage;
fRegion = &fRegionStorage;
fFilter = NULL;
fTopLayer = NULL;
}
fLayer = NULL;
// don't bother initializing fNext
inc_rec();
}
void SkDeferredCanvas::DeferredDevice::purgePending()
{
// TODO: find a way to transfer the state stack and layers
// to the new recording canvas. For now, purge only works
// with an empty stack.
if (fRecordingCanvas->getSaveCount() > 1)
return;
// Save state that is trashed by the purge
SkDrawFilter* drawFilter = fRecordingCanvas->getDrawFilter();
SkSafeRef(drawFilter); // So that it survives the purge
SkMatrix matrix = fRecordingCanvas->getTotalMatrix();
SkRegion clipRegion = fRecordingCanvas->getTotalClip();
// beginRecording creates a new recording canvas and discards the old one,
// hence purging deferred draw ops.
fRecordingCanvas = fPicture.beginRecording(fImmediateDevice->width(),
fImmediateDevice->height(),
SkPicture::kUsePathBoundsForClip_RecordingFlag);
// Restore pre-purge state
if (!clipRegion.isEmpty()) {
fRecordingCanvas->clipRegion(clipRegion, SkRegion::kReplace_Op);
}
if (!matrix.isIdentity()) {
fRecordingCanvas->setMatrix(matrix);
}
if (drawFilter) {
fRecordingCanvas->setDrawFilter(drawFilter)->unref();
}
}
PictureLayerContent::PictureLayerContent(SkPicture* picture)
: m_picture(picture)
, m_checkedContent(false)
, m_hasText(true)
{
SkSafeRef(m_picture);
}
PictureLayerContent::PictureLayerContent(const PictureLayerContent& content)
: m_picture(content.m_picture)
, m_checkedContent(content.m_checkedContent)
, m_hasText(content.m_hasText)
{
SkSafeRef(m_picture);
}
SkPicture* onNewPictureSnapshot() override {
SkBigPicture::SnapshotArray* pictList = NULL;
if (fDrawableList) {
// TODO: should we plumb-down the BBHFactory and recordFlags from our host
// PictureRecorder?
pictList = fDrawableList->newDrawableSnapshot();
}
SkAutoTUnref<SkLayerInfo> saveLayerData;
if (fBBH && fDoSaveLayerInfo) {
saveLayerData.reset(SkNEW(SkLayerInfo));
SkBBoxHierarchy* bbh = NULL; // we've already computed fBBH (received in constructor)
// TODO: update saveLayer info computation to reuse the already computed
// bounds in 'fBBH'
SkRecordComputeLayers(fBounds, *fRecord, pictList, bbh, saveLayerData);
}
size_t subPictureBytes = 0;
for (int i = 0; pictList && i < pictList->count(); i++) {
subPictureBytes += SkPictureUtils::ApproximateBytesUsed(pictList->begin()[i]);
}
// SkBigPicture will take ownership of a ref on both fRecord and fBBH.
// We're not willing to give up our ownership, so we must ref them for SkPicture.
return SkNEW_ARGS(SkBigPicture, (fBounds,
SkRef(fRecord.get()),
pictList,
SkSafeRef(fBBH.get()),
saveLayerData.detach(),
subPictureBytes));
}
SkImageFilter::SkImageFilter(SkImageFilter* input, const CropRect* cropRect)
: fInputCount(1),
fInputs(new SkImageFilter*[1]),
fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)) {
fInputs[0] = input;
SkSafeRef(fInputs[0]);
}
SkPictureImageFilter::SkPictureImageFilter(const SkPicture* picture)
: INHERITED(0, 0, NULL)
, fPicture(SkSafeRef(picture))
, fCropRect(picture ? picture->cullRect() : SkRect::MakeEmpty())
, fPictureResolution(kDeviceSpace_PictureResolution)
, fFilterQuality(kLow_SkFilterQuality) {
}
SkXfermodeImageFilter::SkXfermodeImageFilter(SkXfermode* mode,
SkImageFilter* background,
SkImageFilter* foreground,
const CropRect* cropRect)
: INHERITED(background, foreground, cropRect), fMode(mode) {
SkSafeRef(fMode);
}
SurfaceCollection::SurfaceCollection(BaseLayerAndroid* layer)
: m_compositedRoot(layer)
{
// layer must be non-null.
SkSafeRef(m_compositedRoot);
// calculate draw transforms and z values
SkRect visibleRect = SkRect::MakeLTRB(0, 0, 1, 1);
m_compositedRoot->updatePositionsRecursive(visibleRect);
// allocate surfaces for layers, merging where possible
ALOGV("new tree, allocating surfaces for tree %p", m_baseLayer);
LayerMergeState layerMergeState(&m_surfaces);
m_compositedRoot->assignSurfaces(&layerMergeState);
// set the layersurfaces' update count, to be drawn on painted tiles
unsigned int updateCount = TilesManager::instance()->incWebkitContentUpdates();
for (unsigned int i = 0; i < m_surfaces.size(); i++)
m_surfaces[i]->setUpdateCount(updateCount);
#ifdef DEBUG_COUNT
ClassTracker::instance()->increment("SurfaceCollection");
#endif
}
SkImageFilter::SkImageFilter(int inputCount, SkImageFilter** inputs)
: fInputCount(inputCount), fInputs(new SkImageFilter*[inputCount]) {
for (int i = 0; i < inputCount; ++i) {
fInputs[i] = inputs[i];
SkSafeRef(fInputs[i]);
}
}
ImageTexture* ImagesManager::setImage(SkBitmapRef* imgRef)
{
if (!imgRef)
return 0;
TRACE_METHOD();
SkBitmap* bitmap = &imgRef->bitmap();
ImageTexture* image = 0;
SkBitmap* img = 0;
unsigned crc = 0;
crc = ImageTexture::computeCRC(bitmap);
{
android::Mutex::Autolock lock(m_imagesLock);
if (m_images.contains(crc)) {
image = m_images.get(crc);
SkSafeRef(image);
return image;
}
}
// the image is not in the map, we add it
img = ImageTexture::convertBitmap(bitmap);
image = new ImageTexture(img, crc);
android::Mutex::Autolock lock(m_imagesLock);
m_images.set(crc, image);
return image;
}
void PlatformContextSkia::drawRect(SkRect rect)
{
SkPaint paint;
int fillcolorNotTransparent = m_state->m_fillColor & 0xFF000000;
if (fillcolorNotTransparent) {
setupPaintForFilling(&paint);
canvas()->drawRect(rect, paint);
}
if (m_state->m_strokeStyle != WebCore::NoStroke &&
(m_state->m_strokeColor & 0xFF000000)) {
// We do a fill of four rects to simulate the stroke of a border.
SkColor oldFillColor = m_state->m_fillColor;
// setFillColor() will set the shader to NULL, so save a ref to it now.
SkShader* oldFillShader = m_state->m_fillShader;
SkSafeRef(oldFillShader);
setFillColor(m_state->m_strokeColor);
paint.reset();
setupPaintForFilling(&paint);
SkRect topBorder = { rect.fLeft, rect.fTop, rect.fRight, rect.fTop + 1 };
canvas()->drawRect(topBorder, paint);
SkRect bottomBorder = { rect.fLeft, rect.fBottom - 1, rect.fRight, rect.fBottom };
canvas()->drawRect(bottomBorder, paint);
SkRect leftBorder = { rect.fLeft, rect.fTop + 1, rect.fLeft + 1, rect.fBottom - 1 };
canvas()->drawRect(leftBorder, paint);
SkRect rightBorder = { rect.fRight - 1, rect.fTop + 1, rect.fRight, rect.fBottom - 1 };
canvas()->drawRect(rightBorder, paint);
setFillColor(oldFillColor);
setFillShader(oldFillShader);
SkSafeUnref(oldFillShader);
}
}
SkPictureImageFilter::SkPictureImageFilter(SkPicture* picture)
: INHERITED(0, 0),
fPicture(picture),
fCropRect(SkRect::MakeWH(picture ? SkIntToScalar(picture->width()) : 0,
picture ? SkIntToScalar(picture->height()) : 0)) {
SkSafeRef(fPicture);
}
// draw for base tile - called on TextureGeneration thread
void TreeManager::drawCanvas(SkCanvas* canvas, bool drawLayers)
{
BaseLayerAndroid* paintingTree = 0;
m_paintSwapLock.lock();
if (m_paintingTree)
paintingTree = static_cast<BaseLayerAndroid*>(m_paintingTree);
else
paintingTree = static_cast<BaseLayerAndroid*>(m_drawingTree);
SkSafeRef(paintingTree);
m_paintSwapLock.unlock();
if (!paintingTree)
return;
paintingTree->drawCanvas(canvas);
if (drawLayers && paintingTree->countChildren()) {
// draw the layers onto the canvas as well
Layer* layers = paintingTree->getChild(0);
static_cast<LayerAndroid*>(layers)->drawCanvas(canvas);
}
SkSafeUnref(paintingTree);
}
SkXfermodeImageFilter::SkXfermodeImageFilter(SkXfermode* mode,
SkImageFilter* inputs[2],
const CropRect* cropRect,
uint32_t uniqueID)
: INHERITED(2, inputs, cropRect, uniqueID), fMode(mode) {
SkSafeRef(fMode);
}
void GrTestTarget::init(GrContext* ctx, GrDrawTarget* target, const GrGLInterface* gl) {
SkASSERT(!fContext);
fContext.reset(SkRef(ctx));
fDrawTarget.reset(SkRef(target));
fGLInterface.reset(SkSafeRef(gl));
}
SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode) {
fShaderA = sA; sA->ref();
fShaderB = sB; sB->ref();
// mode may be null
fMode = mode;
SkSafeRef(mode);
}
void Surface::addLayer(LayerAndroid* layer, const TransformationMatrix& transform)
{
m_layers.append(layer);
SkSafeRef(layer);
m_needsTexture |= layer->needsTexture();
m_hasText |= layer->hasText();
// add this layer's size to the surface's area
// TODO: handle scale/3d transform mapping
IntRect rect = enclosingIntRect(layer->fullContentAreaMapped());
if (layer->needsTexture()) {
if (m_fullContentArea.isEmpty()) {
m_drawTransform = transform;
m_drawTransform.translate3d(-rect.x(), -rect.y(), 0);
m_fullContentArea = rect;
} else
m_fullContentArea.unite(rect);
ALOGV("Surf %p adding LA %p, size " INT_RECT_FORMAT
" now fullContentArea " INT_RECT_FORMAT,
this, layer, INT_RECT_ARGS(rect), INT_RECT_ARGS(m_fullContentArea));
}
if (isBase())
m_background = static_cast<BaseLayerAndroid*>(layer)->getBackgroundColor();
}
void SkDeferredCanvas::DeferredDevice::contentsCleared() {
if (!fRecordingCanvas->isDrawingToLayer()) {
fFreshFrame = true;
// TODO: find a way to transfer the state stack and layers
// to the new recording canvas. For now, purging only works
// with an empty stack.
if (fRecordingCanvas->getSaveCount() == 0) {
// Save state that is trashed by the purge
SkDrawFilter* drawFilter = fRecordingCanvas->getDrawFilter();
SkSafeRef(drawFilter); // So that it survives the purge
SkMatrix matrix = fRecordingCanvas->getTotalMatrix();
SkRegion clipRegion = fRecordingCanvas->getTotalClip();
// beginRecording creates a new recording canvas and discards the
// old one, hence purging deferred draw ops.
fRecordingCanvas = fPicture.beginRecording(
fImmediateDevice->width(),
fImmediateDevice->height(), 0);
// Restore pre-purge state
if (!clipRegion.isEmpty()) {
fRecordingCanvas->clipRegion(clipRegion,
SkRegion::kReplace_Op);
}
if (!matrix.isIdentity()) {
fRecordingCanvas->setMatrix(matrix);
}
if (drawFilter) {
fRecordingCanvas->setDrawFilter(drawFilter)->unref();
}
}
}
}
GrTexture* SkPictureImageGenerator::onGenerateTexture(GrContext* ctx, SkImageUsageType usage,
const SkIRect* subset) {
const SkImageInfo& info = this->getInfo();
SkImageInfo surfaceInfo = subset ? info.makeWH(subset->width(), subset->height()) : info;
//
// TODO: respect the usage, by possibly creating a different (pow2) surface
//
SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx,
SkSurface::kYes_Budgeted,
surfaceInfo));
if (!surface.get()) {
return nullptr;
}
SkMatrix matrix = fMatrix;
if (subset) {
matrix.postTranslate(-subset->x(), -subset->y());
}
surface->getCanvas()->clear(0); // does NewRenderTarget promise to do this for us?
surface->getCanvas()->drawPicture(fPicture, &matrix, fPaint.getMaybeNull());
SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
if (!image.get()) {
return nullptr;
}
return SkSafeRef(image->getTexture());
}
SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
const char familyName[],
SkTypeface::Style style) {
load_system_fonts();
SkAutoMutexAcquire ac(gFamilyMutex);
// clip to legal style bits
style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
SkTypeface* tf = NULL;
if (NULL != familyFace) {
tf = find_typeface(familyFace, style);
} else if (NULL != familyName) {
// SkDebugf("======= familyName <%s>\n", familyName);
tf = find_typeface(familyName, style);
}
if (NULL == tf) {
tf = find_best_face(gDefaultFamily, style);
}
SkSafeRef(tf);
return tf;
}
void PlatformContextSkia::setFillShader(SkShader* fillShader)
{
if (fillShader != m_state->m_fillShader) {
SkSafeUnref(m_state->m_fillShader);
m_state->m_fillShader = fillShader;
SkSafeRef(m_state->m_fillShader);
}
}
void PlatformContextSkia::setStrokeShader(SkShader* strokeShader)
{
if (strokeShader != m_state->m_strokeShader) {
SkSafeUnref(m_state->m_strokeShader);
m_state->m_strokeShader = strokeShader;
SkSafeRef(m_state->m_strokeShader);
}
}
