/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.cocoon.components.midi.xmidi;
/**
* The MIDI file parsing parts of this class are based on code from the XMidi project, written
* by Peter Arthur Loeb (http://www.palserv.com/XMidi/) and used with permission.
* The warranty disclaimer of the MIT license (http://www.opensource.org/licenses/mit-license.html)
* applies to Peter Arthur Loeb's code.
*
* @author <a href="mailto:mark.leicester@energyintellect.com">Mark Leicester</a>
* @author <a href="mailto:peter@palserv.com">Peter Loeb</a>
*/
import org.apache.cocoon.ProcessingException;
public final class Utils
{
public static final String VERSION = "1.2";
/**
convert hex string to byte array
*/
static public byte[] hexToBa(String h, int len) throws ProcessingException
{
int l = h.length();
int cnt = 0;
int bs = 0;
int bc = 0;
byte[] ba = new byte[len];
for (int i = 0; i < l; i++)
{
String s = h.substring(i, i + 1);
int x = " \n\t\r".indexOf(s);
if (x != -1)
{
continue;
}
int tmp = "0123456789ABCDEF".indexOf(s.toUpperCase());
if (bc == 0)
{
bs = tmp;
}
else
if (bc == 1)
{
bs <<= 4;
bs |= tmp;
}
else
{
throw new ProcessingException("hexToBa: internal error");
}
bc++;
if (bc >= 2)
{
ba[cnt] = (byte) bs;
cnt++;
bc = 0;
}
}
if (bc != 0)
{
throw new ProcessingException("un-even number of hex digits");
}
if (cnt != len)
{
throw new ProcessingException(
"hexToBa: count (" + cnt + ") != length (" + len + ")");
}
return ba;
}
/**
convert byte array to string (not hex)
*/
public static String baToString(byte[] b, int strt, int end)
{
int l = end - strt + 1;
char[] c = new char[l];
for (int j = 0; j < l; j++)
{
c[j] = (char) b[j];
}
return new String(c);
}
/**
convert byte array to hex string
*/
public static String baToHex(byte[] b, int strt, int end)
throws ProcessingException
{
int l = end - strt + 1;
if (b.length < end)
{
throw new ProcessingException(
"baToHex: length error; b.length="
+ b.length
+ ", strt="
+ strt
+ ", end="
+ end
+ ", l="
+ l);
}
StringBuffer sb = new StringBuffer("");
for (int i = 0; i < l; i++)
{
int t = getUnsignedByte(b[strt + i]);
int a = t / 16;
int aa = t % 16;
sb.append("0123456789ABCDEF".substring(a, a + 1));
sb.append("0123456789ABCDEF".substring(aa, aa + 1));
}
return sb.toString();
}
/**
convert int to byte array of length c
*/
static public byte[] intToBa(int n, int c) throws ProcessingException
{
byte[] b = new byte[c];
int t = n;
for (int i = 0; i < c; i++)
{
int j = c - i - 1;
int k = t % 256;
b[j] = (byte) k;
t /= 256;
}
if (t > 0)
{
throw new ProcessingException(
"intToBa: t is " + t + ", n = " + n + ", c = " + c);
}
return b;
}
/**
convert byte array to int
*/
static public int baToInt(byte[] b, int strt, int end)
throws ProcessingException
{
if (end > b.length - 1)
{
throw new ProcessingException(
"baToInt: strt = "
+ strt
+ ", end = "
+ end
+ ", b.length = "
+ b.length);
}
int l = end - strt + 1;
int i = 0;
for (int j = 0; j < l; j++)
{
int p = strt + l - j - 1;
// get int value of unsigned byte into k
if (p > b.length - 1)
{
throw new ProcessingException(
"baToInt: p = "
+ p
+ ", strt = "
+ strt
+ ", end = "
+ end
+ ", l = "
+ l
+ ", j = "
+ j
+ ", i = "
+ i);
}
int k = getUnsignedByte(b[p]);
int n = pow(256, j);
i += n * k;
}
return i;
}
/**
convert byte (unsigned) to int
*/
static public int getUnsignedByte(byte b)
{
int t = 0;
if ((b & 128) == 128)
{
t = 1;
}
b &= 127;
int k = b;
k += t * 128;
return k;
}
/**
convert delta time to byte array
a delta time is expressed as a
byte array, length unknown (4 or less)
*/
static public ByteLen deltaToInt(byte[] b, int offset)
throws ProcessingException
{
/*
- capture up to four bytes including first with hi-ord
bit off
- turn off hi-ord bits
- accumulate 4 groups of 7 into 28 bit number with
hi-ord 4 bits zero.
*/
int j = 0;
byte[] ba = new byte[4];
boolean jFlag = true;
while (jFlag)
{
if ((j + offset) > b.length)
{
throw new ProcessingException(
"deltaToInt: length error; j = "
+ j
+ ", offset = "
+ offset
+ ", b.length = "
+ b.length);
}
ba[j] = b[j + offset];
if (ba[j] >= 0)
{
jFlag = false;
}
else
{
ba[j] &= 127;
}
/*this.getLogger().debug(
"deltaToInt: j = " + j + ", ba = " + baToInt(ba, 0, j));*/
j++;
}
int s = 0;
for (int i = 0; i < j; i++)
{
int k = j - i - 1;
int p = pow(128, i);
int m = ba[k];
s += m * p;
/*this.getLogger().debug(
"deltaToInt: in loop: s = "
+ s
+ ", i = "
+ i
+ ", j = "
+ j
+ ", k = "
+ k
+ ", p = "
+ p
+ ", m = "
+ m);*/
}
/*this.getLogger().debug("deltaToInt: s = " + s);*/
ByteLen bl = new ByteLen(intToBa(s, 4), j);
return bl;
}
/**
compute b to the e power (b ** e)
*/
static public int pow(int b, int e)
{
int a = 1;
for (int i = 0; i < e; i++)
{
a *= b;
}
return a;
}
public static int getPW(byte[] dta, int offset) throws ProcessingException
{
int hi = baToInt(dta, offset, offset);
int lo = baToInt(dta, offset + 1, offset + 1);
hi <<= 7;
lo |= hi;
return lo;
}
public static int getNextHiOrd(byte[] dta, int offset)
throws ProcessingException
{
int ol = 0;
boolean tflag = true;
for (int o = offset + 1; o < dta.length - 1; o++)
{
if (tflag)
{
int x = baToInt(dta, o, o);
if ((x & 128) == 128)
{
tflag = false;
ol = o;
}
}
}
if (tflag)
{
ol = offset + dta.length;
}
return ol;
}
/**
convert byte array to delta time
a delta time is expressed as a
byte array, length unknown (4 or less)
*/
public static byte[] intToDelta(byte[] t) throws ProcessingException
{
/*
from fullword binary value to variable (midi) value:
- split number into 5 bit groups of 4 7 7 7 7
- just deal with the four groups of 7 (ignore the 4)
- put each group of 7 into a byte
- case 1: whole full word is zero.
return one byte of zero.
- case 2: some non-zero bit (after first four bits)
- work from left to right
- throw away bytes which are zero until non-zero byte
encountered
- turn on hi-ord bit on all but last byte
*/
int i1 = baToInt(t, 0, t.length - 1);
//this.getLogger().debug("intToDelta: i1 = " + i1 + ", t = " + XMidiUtils.baToHex(t, 0, t.length - 1));
if (i1 == 0)
{
byte[] b = new byte[1];
b[0] = 0;
return b;
}
int i2 = i1;
byte[] b1 = new byte[4];
for (int i = 0; i < 4; i++)
{
int j = 4 - i - 1;
int k = i2 % 128;
i2 /= 128;
b1[j] = (byte) k;
}
int j = -1;
boolean bFlag = false;
for (int i = 0; i < 4; i++)
{
if (bFlag)
{
continue;
}
if (b1[i] != 0)
{
j = i;
bFlag = true;
}
}
int k = 4 - j;
byte[] b2 = new byte[k];
for (int i = 0; i < k; i++)
{
b2[i] = b1[i + j];
if (i != (k - 1))
{
b2[i] |= 128;
}
}
return b2;
}
public static int stringToInt(String s)
{
Integer i = new Integer(s);
int r = i.intValue();
return r;
}
}