/*

 * Copyright (c) 2007, 2013, 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.

 */

package sun.java2d;

import java.awt.Color;

import java.awt.Rectangle;

import java.awt.AlphaComposite;

import java.awt.GraphicsEnvironment;

import sun.awt.DisplayChangedListener;

import sun.java2d.StateTrackable.State;

import sun.java2d.loops.CompositeType;

import sun.java2d.loops.SurfaceType;

import sun.java2d.loops.Blit;

import sun.java2d.loops.BlitBg;

import sun.awt.image.SurfaceManager;

import sun.awt.image.SurfaceManager.FlushableCacheData;

import java.security.AccessController;

import sun.security.action.GetPropertyAction;

/**

 * The proxy class encapsulates the logic for managing alternate

 * SurfaceData representations of a primary SurfaceData.

 * The main class will handle tracking the state changes of the

 * primary SurfaceData and updating the associated SurfaceData

 * proxy variants.

 * <p>

 * Subclasses have 2 main responsibilities:

 * <ul>

 * <li> Override the isSupportedOperation() method to determine if

 *      a given operation can be accelerated with a given source

 *      SurfaceData

 * <li> Override the validateSurfaceData() method to create or update

 *      a given accelerated surface to hold the pixels for the indicated

 *      source SurfaceData

 * </ul>

 * If necessary, a subclass may also override the updateSurfaceData

 * method to transfer the pixels to the accelerated surface.

 * By default the parent class will transfer the pixels using a

 * standard Blit operation between the two SurfaceData objects.

 */

public abstract class SurfaceDataProxy

    implements DisplayChangedListener, SurfaceManager.FlushableCacheData

