void LayerAndroid::onDraw(SkCanvas* canvas, SkScalar opacity,
android::DrawExtra* extra, PaintStyle style)
{
if (m_haveClip) {
SkRect r;
r.set(0, 0, getSize().width(), getSize().height());
canvas->clipRect(r);
return;
}
// only continue drawing if layer is drawable
if (!m_content && !m_imageCRC)
return;
// we just have this save/restore for opacity...
SkAutoCanvasRestore restore(canvas, true);
int canvasOpacity = SkScalarRound(opacity * 255);
if (canvasOpacity < 255)
canvas->setDrawFilter(new OpacityDrawFilter(canvasOpacity));
if (m_imageCRC) {
ImageTexture* imageTexture = ImagesManager::instance()->retainImage(m_imageCRC);
m_dirtyRegion.setEmpty();
if (imageTexture) {
SkRect dest;
dest.set(0, 0, getSize().width(), getSize().height());
imageTexture->drawCanvas(canvas, dest);
}
ImagesManager::instance()->releaseImage(m_imageCRC);
}
contentDraw(canvas, style);
if (extra)
extra->draw(canvas, this);
}
void Matte::setTexture(string texture) {
ImageTexture* tex = new ImageTexture();
tex->setTextureFile(texture);
ambientBRDF->setTexture(tex);
tex = new ImageTexture();
tex->setTextureFile(texture);
diffuseBRDF->setTexture(tex);
}
/// M: function for release painter @{
void PaintTileOperation::releasePainter(TilePainter* painter)
{
if (painter && painter->type() == TilePainter::Image) {
ImageTexture* image = static_cast<ImageTexture*>(painter);
ImagesManager::instance()->releaseImage(image->imageCRC());
} else {
SkSafeUnref(painter);
}
}
void ImagesManager::releaseImage(unsigned imgCRC)
{
if (!imgCRC)
return;
android::Mutex::Autolock lock(m_imagesLock);
if (m_images.contains(imgCRC)) {
ImageTexture* image = m_images.get(imgCRC);
if (image->getRefCnt() == 1)
m_images.remove(imgCRC);
SkSafeUnref(image);
}
}
PaintTileOperation::~PaintTileOperation()
{
if (m_tile) {
m_tile->setRepaintPending(false);
m_tile = 0;
}
if (m_surface && m_surface->type() == SurfacePainter::ImageSurface) {
ImageTexture* image = static_cast<ImageTexture*>(m_surface);
ImagesManager::instance()->releaseImage(image->imageCRC());
} else {
SkSafeUnref(m_surface);
}
}
void TransferQueue::clearItemInTranferQueue(int index)
{
m_transferQueue[index].savedTilePtr = 0;
//SAMSUNG_CHANGES >> - MPSG100005914
//WAS: SkSafeUnref(m_transferQueue[index].savedTilePainter);
if (m_transferQueue[index].savedTilePainter && m_transferQueue[index].savedTilePainter->type() == TilePainter::Image) {
ImageTexture* image = static_cast<ImageTexture*>(m_transferQueue[index].savedTilePainter);
ImagesManager::instance()->releaseImage(image->imageCRC());
} else {
SkSafeUnref(m_transferQueue[index].savedTilePainter);
}
//SAMSUNG_CHANGES <<
m_transferQueue[index].savedTilePainter = 0;
m_transferQueue[index].status = emptyItem;
}
PaintTileOperation::~PaintTileOperation()
{
if (m_tile) {
m_tile->setRepaintPending(false);
m_tile = 0;
}
if (m_painter && m_painter->type() == TilePainter::Image) {
ImageTexture* image = static_cast<ImageTexture*>(m_painter);
ImagesManager::instance()->releaseImage(image->imageCRC());
} else {
SkSafeUnref(m_painter);
}
#ifdef DEBUG_COUNT
ClassTracker::instance()->decrement("PaintTileOperation");
#endif
}
bool LayerAndroid::drawGL(bool layerTilesDisabled)
{
if (!layerTilesDisabled && m_imageCRC) {
ImageTexture* imageTexture = ImagesManager::instance()->retainImage(m_imageCRC);
if (imageTexture)
imageTexture->drawGL(this, getOpacity());
ImagesManager::instance()->releaseImage(m_imageCRC);
}
state()->glExtras()->drawGL(this);
bool askScreenUpdate = false;
if (m_hasRunningAnimations)
askScreenUpdate = true;
return askScreenUpdate;
}
bool FixedBackgroundImageLayerAndroid::drawGL(bool layerTilesDisabled)
{
if (layerTilesDisabled)
return false;
if (!m_imageCRC)
return false;
ImageTexture* imageTexture = ImagesManager::instance()->retainImage(m_imageCRC);
if (!imageTexture) {
ImagesManager::instance()->releaseImage(m_imageCRC);
return false;
}
// We have a fixed background image, let's draw it
if (m_fixedPosition && m_fixedPosition->isBackgroundImagePositioning()) {
BackgroundImagePositioning* position =
static_cast<BackgroundImagePositioning*>(m_fixedPosition);
IntPoint repeatTimes(position->nbRepeatX(), position->nbRepeatY());
FloatPoint startPoint(position->offsetX() * getWidth(),
position->offsetY() * getHeight());
FloatPoint origin;
origin = drawTransform()->mapPoint(origin);
Color backgroundColor = Color((int)SkColorGetR(m_backgroundColor),
(int)SkColorGetG(m_backgroundColor),
(int)SkColorGetB(m_backgroundColor),
(int)SkColorGetA(m_backgroundColor));
bool drawSimpleQuadSuccess = drawSimpleQuad(imageTexture, position,
repeatTimes, startPoint,
origin, backgroundColor);
if (!drawSimpleQuadSuccess) {
drawRepeatedGrid(imageTexture, position, repeatTimes, startPoint,
origin, backgroundColor);
}
} else
imageTexture->drawGL(this, getOpacity());
ImagesManager::instance()->releaseImage(m_imageCRC);
return false;
}
void Material::setNormalMap(string texName) {
ImageTexture* tex = new ImageTexture();
tex->setTextureFile(texName);
normalMap = tex;
}
StillImage VideoEngine::CreateImage(ImageMemory *raw_image, const std::string &image_name, bool delete_on_exist) throw(Exception)
{
//the returning image
StillImage still_image;
//check if the raw_image pointer is valid
if(!raw_image)
{
throw Exception("raw_image is NULL, cannot create a StillImage", __FILE__, __LINE__, __FUNCTION__);
return still_image;
}
still_image.SetDimensions(raw_image->width, raw_image->height);
//Check to see if the image_name exists
if(TextureManager->_IsImageTextureRegistered(image_name))
{
//if we are allowed to delete, then we remove the texture
if(delete_on_exist)
{
ImageTexture* old = TextureManager->_GetImageTexture(image_name);
TextureManager->_UnregisterImageTexture(old);
if(old->RemoveReference())
delete old;
}
else
{
throw Exception("image already exists in texture manager", __FILE__, __LINE__, __FUNCTION__);
return still_image;
}
}
//create a new texture image. the next few steps are similar to CaptureImage, so in the future
// we may want to do a code-cleanup
ImageTexture *new_image = new ImageTexture(image_name, "<T>", raw_image->width, raw_image->height);
new_image->AddReference();
// Create a texture sheet of an appropriate size that can retain the capture
TexSheet *temp_sheet = TextureManager->_CreateTexSheet(RoundUpPow2(raw_image->width), RoundUpPow2(raw_image->height), VIDEO_TEXSHEET_ANY, false);
VariableTexSheet *sheet = dynamic_cast<VariableTexSheet *>(temp_sheet);
// Ensure that texture sheet creation succeeded, insert the texture image into the sheet, and copy the screen into the sheet
if(sheet == NULL) {
delete new_image;
throw Exception("could not create texture sheet to store still image", __FILE__, __LINE__, __FUNCTION__);
return still_image;
}
if(sheet->InsertTexture(new_image) == false)
{
TextureManager->_RemoveSheet(sheet);
delete new_image;
throw Exception("could not insert raw image into texture sheet", __FILE__, __LINE__, __FUNCTION__);
return still_image;
}
if(sheet->CopyRect(0, 0, *raw_image) == false)
{
TextureManager->_RemoveSheet(sheet);
delete new_image;
throw Exception("call to TexSheet::CopyRect() failed", __FILE__, __LINE__, __FUNCTION__);
still_image.Clear();
return still_image;
}
// Store the image element to the saved image (with a flipped y axis)
still_image._image_texture = new_image;
still_image._texture = new_image;
return still_image;
}
void serializeLayer(LayerAndroid* layer, SkWStream* stream)
{
if (!layer) {
ALOGV("NULL layer!");
stream->write8(LTNone);
return;
}
if (layer->isMedia() || layer->isVideo()) {
ALOGV("Layer isn't supported for serialization: isMedia: %s, isVideo: %s",
layer->isMedia() ? "true" : "false",
layer->isVideo() ? "true" : "false");
stream->write8(LTNone);
return;
}
LayerTypes type = LTLayerAndroid;
if (layer->contentIsScrollable())
type = LTScrollableLayerAndroid;
stream->write8(type);
// Start with Layer fields
stream->writeBool(layer->shouldInheritFromRootTransform());
stream->writeScalar(layer->getOpacity());
stream->writeScalar(layer->getSize().width());
stream->writeScalar(layer->getSize().height());
stream->writeScalar(layer->getPosition().x());
stream->writeScalar(layer->getPosition().y());
stream->writeScalar(layer->getAnchorPoint().x());
stream->writeScalar(layer->getAnchorPoint().y());
writeMatrix(stream, layer->getMatrix());
writeMatrix(stream, layer->getChildrenMatrix());
// Next up, LayerAndroid fields
stream->writeBool(layer->m_haveClip);
stream->writeBool(layer->isPositionFixed());
stream->writeBool(layer->m_backgroundColorSet);
stream->writeBool(layer->isIFrame());
// With the current LayerAndroid hierarchy, LayerAndroid doesn't have
// those fields anymore. Let's keep the current serialization format for
// now and output blank fields... not great, but probably better than
// dealing with multiple versions.
if (layer->fixedPosition()) {
FixedPositioning* fixedPosition = layer->fixedPosition();
writeSkLength(stream, fixedPosition->m_fixedLeft);
writeSkLength(stream, fixedPosition->m_fixedTop);
writeSkLength(stream, fixedPosition->m_fixedRight);
writeSkLength(stream, fixedPosition->m_fixedBottom);
writeSkLength(stream, fixedPosition->m_fixedMarginLeft);
writeSkLength(stream, fixedPosition->m_fixedMarginTop);
writeSkLength(stream, fixedPosition->m_fixedMarginRight);
writeSkLength(stream, fixedPosition->m_fixedMarginBottom);
writeSkRect(stream, fixedPosition->m_fixedRect);
stream->write32(fixedPosition->m_renderLayerPos.x());
stream->write32(fixedPosition->m_renderLayerPos.y());
} else {
SkLength length;
SkRect rect;
writeSkLength(stream, length); // fixedLeft
writeSkLength(stream, length); // fixedTop
writeSkLength(stream, length); // fixedRight
writeSkLength(stream, length); // fixedBottom
writeSkLength(stream, length); // fixedMarginLeft
writeSkLength(stream, length); // fixedMarginTop
writeSkLength(stream, length); // fixedMarginRight
writeSkLength(stream, length); // fixedMarginBottom
writeSkRect(stream, rect); // fixedRect
stream->write32(0); // renderLayerPos.x()
stream->write32(0); // renderLayerPos.y()
}
stream->writeBool(layer->m_backfaceVisibility);
stream->writeBool(layer->m_visible);
stream->write32(layer->m_backgroundColor);
stream->writeBool(layer->m_preserves3D);
stream->writeScalar(layer->m_anchorPointZ);
stream->writeScalar(layer->m_drawOpacity);
bool hasContentsImage = layer->m_imageCRC != 0;
stream->writeBool(hasContentsImage);
if (hasContentsImage) {
SkFlattenableWriteBuffer buffer(1024);
buffer.setFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag);
ImageTexture* imagetexture =
ImagesManager::instance()->retainImage(layer->m_imageCRC);
if (imagetexture && imagetexture->bitmap())
imagetexture->bitmap()->flatten(buffer);
ImagesManager::instance()->releaseImage(layer->m_imageCRC);
stream->write32(buffer.size());
buffer.writeToStream(stream);
}
bool hasRecordingPicture = layer->m_content != 0 && !layer->m_content->isEmpty();
stream->writeBool(hasRecordingPicture);
if (hasRecordingPicture)
layer->m_content->serialize(stream);
// TODO: support m_animations (maybe?)
stream->write32(0); // placeholder for m_animations.size();
writeTransformationMatrix(stream, layer->m_transform);
writeTransformationMatrix(stream, layer->m_childrenTransform);
if (type == LTScrollableLayerAndroid) {
ScrollableLayerAndroid* scrollableLayer =
static_cast<ScrollableLayerAndroid*>(layer);
stream->writeScalar(scrollableLayer->m_scrollLimits.fLeft);
stream->writeScalar(scrollableLayer->m_scrollLimits.fTop);
stream->writeScalar(scrollableLayer->m_scrollLimits.width());
stream->writeScalar(scrollableLayer->m_scrollLimits.height());
}
int childCount = layer->countChildren();
stream->write32(childCount);
for (int i = 0; i < childCount; i++)
serializeLayer(layer->getChild(i), stream);
}
void LayerAndroid::setContentsImage(SkBitmapRef* img)
{
ImageTexture* image = ImagesManager::instance()->setImage(img);
ImagesManager::instance()->releaseImage(m_imageCRC);
m_imageCRC = image ? image->imageCRC() : 0;
}
void serializeLayer(LayerAndroid* layer, SkWStream* stream)
{
if (!layer) {
XLOG("NULL layer!");
stream->write8(LTNone);
return;
}
if (layer->isMedia() || layer->isVideo()) {
XLOG("Layer isn't supported for serialization: isMedia: %s, isVideo: %s",
layer->isMedia() ? "true" : "false",
layer->isVideo() ? "true" : "false");
stream->write8(LTNone);
return;
}
LayerTypes type = layer->contentIsScrollable()
? LTScrollableLayerAndroid
: LTLayerAndroid;
stream->write8(type);
// Start with Layer fields
stream->writeBool(layer->shouldInheritFromRootTransform());
stream->writeScalar(layer->getOpacity());
stream->writeScalar(layer->getSize().width());
stream->writeScalar(layer->getSize().height());
stream->writeScalar(layer->getPosition().x());
stream->writeScalar(layer->getPosition().y());
stream->writeScalar(layer->getAnchorPoint().x());
stream->writeScalar(layer->getAnchorPoint().y());
writeMatrix(stream, layer->getMatrix());
writeMatrix(stream, layer->getChildrenMatrix());
// Next up, LayerAndroid fields
stream->writeBool(layer->m_haveClip);
stream->writeBool(layer->m_isFixed);
stream->writeBool(layer->m_backgroundColorSet);
stream->writeBool(layer->m_isIframe);
writeSkLength(stream, layer->m_fixedLeft);
writeSkLength(stream, layer->m_fixedTop);
writeSkLength(stream, layer->m_fixedRight);
writeSkLength(stream, layer->m_fixedBottom);
writeSkLength(stream, layer->m_fixedMarginLeft);
writeSkLength(stream, layer->m_fixedMarginTop);
writeSkLength(stream, layer->m_fixedMarginRight);
writeSkLength(stream, layer->m_fixedMarginBottom);
writeSkRect(stream, layer->m_fixedRect);
stream->write32(layer->m_renderLayerPos.x());
stream->write32(layer->m_renderLayerPos.y());
stream->writeBool(layer->m_backfaceVisibility);
stream->writeBool(layer->m_visible);
stream->write32(layer->m_backgroundColor);
stream->writeBool(layer->m_preserves3D);
stream->writeScalar(layer->m_anchorPointZ);
stream->writeScalar(layer->m_drawOpacity);
bool hasContentsImage = layer->m_imageCRC != 0;
stream->writeBool(hasContentsImage);
if (hasContentsImage) {
SkFlattenableWriteBuffer buffer(1024);
buffer.setFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag);
ImageTexture* imagetexture =
ImagesManager::instance()->retainImage(layer->m_imageCRC);
if (imagetexture && imagetexture->bitmap())
imagetexture->bitmap()->flatten(buffer);
ImagesManager::instance()->releaseImage(layer->m_imageCRC);
stream->write32(buffer.size());
buffer.writeToStream(stream);
}
bool hasRecordingPicture = layer->m_recordingPicture != 0;
stream->writeBool(hasRecordingPicture);
if (hasRecordingPicture)
layer->m_recordingPicture->serialize(stream);
// TODO: support m_animations (maybe?)
stream->write32(0); // placeholder for m_animations.size();
writeTransformationMatrix(stream, layer->m_transform);
writeTransformationMatrix(stream, layer->m_childrenTransform);
if (type == LTScrollableLayerAndroid) {
ScrollableLayerAndroid* scrollableLayer =
static_cast<ScrollableLayerAndroid*>(layer);
stream->writeScalar(scrollableLayer->m_scrollLimits.fLeft);
stream->writeScalar(scrollableLayer->m_scrollLimits.fTop);
stream->writeScalar(scrollableLayer->m_scrollLimits.width());
stream->writeScalar(scrollableLayer->m_scrollLimits.height());
}
int childCount = layer->countChildren();
stream->write32(childCount);
for (int i = 0; i < childCount; i++)
serializeLayer(layer->getChild(i), stream);
}
