/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * particular file as subject to the "Classpath" exception as provided

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

#include "jni.h"

#include "jni_util.h"

#include "jlong.h"

#include "sunfontids.h"

#include "sun_font_FreetypeFontScaler.h"

#include<stdlib.h>

#include <math.h>

#include "ft2build.h"

#include FT_FREETYPE_H

#include FT_GLYPH_H

#include FT_BBOX_H

#include FT_SIZES_H

#include FT_OUTLINE_H

#include FT_SYNTHESIS_H

#include "fontscaler.h"

#define  ftFixed1  (FT_Fixed) (1 << 16)

#define  FloatToFTFixed(f) (FT_Fixed)((f) * (float)(ftFixed1))

#define  FTFixedToFloat(x) ((x) / (float)(ftFixed1))

#define  FT26Dot6ToFloat(x)  ((x) / ((float) (1<<6)))

#define  ROUND(x) ((int) (x+0.5))

typedef struct {

    /* Important note:

         JNI forbids sharing same env between different threads.

         We are safe, because pointer is overwritten every time we get into

         JNI call (see setupFTContext).

         Pointer is used by font data reading callbacks

         such as ReadTTFontFileFunc.

         NB: We may consider switching to JNI_GetEnv. */

    JNIEnv* env;

    FT_Library library;

    FT_Face face;

    jobject font2D;

    jobject directBuffer;

    unsigned char* fontData;

    unsigned fontDataOffset;

    unsigned fontDataLength;

    unsigned fileSize;

    TTLayoutTableCache* layoutTables;

} FTScalerInfo;

typedef struct FTScalerContext {

    FT_Matrix  transform;     /* glyph transform, including device transform */

    jboolean   useSbits;      /* sbit usage enabled? */

    jint       aaType;        /* antialiasing mode (off/on/grey/lcd) */

    jint       fmType;        /* fractional metrics - on/off */

    jboolean   doBold;        /* perform algorithmic bolding? */

    jboolean   doItalize;     /* perform algorithmic italicizing? */

    int        renderFlags;   /* configuration specific to particular engine */

    int        pathType;

    int        ptsz;          /* size in points */

} FTScalerContext;

#ifdef DEBUG

/* These are referenced in the freetype sources if DEBUG macro is defined.

   To simplify work with debuging version of freetype we define

   them here. */

int z_verbose;

void z_error(char *s) {}

#endif

/**************** Error handling utilities *****************/

static jmethodID invalidateScalerMID;

JNIEXPORT void JNICALL

Java_sun_font_FreetypeFontScaler_initIDs(

        JNIEnv *env, jobject scaler, jclass FFSClass) {

    invalidateScalerMID =

        (*env)->GetMethodID(env, FFSClass, "invalidateScaler", "()V");

}

static void freeNativeResources(JNIEnv *env, FTScalerInfo* scalerInfo) {

    void *stream;

    if (scalerInfo == NULL)

        return;

    //apparently Done_Face will only close the stream

    // but will not relase the memory of stream structure.

    // We need to free it explicitly to avoid leak.

    //Direct access to the stream field might be not ideal solution as

    // it is considred to be "private".

    //Alternatively we could have stored pointer to the structure

    // in the scalerInfo but this will increase size of the structure

    // for no good reason

    stream = scalerInfo->face->stream;

    FT_Done_Face(scalerInfo->face);

    FT_Done_FreeType(scalerInfo->library);

    if (scalerInfo->directBuffer != NULL) {

        (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);

    }

    if (scalerInfo->fontData != NULL) {

        free(scalerInfo->fontData);

    }

   if (stream != NULL) {

        free(stream);

   }

    free(scalerInfo);

}

/* invalidates state of java scaler object */

static void invalidateJavaScaler(JNIEnv *env,

                                 jobject scaler,

                                 FTScalerInfo* scalerInfo) {

    freeNativeResources(env, scalerInfo);

    (*env)->CallVoidMethod(env, scaler, invalidateScalerMID);

}

/******************* I/O handlers ***************************/

#define FILEDATACACHESIZE 1024

/* NB: is it ever called? */

static void CloseTTFontFileFunc(FT_Stream stream) {

    FTScalerInfo *scalerInfo = (FTScalerInfo *) stream->pathname.pointer;

    JNIEnv* env = scalerInfo->env;

    jclass tmpClass = (*env)->FindClass(env, "sun/font/TrueTypeFont");

    jfieldID platNameField =

         (*env)->GetFieldID(env, tmpClass, "platName", "Ljava/lang/String;");

    jstring platName = (*env)->GetObjectField(env,

                                              scalerInfo->font2D,

                                              platNameField);

    const char *name = JNU_GetStringPlatformChars(env, platName, NULL);

    JNU_ReleaseStringPlatformChars(env, platName, name);

}