{

    private static boolean cachingAllowed;

    private static int defaultThreshold;

    static {

        cachingAllowed = true;

        String manimg = AccessController.doPrivileged(

            new GetPropertyAction("sun.java2d.managedimages"));

        if (manimg != null && manimg.equals("false")) {

            cachingAllowed = false;

            System.out.println("Disabling managed images");

        }

        defaultThreshold = 1;

        String num = AccessController.doPrivileged(

            new GetPropertyAction("sun.java2d.accthreshold"));

        if (num != null) {

            try {

                int parsed = Integer.parseInt(num);

                if (parsed >= 0) {

                    defaultThreshold = parsed;

                    System.out.println("New Default Acceleration Threshold: " +

                                       defaultThreshold);

                }

            } catch (NumberFormatException e) {

                System.err.println("Error setting new threshold:" + e);

            }

        }

    }

    public static boolean isCachingAllowed() {

        return cachingAllowed;

    }

    /**

     * Determine if an alternate form for the srcData is needed

     * and appropriate from the given operational parameters.

     */

    public abstract boolean isSupportedOperation(SurfaceData srcData,

                                                 int txtype,

                                                 CompositeType comp,

                                                 Color bgColor);

    /**

     * Construct an alternate form of the given SurfaceData.

     * The contents of the returned SurfaceData may be undefined

     * since the calling code will take care of updating the

     * contents with a subsequent call to updateSurfaceData.

     * <p>

     * If the method returns null then there was a problem with

     * allocating the accelerated surface.  The getRetryTracker()

     * method will be called to track when to attempt another

     * revalidation.

     */

    public abstract SurfaceData validateSurfaceData(SurfaceData srcData,

                                                    SurfaceData cachedData,

                                                    int w, int h);

    /**

     * If the subclass is unable to validate or create a cached

     * SurfaceData then this method will be used to get a

     * StateTracker object that will indicate when to attempt

     * to validate the surface again.  Subclasses may return

     * trackers which count down an ever increasing threshold

     * to provide hysteresis on creating surfaces during low

     * memory conditions.  The default implementation just waits

     * another "threshold" number of accesses before trying again.

     */

    public StateTracker getRetryTracker(SurfaceData srcData) {

        return new CountdownTracker(threshold);

    }

    public static class CountdownTracker implements StateTracker {

        private int countdown;

        public CountdownTracker(int threshold) {

            this.countdown = threshold;

        }

        public synchronized boolean isCurrent() {

            return (--countdown >= 0);

        }

    }

    /**

     * This instance is for cases where a caching implementation

     * determines that a particular source image will never need

     * to be cached - either the source SurfaceData was of an

     * incompatible type, or it was in an UNTRACKABLE state or

     * some other factor is discovered that permanently prevents

     * acceleration or caching.

     * This class optimally implements NOP variants of all necessary

     * methods to avoid caching with a minimum of fuss.

     */

    public static SurfaceDataProxy UNCACHED = new SurfaceDataProxy(0) {

        @Override

        public boolean isAccelerated() {

            return false;

        }

        @Override

        public boolean isSupportedOperation(SurfaceData srcData,

                                            int txtype,

                                            CompositeType comp,

                                            Color bgColor)

        {

            return false;

        }

        @Override

        public SurfaceData validateSurfaceData(SurfaceData srcData,

                                               SurfaceData cachedData,

                                               int w, int h)

        {

            throw new InternalError("UNCACHED should never validate SDs");

        }

        @Override

        public SurfaceData replaceData(SurfaceData srcData,

                                       int txtype,

                                       CompositeType comp,

                                       Color bgColor)

        {

            // Not necessary to override this, but doing so is faster

            return srcData;

        }

    };

    // The number of attempts to copy from a STABLE source before

    // a cached copy is created or updated.

    private int threshold;

    /*

     * Source tracking data

     *

     * Every time that srcTracker is out of date we will reset numtries

     * to threshold and set the cacheTracker to one that is non-current.

     * numtries will then count down to 0 at which point the cacheTracker

     * will remind us that we need to update the cachedSD before we can

     * use it.

     *

     * Note that since these fields interrelate we should synchronize

     * whenever we update them, but it should be OK to read them

     * without synchronization.

     */

    private StateTracker srcTracker;

    private int numtries;

    /*

     * Cached data

     *

     * We cache a SurfaceData created by the subclass in cachedSD and

     * track its state (isValid and !surfaceLost) in cacheTracker.

     *

     * Also, when we want to note that cachedSD needs to be updated

     * we replace the cacheTracker with a NEVER_CURRENT tracker which

     * will cause us to try to revalidate and update the surface on

     * next use.

     */

    private SurfaceData cachedSD;

    private StateTracker cacheTracker;

    /*

     * Are we still the best object to control caching of data

     * for the source image?

     */

    private boolean valid;

    /**

     * Create a SurfaceData proxy manager that attempts to create

     * and cache a variant copy of the source SurfaceData after

     * the default threshold number of attempts to copy from the

     * STABLE source.

     */

    public SurfaceDataProxy() {

        this(defaultThreshold);

    }

    /**

     * Create a SurfaceData proxy manager that attempts to create

     * and cache a variant copy of the source SurfaceData after

     * the specified threshold number of attempts to copy from

     * the STABLE source.

     */

    public SurfaceDataProxy(int threshold) {

        this.threshold = threshold;

        this.srcTracker = StateTracker.NEVER_CURRENT;

        // numtries will be reset on first use

        this.cacheTracker = StateTracker.NEVER_CURRENT;

        this.valid = true;

    }

    /**

     * Returns true iff this SurfaceData proxy is still the best

     * way to control caching of the given source on the given

     * destination.

     */

    public boolean isValid() {

        return valid;

    }

    /**

     * Sets the valid state to false so that the next time this

     * proxy is fetched to generate a replacement SurfaceData,

     * the code in SurfaceData knows to replace the proxy first.

     */

    public void invalidate() {

        this.valid = false;

    }

    /**

     * Flush all cached resources as per the FlushableCacheData interface.

     * The deaccelerated parameter indicates if the flush is

     * happening because the associated surface is no longer

     * being accelerated (for instance the acceleration priority

     * is set below the threshold needed for acceleration).

     * Returns a boolean that indicates if the cached object is

     * no longer needed and should be removed from the cache.

     */

    public boolean flush(boolean deaccelerated) {

        if (deaccelerated) {

            invalidate();

        }

        flush();

        return !isValid();

    }

    /**

     * Actively flushes (drops and invalidates) the cached surface

     * so that it can be reclaimed quickly.

     */

    public synchronized void flush() {

        SurfaceData csd = this.cachedSD;

        this.cachedSD = null;

        this.cacheTracker = StateTracker.NEVER_CURRENT;

        if (csd != null) {

            csd.flush();

        }

    }

    /**

     * Returns true iff this SurfaceData proxy is still valid

     * and if it has a currently cached replacement that is also

     * valid and current.

     */

    public boolean isAccelerated() {

        return (isValid() &&

                srcTracker.isCurrent() &&

                cacheTracker.isCurrent());

    }

    /**

     * This method should be called from subclasses which create

     * cached SurfaceData objects that depend on the current

     * properties of the display.

     */

    protected void activateDisplayListener() {

        GraphicsEnvironment ge =

            GraphicsEnvironment.getLocalGraphicsEnvironment();

        // We could have a HeadlessGE at this point, so double-check before

        // assuming anything.

        // Also, no point in listening to display change events if

        // the image is never going to be accelerated.

        if (ge instanceof SunGraphicsEnvironment) {

            ((SunGraphicsEnvironment)ge).addDisplayChangedListener(this);

        }

    }

    /**

     * Invoked when the display mode has changed.

     * This method will invalidate and drop the internal cachedSD object.

     */

    public void displayChanged() {

        flush();

    }

    /**

     * Invoked when the palette has changed.

     */

    public void paletteChanged() {

        // We could potentially get away with just resetting cacheTracker

        // here but there is a small window of vulnerability in the

        // replaceData method where we could be just finished with

        // updating the cachedSD when this method is called and even

        // though we set a non-current cacheTracker here it will then

        // immediately get set to a current one by the thread that is

        // updating the cachedSD.  It is safer to just replace the

        // srcTracker with a non-current version that will trigger a

        // full update cycle the next time this proxy is used.

        // The downside is having to go through a full threshold count

        // before we can update and use our cache again, but palette

        // changes should be relatively rare...

        this.srcTracker = StateTracker.NEVER_CURRENT;

    }

    /**

     * This method attempts to replace the srcData with a cached version.

     * It relies on the subclass to determine if the cached version will

     * be useful given the operational parameters.

     * This method checks any preexisting cached copy for being "up to date"

     * and tries to update it if it is stale or non-existant and the

     * appropriate number of accesses have occurred since it last was stale.

     * <p>

     * An outline of the process is as follows:

     * <ol>

     * <li> Check the operational parameters (txtype, comp, bgColor)

     *      to make sure that the operation is supported.  Return the

     *      original SurfaceData if the operation cannot be accelerated.

     * <li> Check the tracker for the source surface to see if it has

     *      remained stable since it was last cached.  Update the state

     *      variables to cause both a threshold countdown and an update

     *      of the cached copy if it is not.  (Setting cacheTracker to

     *      NEVER_CURRENT effectively marks it as "needing to be updated".)

     * <li> Check the tracker for the cached copy to see if is still

     *      valid and up to date.  Note that the cacheTracker may be

     *      non-current if either something happened to the cached copy

     *      (eg. surfaceLost) or if the source was out of date and the

     *      cacheTracker was set to NEVER_CURRENT to force an update.

     *      Decrement the countdown and copy the source to the cache

     *      as necessary and then update the variables to show that

     *      the cached copy is stable.

     * </ol>

     */

    public SurfaceData replaceData(SurfaceData srcData,

                                   int txtype,

                                   CompositeType comp,

                                   Color bgColor)

    {

        if (isSupportedOperation(srcData, txtype, comp, bgColor)) {

            // First deal with tracking the source.

            if (!srcTracker.isCurrent()) {

                synchronized (this) {

                    this.numtries = threshold;

                    this.srcTracker = srcData.getStateTracker();

                    this.cacheTracker = StateTracker.NEVER_CURRENT;

                }

                if (!srcTracker.isCurrent()) {

                    // Dynamic or Untrackable (or a very recent modification)

                    if (srcData.getState() == State.UNTRACKABLE) {

                        // UNTRACKABLE means we can never cache again.

                        // Invalidate so we get replaced next time we are used

                        // (presumably with an UNCACHED proxy).

                        invalidate();

                        // Aggressively drop our reference to the cachedSD

                        // in case this proxy is not consulted again (and

                        // thus replaced) for a long time.

                        flush();

                    }

                    return srcData;

                }

            }

            // Then deal with checking the validity of the cached SurfaceData

            SurfaceData csd = this.cachedSD;

            if (!cacheTracker.isCurrent()) {

                // Next make sure the dust has settled

                synchronized (this) {

                    if (numtries > 0) {

                        --numtries;

                        return srcData;

                    }

                }

                Rectangle r = srcData.getBounds();

                int w = r.width;

                int h = r.height;

                // Snapshot the tracker in case it changes while

                // we are updating the cached SD...

                StateTracker curTracker = srcTracker;

                csd = validateSurfaceData(srcData, csd, w, h);

                if (csd == null) {

                    synchronized (this) {

                        if (curTracker == srcTracker) {

                            this.cacheTracker = getRetryTracker(srcData);

                            this.cachedSD = null;

                        }

                    }

                    return srcData;

                }

                updateSurfaceData(srcData, csd, w, h);

                if (!csd.isValid()) {

                    return srcData;

                }

                synchronized (this) {

                    // We only reset these variables if the tracker from

                    // before the surface update is still in use and current

                    // Note that we must use a srcTracker that was fetched

                    // from before the update process to make sure that we

                    // do not lose some pixel changes in the shuffle.

                    if (curTracker == srcTracker && curTracker.isCurrent()) {

                        this.cacheTracker = csd.getStateTracker();

                        this.cachedSD = csd;

                    }

                }

            }

            if (csd != null) {

                return csd;

            }

        }

        return srcData;

    }

    /**

     * This is the default implementation for updating the cached

     * SurfaceData from the source (primary) SurfaceData.

     * A simple Blit is used to copy the pixels from the source to

     * the destination SurfaceData.

     * A subclass can override this implementation if a more complex

     * operation is required to update its cached copies.

     */

    public void updateSurfaceData(SurfaceData srcData,

                                  SurfaceData dstData,

                                  int w, int h)

    {

        SurfaceType srcType = srcData.getSurfaceType();

        SurfaceType dstType = dstData.getSurfaceType();

        Blit blit = Blit.getFromCache(srcType,

                                      CompositeType.SrcNoEa,

                                      dstType);

        blit.Blit(srcData, dstData,

                  AlphaComposite.Src, null,

                  0, 0, 0, 0, w, h);

        dstData.markDirty();

    }

    /**

     * This is an alternate implementation for updating the cached

     * SurfaceData from the source (primary) SurfaceData using a

     * background color for transparent pixels.

     * A simple BlitBg is used to copy the pixels from the source to

     * the destination SurfaceData with the specified bgColor.

     * A subclass can override the normal updateSurfaceData method

     * and call this implementation instead if it wants to use color

     * keying for bitmask images.

     */

    public void updateSurfaceDataBg(SurfaceData srcData,

                                    SurfaceData dstData,

                                    int w, int h, Color bgColor)

    {

        SurfaceType srcType = srcData.getSurfaceType();

        SurfaceType dstType = dstData.getSurfaceType();

        BlitBg blitbg = BlitBg.getFromCache(srcType,

                                            CompositeType.SrcNoEa,

                                            dstType);

        blitbg.BlitBg(srcData, dstData,

                      AlphaComposite.Src, null, bgColor.getRGB(),

                      0, 0, 0, 0, w, h);

        dstData.markDirty();

    }