/*

 * Copyright (c) 2003, 2007, 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 com.sun.media.sound;

import javax.sound.midi.*;

import java.util.ArrayList;

// TODO:

// - define and use a global symbolic constant for 60000000 (see convertTempo)

/**

 * Some utilities for MIDI (some stuff is used from javax.sound.midi)

 *

 * @author Florian Bomers

 */

public class MidiUtils {

    public final static int DEFAULT_TEMPO_MPQ = 500000; // 120bpm

    public final static int META_END_OF_TRACK_TYPE = 0x2F;

    public final static int META_TEMPO_TYPE = 0x51;

    /** return true if the passed message is Meta End Of Track */

    public static boolean isMetaEndOfTrack(MidiMessage midiMsg) {

        // first check if it is a META message at all

        if (midiMsg.getLength() != 3

            || midiMsg.getStatus() != MetaMessage.META) {

            return false;

        }

        // now get message and check for end of track

        byte[] msg = midiMsg.getMessage();

        return ((msg[1] & 0xFF) == META_END_OF_TRACK_TYPE) && (msg[2] == 0);

    }

    /** return if the given message is a meta tempo message */

    public static boolean isMetaTempo(MidiMessage midiMsg) {

        // first check if it is a META message at all

        if (midiMsg.getLength() != 6

            || midiMsg.getStatus() != MetaMessage.META) {

            return false;

        }

        // now get message and check for tempo

        byte[] msg = midiMsg.getMessage();

        // meta type must be 0x51, and data length must be 3

        return ((msg[1] & 0xFF) == META_TEMPO_TYPE) && (msg[2] == 3);

    }

    /** parses this message for a META tempo message and returns

     * the tempo in MPQ, or -1 if this isn't a tempo message

     */

    public static int getTempoMPQ(MidiMessage midiMsg) {

        // first check if it is a META message at all

        if (midiMsg.getLength() != 6

            || midiMsg.getStatus() != MetaMessage.META) {

            return -1;

        }

        byte[] msg = midiMsg.getMessage();

        if (((msg[1] & 0xFF) != META_TEMPO_TYPE) || (msg[2] != 3)) {

            return -1;

        }

        int tempo =    (msg[5] & 0xFF)

                    | ((msg[4] & 0xFF) << 8)

                    | ((msg[3] & 0xFF) << 16);

        return tempo;

    }

    /**

     * converts<br>

     * 1 - MPQ-Tempo to BPM tempo<br>

     * 2 - BPM tempo to MPQ tempo<br>

     */

    public static double convertTempo(double tempo) {

        if (tempo <= 0) {

            tempo = 1;

        }

        return ((double) 60000000l) / tempo;

    }

    /**

     * convert tick to microsecond with given tempo.

     * Does not take tempo changes into account.

     * Does not work for SMPTE timing!

     */

    public static long ticks2microsec(long tick, double tempoMPQ, int resolution) {

        return (long) (((double) tick) * tempoMPQ / resolution);

    }

    /**

     * convert tempo to microsecond with given tempo

     * Does not take tempo changes into account.

     * Does not work for SMPTE timing!

     */

    public static long microsec2ticks(long us, double tempoMPQ, int resolution) {

        // do not round to nearest tick

        //return (long) Math.round((((double)us) * resolution) / tempoMPQ);

        return (long) ((((double)us) * resolution) / tempoMPQ);

    }

    /**

     * Given a tick, convert to microsecond

     * @param cache tempo info and current tempo

     */

    public static long tick2microsecond(Sequence seq, long tick, TempoCache cache) {

        if (seq.getDivisionType() != Sequence.PPQ ) {

            double seconds = ((double)tick / (double)(seq.getDivisionType() * seq.getResolution()));

            return (long) (1000000 * seconds);

        }

        if (cache == null) {

            cache = new TempoCache(seq);

        }

        int resolution = seq.getResolution();

        long[] ticks = cache.ticks;

        int[] tempos = cache.tempos; // in MPQ

        int cacheCount = tempos.length;

        // optimization to not always go through entire list of tempo events

        int snapshotIndex = cache.snapshotIndex;

        int snapshotMicro = cache.snapshotMicro;

        // walk through all tempo changes and add time for the respective blocks

        long us = 0; // microsecond

        if (snapshotIndex <= 0

            || snapshotIndex >= cacheCount

            || ticks[snapshotIndex] > tick) {

            snapshotMicro = 0;

            snapshotIndex = 0;

        }

        if (cacheCount > 0) {

            // this implementation needs a tempo event at tick 0!

            int i = snapshotIndex + 1;

            while (i < cacheCount && ticks[i] <= tick) {

                snapshotMicro += ticks2microsec(ticks[i] - ticks[i - 1], tempos[i - 1], resolution);

                snapshotIndex = i;

                i++;

            }

            us = snapshotMicro

                + ticks2microsec(tick - ticks[snapshotIndex],

                                 tempos[snapshotIndex],

                                 resolution);

        }

        cache.snapshotIndex = snapshotIndex;

        cache.snapshotMicro = snapshotMicro;

        return us;

    }

    /**

     * Given a microsecond time, convert to tick.

     * returns tempo at the given time in cache.getCurrTempoMPQ

     */