static unsigned long ReadTTFontFileFunc(FT_Stream stream,

                                        unsigned long offset,

                                        unsigned char* destBuffer,

                                        unsigned long numBytes)

{

    FTScalerInfo *scalerInfo = (FTScalerInfo *) stream->pathname.pointer;

    JNIEnv* env = scalerInfo->env;

    jobject bBuffer;

    int bread = 0;

    if (numBytes == 0) return 0;

    /* Large reads will bypass the cache and data copying */

    if (numBytes > FILEDATACACHESIZE) {

        bBuffer = (*env)->NewDirectByteBuffer(env, destBuffer, numBytes);

        if (bBuffer != NULL) {

            /* Loop until the read succeeds (or EOF).

             * This should improve robustness in the event of a problem in

             * the I/O system. If we find that we ever end up spinning here

             * we are going to have to do some serious work to recover.

             * Just returning without reading the data will cause a crash.

             */

            while (bread == 0) {

                bread = (*env)->CallIntMethod(env,

                                              scalerInfo->font2D,

                                              sunFontIDs.ttReadBlockMID,

                                              bBuffer, offset, numBytes);

            }

            return bread;

        } else {

            /* We probably hit bug bug 4845371. For reasons that

             * are currently unclear, the call stacks after the initial

             * createScaler call that read large amounts of data seem to

             * be OK and can create the byte buffer above, but this code

             * is here just in case.

             * 4845371 is fixed now so I don't expect this code path to

             * ever get called but its harmless to leave it here on the

             * small chance its needed.

             */

            jbyteArray byteArray = (jbyteArray)

            (*env)->CallObjectMethod(env, scalerInfo->font2D,

                                     sunFontIDs.ttReadBytesMID,

                                     offset, numBytes);

            (*env)->GetByteArrayRegion(env, byteArray,

                                       0, numBytes, (jbyte*)destBuffer);

            return numBytes;

        }

    } /* Do we have a cache hit? */

      else if (scalerInfo->fontDataOffset <= offset &&

        scalerInfo->fontDataOffset + scalerInfo->fontDataLength >=

                                                         offset + numBytes)

    {

        unsigned cacheOffset = offset - scalerInfo->fontDataOffset;

        memcpy(destBuffer, scalerInfo->fontData+(size_t)cacheOffset, numBytes);

        return numBytes;

    } else {

        /* Must fill the cache */

        scalerInfo->fontDataOffset = offset;

        scalerInfo->fontDataLength =

                 (offset + FILEDATACACHESIZE > scalerInfo->fileSize) ?

                 scalerInfo->fileSize - offset : FILEDATACACHESIZE;

        bBuffer = scalerInfo->directBuffer;

        /* Loop until all the read succeeds (or EOF).

         * This should improve robustness in the event of a problem in

         * the I/O system. If we find that we ever end up spinning here

         * we are going to have to do some serious work to recover.

         * Just returning without reading the data will cause a crash.

         */

        while (bread == 0) {

            bread = (*env)->CallIntMethod(env, scalerInfo->font2D,

                                          sunFontIDs.ttReadBlockMID,

                                          bBuffer, offset,

                                          scalerInfo->fontDataLength);

        }

        memcpy(destBuffer, scalerInfo->fontData, numBytes);

        return numBytes;

    }

}

/*

 * Class:     sun_font_FreetypeFontScaler

 * Method:    initNativeScaler

 * Signature: (Lsun/font/Font2D;IIZI)J

 */

JNIEXPORT jlong JNICALL

