/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "gfxGlyphExtents.h"

#include "gfxTextRun.h"

using namespace mozilla;

#ifdef DEBUG_roc

#define DEBUG_TEXT_RUN_STORAGE_METRICS

#endif

#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS

extern uint32_t gTextRunStorageHighWaterMark;

extern uint32_t gTextRunStorage;

extern uint32_t gFontCount;

extern uint32_t gGlyphExtentsCount;

extern uint32_t gGlyphExtentsWidthsTotalSize;

extern uint32_t gGlyphExtentsSetupEagerSimple;

extern uint32_t gGlyphExtentsSetupEagerTight;

extern uint32_t gGlyphExtentsSetupLazyTight;

extern uint32_t gGlyphExtentsSetupFallBackToTight;

#endif

gfxGlyphExtents::~gfxGlyphExtents()

{

#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS

    gGlyphExtentsWidthsTotalSize +=

        mContainedGlyphWidths.SizeOfExcludingThis(&FontCacheMallocSizeOf);

    gGlyphExtentsCount++;

#endif

    MOZ_COUNT_DTOR(gfxGlyphExtents);

}

bool

gfxGlyphExtents::GetTightGlyphExtentsAppUnits(gfxFont* aFont,

    DrawTarget* aDrawTarget, uint32_t aGlyphID, gfxRect* aExtents)

{

    HashEntry *entry = mTightGlyphExtents.GetEntry(aGlyphID);

    if (!entry) {

        // Some functions higher up in the call chain deliberately pass in a

        // nullptr DrawTarget, e.g. GetBaselinePosition() passes nullptr to

        // gfxTextRun::MeasureText() and that nullptr reaches here.

        if (!aDrawTarget) {

            NS_WARNING("Could not get glyph extents (no aDrawTarget)");

            return false;

        }

        if (aFont->SetupCairoFont(aDrawTarget)) {

#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS

            ++gGlyphExtentsSetupLazyTight;

#endif

            aFont->SetupGlyphExtents(aDrawTarget, aGlyphID, true, this);

            entry = mTightGlyphExtents.GetEntry(aGlyphID);

        }

        if (!entry) {

            NS_WARNING("Could not get glyph extents");

            return false;

        }

    }

    *aExtents = gfxRect(entry->x, entry->y, entry->width, entry->height);

    return true;

}

gfxGlyphExtents::GlyphWidths::~GlyphWidths()

{

    uint32_t i, count = mBlocks.Length();

    for (i = 0; i < count; ++i) {

        uintptr_t bits = mBlocks[i];

        if (bits && !(bits & 0x1)) {

            delete[] reinterpret_cast<uint16_t *>(bits);

        }

    }

}

uint32_t

gfxGlyphExtents::GlyphWidths::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const

{

    uint32_t i;

    uint32_t size = mBlocks.ShallowSizeOfExcludingThis(aMallocSizeOf);

    for (i = 0; i < mBlocks.Length(); ++i) {

        uintptr_t bits = mBlocks[i];

        if (bits && !(bits & 0x1)) {

            size += aMallocSizeOf(reinterpret_cast<void*>(bits));

        }

    }

    return size;

}

void

gfxGlyphExtents::GlyphWidths::Set(uint32_t aGlyphID, uint16_t aWidth)

{

    uint32_t block = aGlyphID >> BLOCK_SIZE_BITS;

    uint32_t len = mBlocks.Length();

    if (block >= len) {

        uintptr_t *elems = mBlocks.AppendElements(block + 1 - len);

        if (!elems)

            return;

        memset(elems, 0, sizeof(uintptr_t)*(block + 1 - len));

    }

    uintptr_t bits = mBlocks[block];

    uint32_t glyphOffset = aGlyphID & (BLOCK_SIZE - 1);

    if (!bits) {

        mBlocks[block] = MakeSingle(glyphOffset, aWidth);

        return;

    }

    uint16_t *newBlock;

    if (bits & 0x1) {

        // Expand the block to a real block. We could avoid this by checking

        // glyphOffset == GetGlyphOffset(bits), but that never happens so don't bother

        newBlock = new uint16_t[BLOCK_SIZE];

        if (!newBlock)

            return;

        uint32_t i;

        for (i = 0; i < BLOCK_SIZE; ++i) {

            newBlock[i] = INVALID_WIDTH;

        }

        newBlock[GetGlyphOffset(bits)] = GetWidth(bits);

        mBlocks[block] = reinterpret_cast<uintptr_t>(newBlock);

    } else {

        newBlock = reinterpret_cast<uint16_t *>(bits);

    }

    newBlock[glyphOffset] = aWidth;

}

void

gfxGlyphExtents::SetTightGlyphExtents(uint32_t aGlyphID, const gfxRect& aExtentsAppUnits)

{

    HashEntry *entry = mTightGlyphExtents.PutEntry(aGlyphID);

    if (!entry)

        return;

    entry->x = aExtentsAppUnits.X();

    entry->y = aExtentsAppUnits.Y();

    entry->width = aExtentsAppUnits.Width();

    entry->height = aExtentsAppUnits.Height();

}

size_t

gfxGlyphExtents::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const

{

    return mContainedGlyphWidths.SizeOfExcludingThis(aMallocSizeOf) +

        mTightGlyphExtents.ShallowSizeOfExcludingThis(aMallocSizeOf);

}

size_t

gfxGlyphExtents::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const

{

    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);

}