    public static long microsecond2tick(Sequence seq, long micros, TempoCache cache) {

        if (seq.getDivisionType() != Sequence.PPQ ) {

            double dTick = ( ((double) micros)

                           * ((double) seq.getDivisionType())

                           * ((double) seq.getResolution()))

                           / ((double) 1000000);

            long tick = (long) dTick;

            if (cache != null) {

                cache.currTempo = (int) cache.getTempoMPQAt(tick);

            }

            return tick;

        }

        if (cache == null) {

            cache = new TempoCache(seq);

        }

        long[] ticks = cache.ticks;

        int[] tempos = cache.tempos; // in MPQ

        int cacheCount = tempos.length;

        int resolution = seq.getResolution();

        long us = 0; long tick = 0; int newReadPos = 0; int i = 1;

        // walk through all tempo changes and add time for the respective blocks

        // to find the right tick

        if (micros > 0 && cacheCount > 0) {

            // this loop requires that the first tempo Event is at time 0

            while (i < cacheCount) {

                long nextTime = us + ticks2microsec(ticks[i] - ticks[i - 1],

                                                    tempos[i - 1], resolution);

                if (nextTime > micros) {

                    break;

                }

                us = nextTime;

                i++;

            }

            tick = ticks[i - 1] + microsec2ticks(micros - us, tempos[i - 1], resolution);

            if (Printer.debug) Printer.debug("microsecond2tick(" + (micros / 1000)+") = "+tick+" ticks.");

            //if (Printer.debug) Printer.debug("   -> convert back = " + (tick2microsecond(seq, tick, null) / 1000)+" microseconds");

        }

        cache.currTempo = tempos[i - 1];

        return tick;

    }

    /**

     * Binary search for the event indexes of the track

     *

     * @param tick - tick number of index to be found in array

     * @return index in track which is on or after "tick".

     *   if no entries are found that follow after tick, track.size() is returned

     */

    public static int tick2index(Track track, long tick) {

        int ret = 0;

        if (tick > 0) {

            int low = 0;

            int high = track.size() - 1;

            while (low < high) {

                // take the middle event as estimate

                ret = (low + high) >> 1;

                // tick of estimate

                long t = track.get(ret).getTick();

                if (t == tick) {

                    break;

                } else if (t < tick) {

                    // estimate too low

                    if (low == high - 1) {

                        // "or after tick"

                        ret++;

                        break;

                    }

                    low = ret;

                } else { // if (t>tick)

                    // estimate too high

                    high = ret;

                }

            }

        }

        return ret;

    }

    public static class TempoCache {

        long[] ticks;

        int[] tempos; // in MPQ

        // index in ticks/tempos at the snapshot

        int snapshotIndex = 0;

        // microsecond at the snapshot

        int snapshotMicro = 0;

        int currTempo; // MPQ, used as return value for microsecond2tick

        private boolean firstTempoIsFake = false;

        public TempoCache() {

            // just some defaults, to prevents weird stuff

            ticks = new long[1];

            tempos = new int[1];

            tempos[0] = DEFAULT_TEMPO_MPQ;

            snapshotIndex = 0;

            snapshotMicro = 0;

        }

        public TempoCache(Sequence seq) {

            this();

            refresh(seq);

        }

        public synchronized void refresh(Sequence seq) {

            ArrayList list = new ArrayList();

            Track[] tracks = seq.getTracks();

            if (tracks.length > 0) {

                // tempo events only occur in track 0

                Track track = tracks[0];

                int c = track.size();

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

                    MidiEvent ev = track.get(i);

                    MidiMessage msg = ev.getMessage();

                    if (isMetaTempo(msg)) {

                        // found a tempo event. Add it to the list

                        list.add(ev);

                    }

                }

            }

            int size = list.size() + 1;

            firstTempoIsFake = true;

            if ((size > 1)

                && (((MidiEvent) list.get(0)).getTick() == 0)) {

                // do not need to add an initial tempo event at the beginning

                size--;

                firstTempoIsFake = false;

            }

            ticks  = new long[size];

            tempos = new int[size];

            int e = 0;

            if (firstTempoIsFake) {

                // add tempo 120 at beginning

                ticks[0] = 0;

                tempos[0] = DEFAULT_TEMPO_MPQ;

                e++;

            }

            for (int i = 0; i < list.size(); i++, e++) {

                MidiEvent evt = (MidiEvent) list.get(i);

                ticks[e] = evt.getTick();

                tempos[e] = getTempoMPQ(evt.getMessage());

            }

            snapshotIndex = 0;

            snapshotMicro = 0;

        }

        public int getCurrTempoMPQ() {

            return currTempo;

        }

        float getTempoMPQAt(long tick) {

            return getTempoMPQAt(tick, -1.0f);

        }

        synchronized float getTempoMPQAt(long tick, float startTempoMPQ) {

            for (int i = 0; i < ticks.length; i++) {

                if (ticks[i] > tick) {

                    if (i > 0) i--;

                    if (startTempoMPQ > 0 && i == 0 && firstTempoIsFake) {

                        return startTempoMPQ;

                    }

                    return (float) tempos[i];

                }

            }

            return tempos[tempos.length - 1];

        }

    }

}