Java_sun_font_FreetypeFontScaler_initNativeScaler(

        JNIEnv *env, jobject scaler, jobject font2D, jint type,

        jint indexInCollection, jboolean supportsCJK, jint filesize) {

    FTScalerInfo* scalerInfo = NULL;

    FT_Stream ftstream;

    FT_Open_Args ft_open_args;

    int error;

    jobject bBuffer;

    scalerInfo = (FTScalerInfo*) calloc(1, sizeof(FTScalerInfo));

    if (scalerInfo == NULL)

        return 0;

    scalerInfo->env = env;

    scalerInfo->font2D = font2D;

    scalerInfo->fontDataOffset = 0;

    scalerInfo->fontDataLength = 0;

    scalerInfo->fileSize = filesize;

    /*

       We can consider sharing freetype library between different

       scalers. However, Freetype docs suggest to use different libraries

       for different threads. Also, our architecture implies that single

       FontScaler object is shared for for different sizes/transforms/styles

       of the same font.

       On other hand these methods can not be concurrently executed

       becaused they are "synchronized" in java.

    */

    error = FT_Init_FreeType(&scalerInfo->library);

    if (error) {

        free(scalerInfo);

        return 0;

    }

#define TYPE1_FROM_JAVA        2

    error = 1; /* triggers memory freeing unless we clear it */

    if (type == TYPE1_FROM_JAVA) { /* TYPE1 */

        scalerInfo->fontData = (unsigned char*) malloc(filesize);

        scalerInfo->directBuffer = NULL;

        scalerInfo->layoutTables = NULL;

        scalerInfo->fontDataLength = filesize;

        if (scalerInfo->fontData != NULL) {

            bBuffer = (*env)->NewDirectByteBuffer(env,

                                              scalerInfo->fontData,

                                              scalerInfo->fontDataLength);

            if (bBuffer != NULL) {

                (*env)->CallObjectMethod(env, font2D,

                                   sunFontIDs.readFileMID, bBuffer);

                error = FT_New_Memory_Face(scalerInfo->library,

                                   scalerInfo->fontData,

                                   scalerInfo->fontDataLength,

                                   indexInCollection,

                                   &scalerInfo->face);

            }

        }

    } else { /* Truetype */

        scalerInfo->fontData = (unsigned char*) malloc(FILEDATACACHESIZE);

        ftstream = (FT_Stream) calloc(1, sizeof(FT_StreamRec));

        if (ftstream != NULL && scalerInfo->fontData != NULL) {

            scalerInfo->directBuffer = (*env)->NewDirectByteBuffer(env,

                                        scalerInfo->fontData,

                                        FILEDATACACHESIZE);

            if (scalerInfo->directBuffer != NULL) {

                scalerInfo->directBuffer = (*env)->NewGlobalRef(env,

                                            scalerInfo->directBuffer);

                ftstream->base = NULL;

                ftstream->size = filesize;

                ftstream->pos = 0;

                ftstream->read = (FT_Stream_IoFunc) ReadTTFontFileFunc;

                ftstream->close = (FT_Stream_CloseFunc) CloseTTFontFileFunc;

                ftstream->pathname.pointer = (void *) scalerInfo;

                memset(&ft_open_args, 0, sizeof(FT_Open_Args));

                ft_open_args.flags = FT_OPEN_STREAM;

                ft_open_args.stream = ftstream;

                error = FT_Open_Face(scalerInfo->library,

                                     &ft_open_args,

                                     indexInCollection,

                                     &scalerInfo->face);

           }

           if (error || scalerInfo->directBuffer == NULL) {

               free(ftstream);

           }

        }

    }

    if (error) {

        FT_Done_FreeType(scalerInfo->library);

        if (scalerInfo->directBuffer != NULL) {

            (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);

        }

        if (scalerInfo->fontData != NULL)

            free(scalerInfo->fontData);

        free(scalerInfo);

        return 0;

    }

    return ptr_to_jlong(scalerInfo);

}

static double euclidianDistance(double a, double b) {

    if (a < 0) a=-a;

    if (b < 0) b=-b;

    if (a == 0) return b;

    if (b == 0) return a;

    return sqrt(a*a+b*b);

}

JNIEXPORT jlong JNICALL

Java_sun_font_FreetypeFontScaler_createScalerContextNative(

        JNIEnv *env, jobject scaler, jlong pScaler, jdoubleArray matrix,

        jboolean ttFont, jint aa, jint fm, jfloat boldness, jfloat italic) {

    double dmat[4], ptsz;

    FTScalerContext *context =

            (FTScalerContext*) calloc(1, sizeof(FTScalerContext));

    FTScalerInfo *scalerInfo =

             (FTScalerInfo*) jlong_to_ptr(pScaler);

    if (context == NULL) {

        invalidateJavaScaler(env, scaler, NULL);

        return (jlong) 0;

    }

    (*env)->GetDoubleArrayRegion(env, matrix, 0, 4, dmat);

    ptsz = euclidianDistance(dmat[2], dmat[3]); //i.e. y-size

    if (ptsz < 1.0) {

        //text can not be smaller than 1 point

        ptsz = 1.0;

    }

    context->ptsz = (int)(ptsz * 64);

    context->transform.xx =  FloatToFTFixed((float)dmat[0]/ptsz);

    context->transform.yx = -FloatToFTFixed((float)dmat[1]/ptsz);

    context->transform.xy = -FloatToFTFixed((float)dmat[2]/ptsz);

    context->transform.yy =  FloatToFTFixed((float)dmat[3]/ptsz);

    context->aaType = aa;

    context->fmType = fm;

    /* If using algorithmic styling, the base values are

     * boldness = 1.0, italic = 0.0.

     */

    context->doBold = (boldness != 1.0);

    context->doItalize = (italic != 0);

    return ptr_to_jlong(context);

}

