Skip to content

Commit

Permalink
Bug 717872 - Remove the imgFrame* helpers from FrameBlender now that …
Browse files Browse the repository at this point in the history 
…we always have raw data pointers. r=seth
  • Loading branch information
@joedrew
joedrew committed Jun 28, 2013
1 parent 899a1fa commit 05751e2
Show file tree
Hide file tree
Showing 3 changed files with 48 additions and 74 deletions.
115 changes: 45 additions & 70 deletions image/src/FrameBlender.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -277,28 +277,36 @@ FrameBlender::DoBlend(nsIntRect* aDirtyRect,
if (needToBlankComposite) {
// If we just created the composite, it could have anything in its
// buffer. Clear whole frame
ClearFrame(mAnim->compositingFrame);
ClearFrame(mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect());
} else {
// Only blank out previous frame area (both color & Mask/Alpha)
ClearFrame(mAnim->compositingFrame, prevFrameRect);
ClearFrame(mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect(),
prevFrameRect);
}
break;

case FrameBlender::kDisposeClearAll:
ClearFrame(mAnim->compositingFrame);
ClearFrame(mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect());
break;

case FrameBlender::kDisposeRestorePrevious:
// It would be better to copy only the area changed back to
// compositingFrame.
if (mAnim->compositingPrevFrame) {
CopyFrameImage(mAnim->compositingPrevFrame, mAnim->compositingFrame);
CopyFrameImage(mAnim->compositingPrevFrame.GetFrameData(),
mAnim->compositingPrevFrame.GetFrame()->GetRect(),
mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect());

// destroy only if we don't need it for this frame's disposal
if (nextFrameDisposalMethod != FrameBlender::kDisposeRestorePrevious)
mAnim->compositingPrevFrame.SetFrame(nullptr);
} else {
ClearFrame(mAnim->compositingFrame);
ClearFrame(mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect());
}
break;

Expand All @@ -312,22 +320,32 @@ FrameBlender::DoBlend(nsIntRect* aDirtyRect,
if (mAnim->lastCompositedFrameIndex != int32_t(aNextFrameIndex - 1)) {
if (isFullPrevFrame && !prevFrame->GetIsPaletted()) {
// Just copy the bits
CopyFrameImage(prevFrame, mAnim->compositingFrame);
CopyFrameImage(prevFrame.GetFrameData(),
prevFrame.GetFrame()->GetRect(),
mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect());
} else {
if (needToBlankComposite) {
// Only blank composite when prev is transparent or not full.
if (prevFrame->GetHasAlpha() || !isFullPrevFrame) {
ClearFrame(mAnim->compositingFrame);
ClearFrame(mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect());
}
}
DrawFrameTo(prevFrame, mAnim->compositingFrame, prevFrameRect);
DrawFrameTo(prevFrame.GetFrameData(), prevFrameRect,
prevFrame.GetFrame()->PaletteDataLength(),
prevFrame.GetFrame()->GetHasAlpha(),
mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect(),
FrameBlendMethod(prevFrame.GetFrame()->GetBlendMethod()));
}
}
}
} else if (needToBlankComposite) {
// If we just created the composite, it could have anything in it's
// buffers. Clear them
ClearFrame(mAnim->compositingFrame);
ClearFrame(mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect());
}

// Check if the frame we are composing wants the previous image restored afer
Expand All @@ -350,11 +368,19 @@ FrameBlender::DoBlend(nsIntRect* aDirtyRect,
mAnim->compositingPrevFrame.LockAndGetData();
}

CopyFrameImage(mAnim->compositingFrame, mAnim->compositingPrevFrame);
CopyFrameImage(mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect(),
mAnim->compositingPrevFrame.GetFrameData(),
mAnim->compositingPrevFrame.GetFrame()->GetRect());
}

// blit next frame into it's correct spot
DrawFrameTo(nextFrame, mAnim->compositingFrame, nextFrameRect);
DrawFrameTo(nextFrame.GetFrameData(), nextFrameRect,
nextFrame.GetFrame()->PaletteDataLength(),
nextFrame.GetFrame()->GetHasAlpha(),
mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect(),
FrameBlendMethod(nextFrame.GetFrame()->GetBlendMethod()));

