/* -*- Mode: C++; tab-width: 4; 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 "gfxGraphiteShaper.h"

#include "nsString.h"

#include "gfxContext.h"

#include "gfxFontConstants.h"

#include "gfxTextRun.h"

#include "graphite2/Font.h"

#include "graphite2/Segment.h"

#include "harfbuzz/hb.h"

#define FloatToFixed(f) (65536 * (f))

#define FixedToFloat(f) ((f) * (1.0 / 65536.0))

// Right shifts of negative (signed) integers are undefined, as are overflows

// when converting unsigned to negative signed integers.

// (If speed were an issue we could make some 2's complement assumptions.)

#define FixedToIntRound(f) ((f) > 0 ?  ((32768 + (f)) >> 16) \

                                    : -((32767 - (f)) >> 16))

using namespace mozilla; // for AutoSwap_* types

/*

 * Creation and destruction; on deletion, release any font tables we're holding

 */

gfxGraphiteShaper::gfxGraphiteShaper(gfxFont *aFont)

    : gfxFontShaper(aFont),

      mGrFace(mFont->GetFontEntry()->GetGrFace()),

      mGrFont(nullptr), mFallbackToSmallCaps(false)

{

    mCallbackData.mDrawTarget = nullptr;

    mCallbackData.mFont = aFont;

}

gfxGraphiteShaper::~gfxGraphiteShaper()

{

    if (mGrFont) {

        gr_font_destroy(mGrFont);

    }

    mFont->GetFontEntry()->ReleaseGrFace(mGrFace);

}

/*static*/ float

gfxGraphiteShaper::GrGetAdvance(const void* appFontHandle, uint16_t glyphid)

{

    const CallbackData *cb =

        static_cast<const CallbackData*>(appFontHandle);

    return FixedToFloat(cb->mFont->GetGlyphWidth(*cb->mDrawTarget, glyphid));

}

static inline uint32_t

MakeGraphiteLangTag(uint32_t aTag)

{

    uint32_t grLangTag = aTag;

    // replace trailing space-padding with NULs for graphite

    uint32_t mask = 0x000000FF;

    while ((grLangTag & mask) == ' ') {

        grLangTag &= ~mask;

        mask <<= 8;

    }

    return grLangTag;

}

struct GrFontFeatures {

    gr_face        *mFace;

    gr_feature_val *mFeatures;

};

static void

AddFeature(const uint32_t& aTag, uint32_t& aValue, void *aUserArg)

{

    GrFontFeatures *f = static_cast<GrFontFeatures*>(aUserArg);

    const gr_feature_ref* fref = gr_face_find_fref(f->mFace, aTag);

    if (fref) {

        gr_fref_set_feature_value(fref, aValue, f->mFeatures);

    }

}

bool

gfxGraphiteShaper::ShapeText(DrawTarget      *aDrawTarget,

                             const char16_t *aText,

                             uint32_t         aOffset,

                             uint32_t         aLength,

                             Script           aScript,

                             bool             aVertical,

                             RoundingFlags    aRounding,

                             gfxShapedText   *aShapedText)

