/*

 * Copyright 2003-2008 Sun Microsystems, Inc.  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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.font;

import java.awt.Font;

import java.awt.FontFormatException;

import java.awt.GraphicsEnvironment;

import java.awt.geom.Point2D;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.io.UnsupportedEncodingException;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.IntBuffer;

import java.nio.ShortBuffer;

import java.nio.channels.ClosedChannelException;

import java.nio.channels.FileChannel;

import java.util.HashSet;

import java.util.Locale;

import java.util.logging.Level;

import sun.java2d.Disposer;

import sun.java2d.DisposerRecord;

/**

 * TrueTypeFont is not called SFntFont because it is not expected

 * to handle all types that may be housed in a such a font file.

 * If additional types are supported later, it may make sense to

 * create an SFnt superclass. Eg to handle sfnt-housed postscript fonts.

 * OpenType fonts are handled by this class, and possibly should be

 * represented by a subclass.

 * An instance stores some information from the font file to faciliate

 * faster access. File size, the table directory and the names of the font

 * are the most important of these. It amounts to approx 400 bytes

 * for a typical font. Systems with mutiple locales sometimes have up to 400

 * font files, and an app which loads all font files would need around

 * 160Kbytes. So storing any more info than this would be expensive.

 */

public class TrueTypeFont extends FileFont {

   /* -- Tags for required TrueType tables */

    public static final int cmapTag = 0x636D6170; // 'cmap'

    public static final int glyfTag = 0x676C7966; // 'glyf'

    public static final int headTag = 0x68656164; // 'head'

    public static final int hheaTag = 0x68686561; // 'hhea'

    public static final int hmtxTag = 0x686D7478; // 'hmtx'

    public static final int locaTag = 0x6C6F6361; // 'loca'

    public static final int maxpTag = 0x6D617870; // 'maxp'

    public static final int nameTag = 0x6E616D65; // 'name'

    public static final int postTag = 0x706F7374; // 'post'

    public static final int os_2Tag = 0x4F532F32; // 'OS/2'

    /* -- Tags for opentype related tables */

    public static final int GDEFTag = 0x47444546; // 'GDEF'

    public static final int GPOSTag = 0x47504F53; // 'GPOS'

    public static final int GSUBTag = 0x47535542; // 'GSUB'

    public static final int mortTag = 0x6D6F7274; // 'mort'

    /* -- Tags for non-standard tables */

    public static final int fdscTag = 0x66647363; // 'fdsc' - gxFont descriptor

    public static final int fvarTag = 0x66766172; // 'fvar' - gxFont variations

    public static final int featTag = 0x66656174; // 'feat' - layout features

    public static final int EBLCTag = 0x45424C43; // 'EBLC' - embedded bitmaps

    public static final int gaspTag = 0x67617370; // 'gasp' - hint/smooth sizes

    /* --  Other tags */

    public static final int ttcfTag = 0x74746366; // 'ttcf' - TTC file

    public static final int v1ttTag = 0x00010000; // 'v1tt' - Version 1 TT font

    public static final int trueTag = 0x74727565; // 'true' - Version 2 TT font

    public static final int ottoTag = 0x4f54544f; // 'otto' - OpenType font

    /* -- ID's used in the 'name' table */

    public static final int MS_PLATFORM_ID = 3;

    /* MS locale id for US English is the "default" */

    public static final short ENGLISH_LOCALE_ID = 0x0409; // 1033 decimal

    public static final int FAMILY_NAME_ID = 1;

    // public static final int STYLE_WEIGHT_ID = 2; // currently unused.

    public static final int FULL_NAME_ID = 4;

    public static final int POSTSCRIPT_NAME_ID = 6;

    class DirectoryEntry {

        int tag;

        int offset;

        int length;

    }

    /* There is a pool which limits the number of fd's that are in

     * use. Normally fd's are closed as they are replaced in the pool.

     * But if an instance of this class becomes unreferenced, then there

     * needs to be a way to close the fd. A finalize() method could do this,

     * but using the Disposer class will ensure its called in a more timely

     * manner. This is not something which should be relied upon to free

     * fd's - its a safeguard.

     */

    private static class TTDisposerRecord implements DisposerRecord {

        FileChannel channel = null;

        public synchronized void dispose() {

            try {

                if (channel != null) {

                    channel.close();

                }

            } catch (IOException e) {

            } finally {

                channel = null;

            }

        }

    }