static int setupFTContext(JNIEnv *env,

                          jobject font2D,

                          FTScalerInfo *scalerInfo,

                          FTScalerContext *context) {

    int errCode = 0;

    scalerInfo->env = env;

    scalerInfo->font2D = font2D;

    if (context != NULL) {

        FT_Set_Transform(scalerInfo->face, &context->transform, NULL);

        errCode = FT_Set_Char_Size(scalerInfo->face, 0, context->ptsz, 72, 72);

        if (errCode == 0) {

            errCode = FT_Activate_Size(scalerInfo->face->size);

        }

    }

    return errCode;

}

/* ftsynth.c uses (0x10000, 0x06000, 0x0, 0x10000) matrix to get oblique

   outline.  Therefore x coordinate will change by 0x06000*y.

   Note that y coordinate does not change. */

#define OBLIQUE_MODIFIER(y)  (context->doItalize ? ((y)*6/16) : 0)

/*

 * Class:     sun_font_FreetypeFontScaler

 * Method:    getFontMetricsNative

 * Signature: (Lsun/font/Font2D;J)Lsun/font/StrikeMetrics;

 */

JNIEXPORT jobject JNICALL

Java_sun_font_FreetypeFontScaler_getFontMetricsNative(

        JNIEnv *env, jobject scaler, jobject font2D,

        jlong pScalerContext, jlong pScaler) {

    jobject metrics;

    jfloat ax, ay, dx, dy, bx, by, lx, ly, mx, my;

    jfloat f0 = 0.0;

    FT_Pos bmodifier = 0;

    FTScalerContext *context =

        (FTScalerContext*) jlong_to_ptr(pScalerContext);

    FTScalerInfo *scalerInfo =

             (FTScalerInfo*) jlong_to_ptr(pScaler);

    int errCode;

    if (isNullScalerContext(context) || scalerInfo == NULL) {

        return (*env)->NewObject(env,

                                 sunFontIDs.strikeMetricsClass,

                                 sunFontIDs.strikeMetricsCtr,

                                 f0, f0, f0, f0, f0, f0, f0, f0, f0, f0);

    }

    errCode = setupFTContext(env, font2D, scalerInfo, context);

    if (errCode) {

        metrics = (*env)->NewObject(env,

                                 sunFontIDs.strikeMetricsClass,

                                 sunFontIDs.strikeMetricsCtr,

                                 f0, f0, f0, f0, f0, f0, f0, f0, f0, f0);

        invalidateJavaScaler(env, scaler, scalerInfo);

        return metrics;

    }

    /* This is ugly and has to be reworked.

       Freetype provide means to add style to glyph but

       it seems there is no way to adjust metrics accordingly.

       So, we have to do adust them explicitly and stay consistent with what

       freetype does to outlines. */

    /* For bolding glyphs are not just widened. Height is also changed

       (see ftsynth.c).

       TODO: In vertical direction we could do better job and adjust metrics

       proportionally to glyoh shape. */

    if (context->doBold) {

        bmodifier = FT_MulFix(

                       scalerInfo->face->units_per_EM,

                       scalerInfo->face->size->metrics.y_scale)/24;

    }

    /**** Note: only some metrics are affected by styling ***/

    /* ascent */

    ax = 0;

    ay = -(jfloat) FT26Dot6ToFloat(

                       scalerInfo->face->size->metrics.ascender +

                       bmodifier/2);

    /* descent */

    dx = 0;

    dy = -(jfloat) FT26Dot6ToFloat(

                       scalerInfo->face->size->metrics.descender +

                       bmodifier/2);

    /* baseline */

    bx = by = 0;

    /* leading */

    lx = 0;

    ly = (jfloat) FT26Dot6ToFloat(

                      scalerInfo->face->size->metrics.height +

                      bmodifier) + ay - dy;

    /* max advance */

    mx = (jfloat) FT26Dot6ToFloat(

                     scalerInfo->face->size->metrics.max_advance +

                     2*bmodifier +

                     OBLIQUE_MODIFIER(scalerInfo->face->size->metrics.height));

    my = 0;

    metrics = (*env)->NewObject(env,

                                sunFontIDs.strikeMetricsClass,

                                sunFontIDs.strikeMetricsCtr,

                                ax, ay, dx, dy, bx, by, lx, ly, mx, my);

    return metrics;

}

/*

 * Class:     sun_font_FreetypeFontScaler