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); } }