    TTDisposerRecord disposerRecord = new TTDisposerRecord();

    /* > 0 only if this font is a part of a collection */

    int fontIndex = 0;

    /* Number of fonts in this collection. ==1 if not a collection */

    int directoryCount = 1;

    /* offset in file of table directory for this font */

    int directoryOffset; // 12 if its not a collection.

    /* number of table entries in the directory/offsets table */

    int numTables;

    /* The contents of the the directory/offsets table */

    DirectoryEntry []tableDirectory;

//     protected byte []gposTable = null;

//     protected byte []gdefTable = null;

//     protected byte []gsubTable = null;

//     protected byte []mortTable = null;

//     protected boolean hintsTabledChecked = false;

//     protected boolean containsHintsTable = false;

    /* These fields are set from os/2 table info. */

    private boolean supportsJA;

    private boolean supportsCJK;

    /**

     * - does basic verification of the file

     * - reads the header table for this font (within a collection)

     * - reads the names (full, family).

     * - determines the style of the font.

     * - initializes the CMAP

     * @throws FontFormatException - if the font can't be opened

     * or fails verification,  or there's no usable cmap

     */

    TrueTypeFont(String platname, Object nativeNames, int fIndex,

                 boolean javaRasterizer)

        throws FontFormatException {

        super(platname, nativeNames);

        useJavaRasterizer = javaRasterizer;

        fontRank = Font2D.TTF_RANK;

        verify();

        init(fIndex);

        Disposer.addObjectRecord(this, disposerRecord);

    }

    /* Enable natives just for fonts picked up from the platform that

     * may have external bitmaps on Solaris. Could do this just for

     * the fonts that are specified in font configuration files which

     * would lighten the burden (think about that).

     * The EBLCTag is used to skip natives for fonts that contain embedded

     * bitmaps as there's no need to use X11 for those fonts.

     * Skip all the latin fonts as they don't need this treatment.

     * Further refine this to fonts that are natively accessible (ie

     * as PCF bitmap fonts on the X11 font path).

     * This method is called when creating the first strike for this font.

     */

    protected boolean checkUseNatives() {

        if (checkedNatives) {

            return useNatives;

        }

        if (!FontManager.isSolaris || useJavaRasterizer ||

            FontManager.useT2K || nativeNames == null ||

            getDirectoryEntry(EBLCTag) != null ||

            GraphicsEnvironment.isHeadless()) {

            checkedNatives = true;

            return false; /* useNatives is false */

        } else if (nativeNames instanceof String) {

            String name = (String)nativeNames;

            /* Don't do do this for Latin fonts */

            if (name.indexOf("8859") > 0) {

                checkedNatives = true;

                return false;

            } else if (NativeFont.hasExternalBitmaps(name)) {

                nativeFonts = new NativeFont[1];

                try {

                    nativeFonts[0] = new NativeFont(name, true);

                    /* If reach here we have an non-latin font that has

                     * external bitmaps and we successfully created it.

                     */

                    useNatives = true;

                } catch (FontFormatException e) {

                    nativeFonts = null;

                }

            }

        } else if (nativeNames instanceof String[]) {

            String[] natNames = (String[])nativeNames;

            int numNames = natNames.length;

            boolean externalBitmaps = false;

            for (int nn = 0; nn < numNames; nn++) {

                if (natNames[nn].indexOf("8859") > 0) {

                    checkedNatives = true;

                    return false;

                } else if (NativeFont.hasExternalBitmaps(natNames[nn])) {

                    externalBitmaps = true;

                }

            }

            if (!externalBitmaps) {

                checkedNatives = true;

                return false;

            }

            useNatives = true;

            nativeFonts = new NativeFont[numNames];

            for (int nn = 0; nn < numNames; nn++) {

                try {

                    nativeFonts[nn] = new NativeFont(natNames[nn], true);

                } catch (FontFormatException e) {

                    useNatives = false;

                    nativeFonts = null;

                }

            }

        }

        if (useNatives) {

            glyphToCharMap = new char[getMapper().getNumGlyphs()];

        }

        checkedNatives = true;

        return useNatives;

    }