// Set timeout of CompositeFrame to timeout of frame we just composed
// Bug 177948
Expand All @@ -379,7 +405,10 @@ FrameBlender::DoBlend(nsIntRect* aDirtyRect,
// continuously re-build it
// Then set the previous frame's disposal to CLEAR_ALL so we just draw the
// frame next time around
if (CopyFrameImage(mAnim->compositingFrame, nextFrame)) {
if (CopyFrameImage(mAnim->compositingFrame.GetFrameData(),
mAnim->compositingFrame.GetFrame()->GetRect(),
nextFrame.GetFrameData(),
nextFrame.GetFrame()->GetRect())) {
prevFrame->SetFrameDisposalMethod(FrameBlender::kDisposeClearAll);
mAnim->compositingFrame.SetFrame(nullptr);
mAnim->lastCompositedFrameIndex = -1;
Expand All @@ -403,15 +432,6 @@ FrameBlender::ClearFrame(uint8_t* aFrameData, const nsIntRect& aFrameRect)
memset(aFrameData, 0, aFrameRect.width * aFrameRect.height * 4);
}

void
FrameBlender::ClearFrame(imgFrame* aFrame)
{
AutoFrameLocker lock(aFrame);
if (lock.Succeeded()) {
ClearFrame(aFrame->GetImageData(), aFrame->GetRect());
}
}

//******************************************************************************
void
FrameBlender::ClearFrame(uint8_t* aFrameData, const nsIntRect& aFrameRect, const nsIntRect& aRectToClear)
Expand All @@ -432,21 +452,12 @@ FrameBlender::ClearFrame(uint8_t* aFrameData, const nsIntRect& aFrameRect, const
}
}

void
FrameBlender::ClearFrame(imgFrame* aFrame, const nsIntRect& aRectToClear)
{
AutoFrameLocker lock(aFrame);
if (lock.Succeeded()) {
ClearFrame(aFrame->GetImageData(), aFrame->GetRect(), aRectToClear);
}
}

//******************************************************************************
// Whether we succeed or fail will not cause a crash, and there's not much
// we can do about a failure, so there we don't return a nsresult
bool
FrameBlender::CopyFrameImage(uint8_t *aDataSrc, const nsIntRect& aRectSrc,
uint8_t *aDataDest, const nsIntRect& aRectDest)
uint8_t *aDataDest, const nsIntRect& aRectDest)
{
uint32_t dataLengthSrc = aRectSrc.width * aRectSrc.height * 4;
uint32_t dataLengthDest = aRectDest.width * aRectDest.height * 4;
Expand All @@ -460,24 +471,11 @@ FrameBlender::CopyFrameImage(uint8_t *aDataSrc, const nsIntRect& aRectSrc,
return true;
}

bool
FrameBlender::CopyFrameImage(imgFrame* aSrc, imgFrame* aDst)
{
AutoFrameLocker srclock(aSrc);
AutoFrameLocker dstlock(aDst);
if (!srclock.Succeeded() || !dstlock.Succeeded()) {
return false;
}

return CopyFrameImage(aSrc->GetImageData(), aSrc->GetRect(),
aDst->GetImageData(), aDst->GetRect());
}

nsresult
FrameBlender::DrawFrameTo(uint8_t *aSrcData, const nsIntRect& aSrcRect,
uint32_t aSrcPaletteLength, bool aSrcHasAlpha,
uint8_t *aDstPixels, const nsIntRect& aDstRect,
FrameBlender::FrameBlendMethod aBlendMethod)
uint32_t aSrcPaletteLength, bool aSrcHasAlpha,
uint8_t *aDstPixels, const nsIntRect& aDstRect,
FrameBlender::FrameBlendMethod aBlendMethod)
{
NS_ENSURE_ARG_POINTER(aSrcData);
NS_ENSURE_ARG_POINTER(aDstPixels);
Expand Down Expand Up @@ -563,29 +561,6 @@ FrameBlender::DrawFrameTo(uint8_t *aSrcData, const nsIntRect& aSrcRect,
return NS_OK;
}

nsresult
FrameBlender::DrawFrameTo(imgFrame* aSrc, imgFrame* aDst, const nsIntRect& aSrcRect)
{
AutoFrameLocker srclock(aSrc);
AutoFrameLocker dstlock(aDst);
if (!srclock.Succeeded() || !dstlock.Succeeded()) {
return NS_ERROR_FAILURE;
}

if (aSrc->GetIsPaletted()) {
return DrawFrameTo(reinterpret_cast<uint8_t*>(aSrc->GetPaletteData()),
aSrcRect, aSrc->PaletteDataLength(),
aSrc->GetHasAlpha(), aDst->GetImageData(),
aDst->GetRect(),
FrameBlendMethod(aSrc->GetBlendMethod()));
}

return DrawFrameTo(aSrc->GetImageData(), aSrcRect,
0, aSrc->GetHasAlpha(),
aDst->GetImageData(), aDst->GetRect(),
FrameBlendMethod(aSrc->GetBlendMethod()));
}

void
FrameBlender::Discard()
{
Expand Down
4 changes: 0 additions & 4 deletions image/src/FrameBlender.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -245,16 +245,13 @@ class FrameBlender
* @note Does also clears the transparancy mask
*/
static void ClearFrame(uint8_t* aFrameData, const nsIntRect& aFrameRect);
static void ClearFrame(imgFrame* aFrame);

//! @overload
static void ClearFrame(uint8_t* aFrameData, const nsIntRect& aFrameRect, const nsIntRect &aRectToClear);
static void ClearFrame(imgFrame* aFrame, const nsIntRect& aRectToClear);

//! Copy one frames's image and mask into another
static bool CopyFrameImage(uint8_t *aDataSrc, const nsIntRect& aRectSrc,
uint8_t *aDataDest, const nsIntRect& aRectDest);
static bool CopyFrameImage(imgFrame* aSrc, imgFrame* aDst);

/**
* Draws one frames's image to into another, at the position specified by
Expand All @@ -275,7 +272,6 @@ class FrameBlender
uint32_t aSrcPaletteLength, bool aSrcHasAlpha,
uint8_t *aDstPixels, const nsIntRect& aDstRect,
FrameBlendMethod aBlendMethod);
static nsresult DrawFrameTo(imgFrame* aSrc, imgFrame* aDst, const nsIntRect& aSrcRect);

private: // data
//! All the frames of the image
Expand Down
3 changes: 3 additions & 0 deletions image/src/imgFrame.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -111,6 +111,9 @@ class imgFrame

uint8_t GetPaletteDepth() const { return mPaletteDepth; }
uint32_t PaletteDataLength() const {
if (!mPaletteDepth)
return 0;

return ((1 << mPaletteDepth) * sizeof(uint32_t));
}

Expand Down

0 comments on commit 05751e2

Please sign in to comment.