{

    // some font back-ends require this in order to get proper hinted metrics

    if (!mFont->SetupCairoFont(aDrawTarget)) {

        return false;

    }

    mCallbackData.mDrawTarget = aDrawTarget;

    const gfxFontStyle *style = mFont->GetStyle();

    if (!mGrFont) {

        if (!mGrFace) {

            return false;

        }

        if (mFont->ProvidesGlyphWidths()) {

            gr_font_ops ops = {

                sizeof(gr_font_ops),

                &GrGetAdvance,

                nullptr // vertical text not yet implemented

            };

            mGrFont = gr_make_font_with_ops(mFont->GetAdjustedSize(),

                                            &mCallbackData, &ops, mGrFace);

        } else {

            mGrFont = gr_make_font(mFont->GetAdjustedSize(), mGrFace);

        }

        if (!mGrFont) {

            return false;

        }

        // determine whether petite-caps falls back to small-caps

        if (style->variantCaps != NS_FONT_VARIANT_CAPS_NORMAL) {

            switch (style->variantCaps) {

                case NS_FONT_VARIANT_CAPS_ALLPETITE:

                case NS_FONT_VARIANT_CAPS_PETITECAPS:

                    bool synLower, synUpper;

                    mFont->SupportsVariantCaps(aScript, style->variantCaps,

                                               mFallbackToSmallCaps, synLower,

                                               synUpper);

                    break;

                default:

                    break;

            }

        }

    }

    gfxFontEntry *entry = mFont->GetFontEntry();

    uint32_t grLang = 0;

    if (style->languageOverride) {

        grLang = MakeGraphiteLangTag(style->languageOverride);

    } else if (entry->mLanguageOverride) {

        grLang = MakeGraphiteLangTag(entry->mLanguageOverride);

    } else if (style->explicitLanguage) {

        nsAutoCString langString;

        style->language->ToUTF8String(langString);

        grLang = GetGraphiteTagForLang(langString);

    }

    gr_feature_val *grFeatures = gr_face_featureval_for_lang(mGrFace, grLang);

    // insert any merged features into Graphite feature list

    GrFontFeatures f = {mGrFace, grFeatures};

    MergeFontFeatures(style,

                      mFont->GetFontEntry()->mFeatureSettings,

                      aShapedText->DisableLigatures(),

                      mFont->GetFontEntry()->FamilyName(),

                      mFallbackToSmallCaps,

                      AddFeature,

                      &f);

    // Graphite shaping doesn't map U+00a0 (nbsp) to space if it is missing

    // from the font, so check for that possibility. (Most fonts double-map

    // the space glyph to both 0x20 and 0xA0, so this won't often be needed;

    // so we don't copy the text until we know it's required.)

    nsAutoString transformed;

    const char16_t NO_BREAK_SPACE = 0x00a0;

    if (!entry->HasCharacter(NO_BREAK_SPACE)) {

        nsDependentSubstring src(aText, aLength);

        if (src.FindChar(NO_BREAK_SPACE) != kNotFound) {

            transformed = src;

            transformed.ReplaceChar(NO_BREAK_SPACE, ' ');

            aText = transformed.BeginReading();

        }

    }

    size_t numChars = gr_count_unicode_characters(gr_utf16,

                                                  aText, aText + aLength,

                                                  nullptr);

    gr_bidirtl grBidi = gr_bidirtl(aShapedText->IsRightToLeft()

                                   ? (gr_rtl | gr_nobidi) : gr_nobidi);

    gr_segment *seg = gr_make_seg(mGrFont, mGrFace, 0, grFeatures,

                                  gr_utf16, aText, numChars, grBidi);

    gr_featureval_destroy(grFeatures);

    if (!seg) {

        return false;

    }

    nsresult rv = SetGlyphsFromSegment(aShapedText, aOffset, aLength,

                                       aText, seg, aRounding);

    gr_seg_destroy(seg);

    return NS_SUCCEEDED(rv);

}

#define SMALL_GLYPH_RUN 256 // avoid heap allocation of per-glyph data arrays

                            // for short (typical) runs up to this length

struct Cluster {

    uint32_t baseChar; // in UTF16 code units, not Unicode character indices

    uint32_t baseGlyph;

    uint32_t nChars; // UTF16 code units

    uint32_t nGlyphs;

    Cluster() : baseChar(0), baseGlyph(0), nChars(0), nGlyphs(0) { }

};

nsresult

gfxGraphiteShaper::SetGlyphsFromSegment(gfxShapedText   *aShapedText,

                                        uint32_t         aOffset,

                                        uint32_t         aLength,

                                        const char16_t *aText,

                                        gr_segment      *aSegment,

                                        RoundingFlags    aRounding)