    /* This is intended to be called, and the returned value used,

     * from within a block synchronized on this font object.

     * ie the channel returned may be nulled out at any time by "close()"

     * unless the caller holds a lock.

     * Deadlock warning: FontManager.addToPool(..) acquires a global lock,

     * which means nested locks may be in effect.

     */

    private synchronized FileChannel open() throws FontFormatException {

        if (disposerRecord.channel == null) {

            if (FontManager.logging) {

                FontManager.logger.info("open TTF: " + platName);

            }

            try {

                RandomAccessFile raf = (RandomAccessFile)

                java.security.AccessController.doPrivileged(

                    new java.security.PrivilegedAction() {

                        public Object run() {

                            try {

                                return new RandomAccessFile(platName, "r");

                            } catch (FileNotFoundException ffne) {

                            }

                            return null;

                    }

                });

                disposerRecord.channel = raf.getChannel();

                fileSize = (int)disposerRecord.channel.size();

                FontManager.addToPool(this);

            } catch (NullPointerException e) {

                close();

                throw new FontFormatException(e.toString());

            } catch (ClosedChannelException e) {

                /* NIO I/O is interruptible, recurse to retry operation.

                 * The call to channel.size() above can throw this exception.

                 * Clear interrupts before recursing in case NIO didn't.

                 * Note that close() sets disposerRecord.channel to null.

                 */

                Thread.interrupted();

                close();

                open();

            } catch (IOException e) {

                close();

                throw new FontFormatException(e.toString());

            }

        }

        return disposerRecord.channel;

    }

    protected synchronized void close() {

        disposerRecord.dispose();

    }

    int readBlock(ByteBuffer buffer, int offset, int length) {

        int bread = 0;

        try {

            synchronized (this) {

                if (disposerRecord.channel == null) {

                    open();

                }

                if (offset + length > fileSize) {

                    if (offset >= fileSize) {

                        /* Since the caller ensures that offset is < fileSize

                         * this condition suggests that fileSize is now

                         * different than the value we originally provided

                         * to native when the scaler was created.

                         * Also fileSize is updated every time we

                         * open() the file here, but in native the value

                         * isn't updated. If the file has changed whilst we

                         * are executing we want to bail, not spin.

                         */

                        if (FontManager.logging) {

                            String msg = "Read offset is " + offset +

                                " file size is " + fileSize+

                                " file is " + platName;

                            FontManager.logger.severe(msg);

                        }

                        return -1;

                    } else {

                        length = fileSize - offset;

                    }

                }

                buffer.clear();

                disposerRecord.channel.position(offset);

                while (bread < length) {

                    int cnt = disposerRecord.channel.read(buffer);

                    if (cnt == -1) {

                        String msg = "Unexpected EOF " + this;

                        int currSize = (int)disposerRecord.channel.size();

                        if (currSize != fileSize) {

                            msg += " File size was " + fileSize +

                                " and now is " + currSize;

                        }

                        if (FontManager.logging) {

                            FontManager.logger.severe(msg);

                        }

                        // We could still flip() the buffer here because

                        // it's possible that we did read some data in

                        // an earlier loop, and we probably should

                        // return that to the caller. Although if

                        // the caller expected 8K of data and we return

                        // only a few bytes then maybe it's better instead to

                        // set bread = -1 to indicate failure.

                        // The following is therefore using arbitrary values

                        // but is meant to allow cases where enough

                        // data was read to probably continue.

                        if (bread > length/2 || bread > 16384) {

                            buffer.flip();

                            if (FontManager.logging) {

                                msg = "Returning " + bread +

                                    " bytes instead of " + length;

                                FontManager.logger.severe(msg);

                            }

                        } else {

                            bread = -1;

                        }

                        throw new IOException(msg);

                    }

                    bread += cnt;

                }

                buffer.flip();

                if (bread > length) { // possible if buffer.size() > length

                    bread = length;

                }

            }

        } catch (FontFormatException e) {

            if (FontManager.logging) {

                FontManager.logger.log(Level.SEVERE,

                                       "While reading " + platName, e);

            }

            bread = -1; // signal EOF

            deregisterFontAndClearStrikeCache();

        } catch (ClosedChannelException e) {

            /* NIO I/O is interruptible, recurse to retry operation.

             * Clear interrupts before recursing in case NIO didn't.

             */

            Thread.interrupted();

            close();

            return readBlock(buffer, offset, length);

        } catch (IOException e) {

            /* If we did not read any bytes at all and the exception is

             * not a recoverable one (ie is not ClosedChannelException) then

             * we should indicate that there is no point in re-trying.

             * Other than an attempt to read past the end of the file it

             * seems unlikely this would occur as problems opening the

             * file are handled as a FontFormatException.

             */

            if (FontManager.logging) {

                FontManager.logger.log(Level.SEVERE,

                                       "While reading " + platName, e);

            }

            if (bread == 0) {

                bread = -1; // signal EOF

                deregisterFontAndClearStrikeCache();

            }

        }

        return bread;

    }

