/*
* Copyright (C) 2010 Preston Lacey http://javaflacencoder.sourceforge.net/
* All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
package javaFlacEncoder;
/**
* This is a utility class that provides methods to both encode to and decode
* from the extended version of UTF8 used by the FLAC format. All functions
* should work with standard UTF8 as well, since this only extends it to handle
* larger input values.
*
* @author Preston Lacey
*/
public class UTF8Modified {
static final long oneByteLimit = (long)Math.pow(2, 7);
static final long twoByteLimit = (long)Math.pow(2, 11);
static final long threeByteLimit = (long)Math.pow(2, 16);
static final long fourByteLimit = (long)Math.pow(2, 21);
static final long fiveByteLimit = (long)Math.pow(2, 26);
static final long sixByteLimit = (long)Math.pow(2, 31);
static final long sevenByteLimit = (long)Math.pow(2, 36);
static long[] limits = {
oneByteLimit,
twoByteLimit,
threeByteLimit,
fourByteLimit,
fiveByteLimit,
sixByteLimit,
sevenByteLimit
};
/** For debugging: Higher value equals more output, generally by increments
* of 10 */
public static int DEBUG_LEV = 0;
/**
* Constructor. This Class provides only static methods and static fields.
*/
public UTF8Modified() {
}
/**
* Decode an extended UTF8(as used in FLAC), to a long value.
* @param input extended UTF8 encoded value.
* @return value represented by the UTF8 input.
*/
public static long decodeFromExtendedUTF8(byte[] input) {
int leadOnes = 0;
int leadMask = 128;
int work = input[0];
while((work & leadMask) > 0) {
leadOnes++;
work = work << 1;
}
int valMask = 255 >>> (leadOnes+1);
long val = input[0] & valMask;
for(int i = 1; i < leadOnes; i++) {
int midMask = 0x3F;
val = val << 6;
val = (input[i] & midMask) | val;
}
return val;
}
/**
* Convert a value to an extended UTF8 format(as used in FLAC).
* @param value value to convert to extended UTF8(value must be positive
* and 36 bits or less in size)
* @return extended UTF8 encoded value(array size is equal to the number of
* usable bytes)
*/
public static byte[] convertToExtendedUTF8(long value) {
//calculate bytes needed
int bytesNeeded = 1;
for(int i = 0; i < 7; i++) {
if(value >= limits[i] ) {
bytesNeeded++;
}
}
//create space
byte [] result = new byte[bytesNeeded];
int byteIndex = 0;
int inputIndex = 0;
int bytesLeft = bytesNeeded;
while(bytesLeft > 1) {
int midByteMarker = 0x80;//10 in leftmost bits
int midByteMask = 0x3F;//00111111
int val = ((int)(value >>> inputIndex) & midByteMask) | midByteMarker;
result[byteIndex++] = (byte)val;
inputIndex += 6;
bytesLeft--;
}
int onesNeeded = inputIndex/6;
if(onesNeeded > 0)
onesNeeded++;
int startMask = 255 >>> (onesNeeded + 1);
int ones = 255 << (8-onesNeeded);
int val = ((int)(value >>> inputIndex) & startMask) | ones;
result[byteIndex++] = (byte)val;
byte[] finalResult = new byte[bytesNeeded];
for(int i = 0; i < bytesNeeded; i++) {
int sourceIndex = bytesNeeded-1-i;
int destIndex = i;
finalResult[destIndex] = result[sourceIndex];
}
if(DEBUG_LEV > 10) {
System.err.print("input:result_length:result :: " +value+":"+finalResult.length+"::");
for(int i = 0; i < finalResult.length; i++)
System.err.print(Integer.toHexString(finalResult[i])+":");
System.err.println();
}
return finalResult;
}
}