{

    typedef gfxShapedText::CompressedGlyph CompressedGlyph;

    int32_t dev2appUnits = aShapedText->GetAppUnitsPerDevUnit();

    bool rtl = aShapedText->IsRightToLeft();

    uint32_t glyphCount = gr_seg_n_slots(aSegment);

    // identify clusters; graphite may have reordered/expanded/ligated glyphs.

    AutoTArray<Cluster,SMALL_GLYPH_RUN> clusters;

    AutoTArray<uint16_t,SMALL_GLYPH_RUN> gids;

    AutoTArray<float,SMALL_GLYPH_RUN> xLocs;

    AutoTArray<float,SMALL_GLYPH_RUN> yLocs;

    if (!clusters.SetLength(aLength, fallible) ||

        !gids.SetLength(glyphCount, fallible) ||

        !xLocs.SetLength(glyphCount, fallible) ||

        !yLocs.SetLength(glyphCount, fallible))

    {

        return NS_ERROR_OUT_OF_MEMORY;

    }

    // walk through the glyph slots and check which original character

    // each is associated with

    uint32_t gIndex = 0; // glyph slot index

    uint32_t cIndex = 0; // current cluster index

    for (const gr_slot *slot = gr_seg_first_slot(aSegment);

         slot != nullptr;

         slot = gr_slot_next_in_segment(slot), gIndex++)

    {

        uint32_t before =

            gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_before(slot)));

        uint32_t after =

            gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_after(slot)));

        gids[gIndex] = gr_slot_gid(slot);

        xLocs[gIndex] = gr_slot_origin_X(slot);

        yLocs[gIndex] = gr_slot_origin_Y(slot);

        // if this glyph has a "before" character index that precedes the

        // current cluster's char index, we need to merge preceding

        // clusters until it gets included

        while (before < clusters[cIndex].baseChar && cIndex > 0) {

            clusters[cIndex-1].nChars += clusters[cIndex].nChars;

            clusters[cIndex-1].nGlyphs += clusters[cIndex].nGlyphs;

            --cIndex;

        }

        // if there's a gap between the current cluster's base character and

        // this glyph's, extend the cluster to include the intervening chars

        if (gr_slot_can_insert_before(slot) && clusters[cIndex].nChars &&

            before >= clusters[cIndex].baseChar + clusters[cIndex].nChars)

        {

            NS_ASSERTION(cIndex < aLength - 1, "cIndex at end of word");

            Cluster& c = clusters[cIndex + 1];

            c.baseChar = clusters[cIndex].baseChar + clusters[cIndex].nChars;

            c.nChars = before - c.baseChar;

            c.baseGlyph = gIndex;

            c.nGlyphs = 0;

            ++cIndex;

        }

        // increment cluster's glyph count to include current slot

        NS_ASSERTION(cIndex < aLength, "cIndex beyond word length");

        ++clusters[cIndex].nGlyphs;

        // bump |after| index if it falls in the middle of a surrogate pair

        if (NS_IS_HIGH_SURROGATE(aText[after]) && after < aLength - 1 &&

            NS_IS_LOW_SURROGATE(aText[after + 1])) {

            after++;

        }

        // extend cluster if necessary to reach the glyph's "after" index

        if (clusters[cIndex].baseChar + clusters[cIndex].nChars < after + 1) {

            clusters[cIndex].nChars = after + 1 - clusters[cIndex].baseChar;

        }

    }

    CompressedGlyph* charGlyphs = aShapedText->GetCharacterGlyphs() + aOffset;

    bool roundX = bool(aRounding & RoundingFlags::kRoundX);

    bool roundY = bool(aRounding & RoundingFlags::kRoundY);

    // now put glyphs into the textrun, one cluster at a time

    for (uint32_t i = 0; i <= cIndex; ++i) {

        const Cluster& c = clusters[i];

        float adv; // total advance of the cluster

        if (rtl) {

            if (i == 0) {

                adv = gr_seg_advance_X(aSegment) - xLocs[c.baseGlyph];

            } else {

                adv = xLocs[clusters[i-1].baseGlyph] - xLocs[c.baseGlyph];

            }

        } else {

            if (i == cIndex) {

                adv = gr_seg_advance_X(aSegment) - xLocs[c.baseGlyph];

            } else {

                adv = xLocs[clusters[i+1].baseGlyph] - xLocs[c.baseGlyph];

            }

        }

        // Check for default-ignorable char that didn't get filtered, combined,

        // etc by the shaping process, and skip it.

        uint32_t offs = c.baseChar;

        NS_ASSERTION(offs < aLength, "unexpected offset");

        if (c.nGlyphs == 1 && c.nChars == 1 &&

            aShapedText->FilterIfIgnorable(aOffset + offs, aText[offs])) {

            continue;

        }

        uint32_t appAdvance = roundX ? NSToIntRound(adv) * dev2appUnits

                                     : NSToIntRound(adv * dev2appUnits);

        if (c.nGlyphs == 1 &&

            CompressedGlyph::IsSimpleGlyphID(gids[c.baseGlyph]) &&

            CompressedGlyph::IsSimpleAdvance(appAdvance) &&

            charGlyphs[offs].IsClusterStart() &&

            yLocs[c.baseGlyph] == 0)

        {

            charGlyphs[offs].SetSimpleGlyph(appAdvance, gids[c.baseGlyph]);

        } else {

            // not a one-to-one mapping with simple metrics: use DetailedGlyph

            AutoTArray<gfxShapedText::DetailedGlyph,8> details;

            float clusterLoc;

            for (uint32_t j = c.baseGlyph; j < c.baseGlyph + c.nGlyphs; ++j) {

                gfxShapedText::DetailedGlyph* d = details.AppendElement();

                d->mGlyphID = gids[j];

                d->mOffset.y = roundY ? NSToIntRound(-yLocs[j]) * dev2appUnits

                                      : -yLocs[j] * dev2appUnits;

                if (j == c.baseGlyph) {

                    d->mAdvance = appAdvance;

                    clusterLoc = xLocs[j];

                } else {

                    float dx = rtl ? (xLocs[j] - clusterLoc) :

                                     (xLocs[j] - clusterLoc - adv);

                    d->mOffset.x = roundX ? NSToIntRound(dx) * dev2appUnits

                                          : dx * dev2appUnits;

                    d->mAdvance = 0;

                }

            }

            bool isClusterStart = charGlyphs[offs].IsClusterStart();

            aShapedText->SetGlyphs(aOffset + offs,

                                   CompressedGlyph::MakeComplex(isClusterStart,

                                                                true,

                                                                details.Length()),

                                   details.Elements());

        }

        for (uint32_t j = c.baseChar + 1; j < c.baseChar + c.nChars; ++j) {

            NS_ASSERTION(j < aLength, "unexpected offset");

            CompressedGlyph &g = charGlyphs[j];

            NS_ASSERTION(!g.IsSimpleGlyph(), "overwriting a simple glyph");

            g.SetComplex(g.IsClusterStart(), false, 0);

        }

    }

    return NS_OK;

}