    ByteBuffer readBlock(int offset, int length) {

        ByteBuffer buffer = ByteBuffer.allocate(length);

        try {

            synchronized (this) {

                if (disposerRecord.channel == null) {

                    open();

                }

                if (offset + length > fileSize) {

                    if (offset > fileSize) {

                        return null; // assert?

                    } else {

                        buffer = ByteBuffer.allocate(fileSize-offset);

                    }

                }

                disposerRecord.channel.position(offset);

                disposerRecord.channel.read(buffer);

                buffer.flip();

            }

        } catch (FontFormatException e) {

            return null;

        } catch (ClosedChannelException e) {

            /* NIO I/O is interruptible, recurse to retry operation.

             * Clear interrupts before recursing in case NIO didn't.

             */

            Thread.interrupted();

            close();

            readBlock(buffer, offset, length);

        } catch (IOException e) {

            return null;

        }

        return buffer;

    }

    /* This is used by native code which can't allocate a direct byte

     * buffer because of bug 4845371. It, and references to it in native

     * code in scalerMethods.c can be removed once that bug is fixed.

     * 4845371 is now fixed but we'll keep this around as it doesn't cost

     * us anything if its never used/called.

     */

    byte[] readBytes(int offset, int length) {

        ByteBuffer buffer = readBlock(offset, length);

        if (buffer.hasArray()) {

            return buffer.array();

        } else {

            byte[] bufferBytes = new byte[buffer.limit()];

            buffer.get(bufferBytes);

            return bufferBytes;

        }

    }

    private void verify() throws FontFormatException {

        open();

    }

    /* sizes, in bytes, of TT/TTC header records */

    private static final int TTCHEADERSIZE = 12;

    private static final int DIRECTORYHEADERSIZE = 12;

    private static final int DIRECTORYENTRYSIZE = 16;

    protected void init(int fIndex) throws FontFormatException  {

        int headerOffset = 0;

        ByteBuffer buffer = readBlock(0, TTCHEADERSIZE);

        try {

            switch (buffer.getInt()) {

            case ttcfTag:

                buffer.getInt(); // skip TTC version ID

                directoryCount = buffer.getInt();

                if (fIndex >= directoryCount) {

                    throw new FontFormatException("Bad collection index");

                }

                fontIndex = fIndex;

                buffer = readBlock(TTCHEADERSIZE+4*fIndex, 4);

                headerOffset = buffer.getInt();

                break;

            case v1ttTag:

            case trueTag:

            case ottoTag:

                break;

            default:

                throw new FontFormatException("Unsupported sfnt " + platName);

            }

            /* Now have the offset of this TT font (possibly within a TTC)

             * After the TT version/scaler type field, is the short

             * representing the number of tables in the table directory.

             * The table directory begins at 12 bytes after the header.

             * Each table entry is 16 bytes long (4 32-bit ints)

             */

            buffer = readBlock(headerOffset+4, 2);

            numTables = buffer.getShort();

            directoryOffset = headerOffset+DIRECTORYHEADERSIZE;

            ByteBuffer bbuffer = readBlock(directoryOffset,

                                           numTables*DIRECTORYENTRYSIZE);

            IntBuffer ibuffer = bbuffer.asIntBuffer();

            DirectoryEntry table;

            tableDirectory = new DirectoryEntry[numTables];

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

                tableDirectory[i] = table = new DirectoryEntry();

                table.tag   =  ibuffer.get();

                /* checksum */ ibuffer.get();

                table.offset = ibuffer.get();

                table.length = ibuffer.get();

                if (table.offset + table.length > fileSize) {

                    throw new FontFormatException("bad table, tag="+table.tag);

                }

            }

            initNames();

        } catch (Exception e) {

            if (FontManager.logging) {

                FontManager.logger.severe(e.toString());