/*

 * Copyright (c) 2007, 2019, Oracle and/or its affiliates. All rights reserved.

 * 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

 * published by the Free Software Foundation.  Oracle designates this

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

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#include "jni.h"

#include "jni_util.h"

#include "jlong.h"

#include "sunfontids.h"

#include "sun_font_FreetypeFontScaler.h"

#include <stdlib.h>

#if !defined(_WIN32) && !defined(__APPLE_)

#include <dlfcn.h>

#endif

#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 FT_LCD_FILTER_H

#include FT_MODULE_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  FT26Dot6ToInt(x) (((int)(x)) >> 6)

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;

    FT_Stream faceStream;

    jobject font2D;

    jobject directBuffer;

    unsigned char* fontData;

    unsigned fontDataOffset;

    unsigned fontDataLength;

    unsigned fileSize;

} 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) {

    if (scalerInfo == NULL)

        return;

    // FT_Done_Face always closes the stream, but only frees the memory

    // of the data structure if it was internally allocated by FT.

    // We hold on to a pointer to the stream structure if we provide it

    // ourselves, so that we can free it here.

    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 (scalerInfo->faceStream != NULL) {

        free(scalerInfo->faceStream);

    }

    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

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;

    /* A call with numBytes == 0 is a seek. It should return 0 if the

     * seek position is within the file and non-zero otherwise.

     * For all other cases, ie numBytes !=0, return the number of bytes

     * actually read. This applies to truncated reads and also failed reads.

     */

    if (numBytes == 0) {

        if (offset > scalerInfo->fileSize) {

            return -1;

        } else {

            return 0;

       }

    }

    if (offset + numBytes < offset) {

        return 0; // ft should not do this, but just in case.

    }

    if (offset >= scalerInfo->fileSize) {

        return 0;

    }

    if (offset + numBytes > scalerInfo->fileSize) {

        numBytes = scalerInfo->fileSize - offset;

    }

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

    if (numBytes > FILEDATACACHESIZE) {

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

        if (bBuffer != NULL) {

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

                                          scalerInfo->font2D,

                                          sunFontIDs.ttReadBlockMID,

                                          bBuffer, offset, numBytes);

            if (bread < 0) {

                return 0;

            } else {

               return bread;

            }

        } else {

            /* We probably hit 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);

            /* If there's an OutofMemoryError then byteArray will be null */

            if (byteArray == NULL) {

                return 0;

            } else {

                jsize len = (*env)->GetArrayLength(env, byteArray);

                if (len < numBytes) {

                    numBytes = len; // don't get more bytes than there are ..

                }

                (*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;

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

                                      sunFontIDs.ttReadBlockMID,

                                      bBuffer, offset,

                                      scalerInfo->fontDataLength);

        if (bread <= 0) {

            return 0;

        } else if (bread < numBytes) {

           numBytes = bread;

        }

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

        return numBytes;

    }

}

typedef FT_Error (*FT_Prop_Set_Func)(FT_Library library,

                                     const FT_String*  module_name,

                                     const FT_String*  property_name,

                                     const void*       value );

/**

 * Prefer the older v35 freetype byte code interpreter.

 */

static void setInterpreterVersion(FT_Library library) {

    char* props = getenv("FREETYPE_PROPERTIES");

    int version = 35;

    const char* module = "truetype";

    const char* property = "interpreter-version";

    /* If some one is setting this, don't override it */

    if (props != NULL && strstr(property, props)) {

        return;

    }

    /*

     * FT_Property_Set was introduced in 2.4.11.

     * Some older supported Linux OSes may not include it so look

     * this up dynamically.

     * And if its not available it doesn't matter, since the reason

     * we need it dates from 2.7.

     * On Windows & Mac the library is always bundled so it is safe

     * to use directly in those cases.

     */

#if defined(_WIN32) || defined(__APPLE__)

    FT_Property_Set(library, module, property, (void*)(&version));

#else

    void *lib = dlopen("libfreetype.so", RTLD_LOCAL|RTLD_LAZY);

    if (lib == NULL) {

        lib = dlopen("libfreetype.so.6", RTLD_LOCAL|RTLD_LAZY);

        if (lib == NULL) {

            return;

        }

    }

    FT_Prop_Set_Func func = (FT_Prop_Set_Func)dlsym(lib, "FT_Property_Set");

    if (func != NULL) {

        func(library, module, property, (void*)(&version));

    }

    dlclose(lib);

#endif

}

/*

 * 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_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 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;

    }

    setInterpreterVersion(scalerInfo->library);

#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->fontDataLength = filesize;

        if (scalerInfo->fontData != NULL) {

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

                                              scalerInfo->fontData,

                                              scalerInfo->fontDataLength);

            if (bBuffer != NULL) {

                (*env)->CallVoidMethod(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);

        if (scalerInfo->fontData != NULL) {

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

            if (ftstream != 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 = NULL;

                    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->faceStream = ftstream;

                    }

                }

                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,

        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);

    /* freetype is very keen to use embedded bitmaps, even if it knows

     * there is a rotation or you asked for antialiasing.

     * In the rendering path we will check useSBits and disable

     * bitmaps unless it is set. And here we set it only if none

     * of the conditions invalidate using it.

     * Note that we allow embedded bitmaps for the LCD case.

     */

    if ((aa != TEXT_AA_ON) && (fm != TEXT_FM_ON) &&

        !context->doBold && !context->doItalize &&

        (context->transform.yx == 0) && (context->transform.xy == 0))

    {

        context->useSbits = 1;

    }

    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);

        }

        FT_Library_SetLcdFilter(scalerInfo->library, FT_LCD_FILTER_DEFAULT);

    }

    return errCode;

}

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

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

   Note that y coordinate does not change. These values are based on

   libfreetype version 2.9.1. */

#define OBLIQUE_MODIFIER(y)  (context->doItalize ? ((y)*0x366A/0x10000) : 0)

/* FT_GlyphSlot_Embolden (ftsynth.c) uses FT_MulFix(units_per_EM, y_scale) / 24

 * strength value when glyph format is FT_GLYPH_FORMAT_OUTLINE. This value has

 * been taken from libfreetype version 2.6 and remain valid at least up to

 * 2.9.1. */

#define BOLD_MODIFIER(units_per_EM, y_scale) \

    (context->doBold ? FT_MulFix(units_per_EM, y_scale) / 24 : 0)