#undef SMALL_GLYPH_RUN

// for language tag validation - include list of tags from the IANA registry

#include "gfxLanguageTagList.cpp"

nsTHashtable<nsUint32HashKey> *gfxGraphiteShaper::sLanguageTags;

/*static*/ uint32_t

gfxGraphiteShaper::GetGraphiteTagForLang(const nsCString& aLang)

{

    int len = aLang.Length();

    if (len < 2) {

        return 0;

    }

    // convert primary language subtag to a left-packed, NUL-padded integer

    // for the Graphite API

    uint32_t grLang = 0;

    for (int i = 0; i < 4; ++i) {

        grLang <<= 8;

        if (i < len) {

            uint8_t ch = aLang[i];

            if (ch == '-') {

                // found end of primary language subtag, truncate here

                len = i;

                continue;

            }

            if (ch < 'a' || ch > 'z') {

                // invalid character in tag, so ignore it completely

                return 0;

            }

            grLang += ch;

        }

    }

    // valid tags must have length = 2 or 3

    if (len < 2 || len > 3) {

        return 0;

    }

    if (!sLanguageTags) {

        // store the registered IANA tags in a hash for convenient validation

        sLanguageTags = new nsTHashtable<nsUint32HashKey>(ArrayLength(sLanguageTagList));

        for (const uint32_t *tag = sLanguageTagList; *tag != 0; ++tag) {

            sLanguageTags->PutEntry(*tag);

        }

    }

    // only accept tags known in the IANA registry

    if (sLanguageTags->GetEntry(grLang)) {

        return grLang;

    }

    return 0;

}

/*static*/ void

gfxGraphiteShaper::Shutdown()

{

#ifdef NS_FREE_PERMANENT_DATA

    if (sLanguageTags) {

        sLanguageTags->Clear();

        delete sLanguageTags;

        sLanguageTags = nullptr;

    }

#endif

}