From 493cd1a1e4ae341bd733ad02be37d0cfae11e419 Mon Sep 17 00:00:00 2001 From: Martin Lehmann Date: Wed, 21 Apr 2021 15:30:58 +0200 Subject: [PATCH 1/4] ARM-optimized implementation of VorbisCodec. Cannot be used yet due lack of configurable codecs. --- librespot-android-decoder-tremolo/.gitignore | 1 + .../build.gradle | 54 + .../consumer-rules.pro | 3 + .../proguard-rules.pro | 25 + .../src/main/.gitignore | 1 + .../src/main/AndroidManifest.xml | 5 + .../player/codecs/TremoloVorbisCodec.java | 101 + .../tremolo/OggDecodingInputStream.java | 233 ++ .../codecs/tremolo/SeekableInputStream.java | 20 + .../src/main/jni/Android.mk | 1 + .../src/main/jni/Application.mk | 4 + .../src/main/jni/libtremolo/Android.mk | 43 + .../src/main/jni/libtremolo/asm_arm.h | 265 +++ .../src/main/jni/libtremolo/bitwise.c | 871 +++++++ .../src/main/jni/libtremolo/bitwiseARM.s | 399 ++++ .../src/main/jni/libtremolo/codebook.c | 920 +++++++ .../src/main/jni/libtremolo/codebook.h | 89 + .../src/main/jni/libtremolo/codec_internal.h | 235 ++ .../src/main/jni/libtremolo/config_types.h | 47 + .../src/main/jni/libtremolo/dpen.s | 498 ++++ .../src/main/jni/libtremolo/dsp.c | 326 +++ .../src/main/jni/libtremolo/floor0.c | 448 ++++ .../src/main/jni/libtremolo/floor1.c | 407 ++++ .../src/main/jni/libtremolo/floor1ARM.s | 67 + .../src/main/jni/libtremolo/floor_lookup.c | 112 + .../src/main/jni/libtremolo/framing.c | 1169 +++++++++ .../src/main/jni/libtremolo/hide.c | 97 + .../src/main/jni/libtremolo/hide.h | 7 + .../src/main/jni/libtremolo/ivorbiscodec.h | 124 + .../src/main/jni/libtremolo/ivorbisfile.h | 142 ++ .../src/main/jni/libtremolo/lsp_lookup.h | 128 + .../src/main/jni/libtremolo/mapping0.c | 261 ++ .../src/main/jni/libtremolo/md5.c | 329 +++ .../src/main/jni/libtremolo/md5.h | 29 + .../src/main/jni/libtremolo/mdct.c | 582 +++++ .../src/main/jni/libtremolo/mdct.h | 79 + .../src/main/jni/libtremolo/mdctARM.s | 1234 ++++++++++ .../src/main/jni/libtremolo/mdct_lookup.h | 559 +++++ .../src/main/jni/libtremolo/misc.c | 229 ++ .../src/main/jni/libtremolo/misc.h | 213 ++ .../src/main/jni/libtremolo/ogg.h | 242 ++ .../src/main/jni/libtremolo/os.h | 82 + .../src/main/jni/libtremolo/os_types.h | 124 + .../src/main/jni/libtremolo/res012.c | 268 +++ .../src/main/jni/libtremolo/treminfo.c | 395 +++ .../src/main/jni/libtremolo/tremolo-jni.c | 173 ++ .../src/main/jni/libtremolo/vorbisfile.c | 1612 +++++++++++++ .../src/main/jni/libtremolo/window_lookup.h | 2107 +++++++++++++++++ .../src/main/libs/arm64-v8a/libtremolo.so | Bin 0 -> 109312 bytes .../src/main/libs/armeabi-v7a/libtremolo.so | Bin 0 -> 121468 bytes settings.gradle | 1 + 51 files changed, 15361 insertions(+) create mode 100644 librespot-android-decoder-tremolo/.gitignore create mode 100644 librespot-android-decoder-tremolo/build.gradle create mode 100644 librespot-android-decoder-tremolo/consumer-rules.pro create mode 100644 librespot-android-decoder-tremolo/proguard-rules.pro create mode 100644 librespot-android-decoder-tremolo/src/main/.gitignore create mode 100644 librespot-android-decoder-tremolo/src/main/AndroidManifest.xml create mode 100644 librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java create mode 100644 librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java create mode 100644 librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/SeekableInputStream.java create mode 100644 librespot-android-decoder-tremolo/src/main/jni/Android.mk create mode 100644 librespot-android-decoder-tremolo/src/main/jni/Application.mk create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/Android.mk create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/asm_arm.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/bitwise.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/bitwiseARM.s create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/codebook.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/codebook.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/codec_internal.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/config_types.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/dpen.s create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/dsp.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor0.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor1.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor1ARM.s create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor_lookup.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/framing.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/hide.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/hide.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/ivorbiscodec.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/ivorbisfile.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/lsp_lookup.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/mapping0.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/md5.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/md5.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdctARM.s create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct_lookup.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/misc.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/misc.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/ogg.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/os.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/os_types.h create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/res012.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/treminfo.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/vorbisfile.c create mode 100644 librespot-android-decoder-tremolo/src/main/jni/libtremolo/window_lookup.h create mode 100644 librespot-android-decoder-tremolo/src/main/libs/arm64-v8a/libtremolo.so create mode 100644 librespot-android-decoder-tremolo/src/main/libs/armeabi-v7a/libtremolo.so diff --git a/librespot-android-decoder-tremolo/.gitignore b/librespot-android-decoder-tremolo/.gitignore new file mode 100644 index 0000000..42afabf --- /dev/null +++ b/librespot-android-decoder-tremolo/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/build.gradle b/librespot-android-decoder-tremolo/build.gradle new file mode 100644 index 0000000..54446ec --- /dev/null +++ b/librespot-android-decoder-tremolo/build.gradle @@ -0,0 +1,54 @@ +plugins { + id 'com.android.library' +} + +android { + compileSdkVersion 30 + buildToolsVersion "30.0.3" + + defaultConfig { + minSdkVersion 23 + targetSdkVersion 30 + versionCode 1 + versionName "1.0" + + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + consumerProguardFiles "consumer-rules.pro" + + // TODO use modern way to build native library + sourceSets.main { + jniLibs.srcDir 'src/main/libs' + jni.srcDirs = [] //disable automatic ndk-build call + } + + // call regular ndk-build(.cmd) script from app directory + task ndkBuild(type: Exec) { + commandLine 'ndk-build.cmd', '-C', file('src/main').absolutePath + } + + tasks.withType(JavaCompile) { + compileTask -> compileTask.dependsOn ndkBuild + } + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } +} + +dependencies { + // TODO fix dependencies + implementation('xyz.gianlu.librespot:librespot-player:1.5.6-SNAPSHOT:thin') { + exclude group: 'xyz.gianlu.librespot', module: 'librespot-sink' + exclude group: 'org.apache.logging.log4j', module: 'log4j-core' + exclude group: 'org.apache.logging.log4j', module: 'log4j-slf4j-impl' + exclude group: 'com.lmax', module: 'disruptor' + } +} \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/consumer-rules.pro b/librespot-android-decoder-tremolo/consumer-rules.pro new file mode 100644 index 0000000..fcaead7 --- /dev/null +++ b/librespot-android-decoder-tremolo/consumer-rules.pro @@ -0,0 +1,3 @@ +-keepclassmembers class xyz.gianlu.librespot.player.codecs.tremolo.OggDecodingInputStream { + *; +} \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/proguard-rules.pro b/librespot-android-decoder-tremolo/proguard-rules.pro new file mode 100644 index 0000000..a9fcfcc --- /dev/null +++ b/librespot-android-decoder-tremolo/proguard-rules.pro @@ -0,0 +1,25 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile + +-keepclassmembers class xyz.gianlu.librespot.player.codecs.tremolo.OggDecodingInputStream { + *; +} \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/.gitignore b/librespot-android-decoder-tremolo/src/main/.gitignore new file mode 100644 index 0000000..b672fde --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/.gitignore @@ -0,0 +1 @@ +obj diff --git a/librespot-android-decoder-tremolo/src/main/AndroidManifest.xml b/librespot-android-decoder-tremolo/src/main/AndroidManifest.xml new file mode 100644 index 0000000..eed54d3 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/AndroidManifest.xml @@ -0,0 +1,5 @@ + + + + \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java new file mode 100644 index 0000000..7a333d5 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java @@ -0,0 +1,101 @@ +package xyz.gianlu.librespot.player.codecs; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.io.IOException; +import java.io.OutputStream; + +import xyz.gianlu.librespot.audio.GeneralAudioStream; +import xyz.gianlu.librespot.audio.NormalizationData; +import xyz.gianlu.librespot.player.PlayerConfiguration; +import xyz.gianlu.librespot.player.codecs.tremolo.OggDecodingInputStream; +import xyz.gianlu.librespot.player.codecs.tremolo.SeekableInputStream; +import xyz.gianlu.librespot.player.mixing.output.OutputAudioFormat; + +public class TremoloVorbisCodec extends Codec { + private final byte[] buffer = new byte[2 * BUFFER_SIZE]; + + private OggDecodingInputStream inputStream; + + public TremoloVorbisCodec(@NotNull GeneralAudioStream audioFile, @Nullable NormalizationData normalizationData, @NotNull PlayerConfiguration conf, int duration) throws IOException { + super(audioFile, normalizationData, conf, duration); + + seekZero = audioIn.pos(); + + inputStream = new OggDecodingInputStream(new SeekableInputStream() { + @Override + public void seek(long positionBytes) throws IOException { + audioFile.stream().seek((int) (positionBytes + seekZero)); + } + + @Override + public long tell() { + return audioFile.stream().pos() - seekZero; + } + + @Override + public long length() { + return (audioFile.stream().available() + audioFile.stream().pos()) - seekZero; + } + + @Override + public int read(byte[] bytes) throws IOException { + return audioFile.stream().read(bytes); + } + + @Override + public void close() { + audioFile.stream().close(); + } + + @Override + public int read() throws IOException { + return audioFile.stream().read(); + } + }); + + setAudioFormat(new OutputAudioFormat(44100, 16, 2, true, false)); + } + + @Override + protected synchronized int readInternal(@NotNull OutputStream outputStream) throws IOException { + if (closed) return -1; + + int count = inputStream.read(buffer); + if (count == -1) return -1; + try { + outputStream.write(buffer, 0, count); + outputStream.flush(); + } catch (IllegalStateException e) { + // TODO logging + } + return count; + } + + @Override + public int time() throws CannotGetTimeException { + try { + return (int) inputStream.tellMs(); + } catch (Exception e) { + throw new CannotGetTimeException(); + } + } + + @Override + public void close() throws IOException { + if (inputStream != null) { + inputStream.close(); + } + super.close(); + } + + @Override + public /*synchronized*/ void seek(int positionMs) { + try { + inputStream.seekMs(positionMs); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java new file mode 100644 index 0000000..db326eb --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java @@ -0,0 +1,233 @@ +package xyz.gianlu.librespot.player.codecs.tremolo; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.util.concurrent.atomic.AtomicBoolean; + +/** + * Created by M. Lehmann on 15.11.2016. + */ +@SuppressWarnings("unused") +public class OggDecodingInputStream extends InputStream { + + private static final int BUFFER_SIZE = 4096; + private static final int SEEK_SET = 0; + private static final int SEEK_CUR = 1; + private static final int SEEK_END = 2; + + static { + System.loadLibrary("tremolo"); + } + + /** + * address of native OggFileHandle structure + **/ + private final long handle; + + private final SeekableInputStream oggInputStream; + private final ByteBuffer jniBuffer; + private final AtomicBoolean isClosed = new AtomicBoolean(false); + + public boolean isClosed() { + return isClosed.get(); + } + + public OggDecodingInputStream(SeekableInputStream oggInputStream) throws IOException { + this.oggInputStream = oggInputStream; + + jniBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE); + + handle = initDecoder(jniBuffer); + if (handle == 0) { + throw new IOException("Couldn't start decoder!"); + } + } + + private native long initDecoder(ByteBuffer jniBuffer); + + private int writeOgg(int size) { + byte[] bytes = new byte[Math.min(size, BUFFER_SIZE)]; + try { + int read = oggInputStream.read(bytes); + if (read > -1) { + jniBuffer.put(bytes); + jniBuffer.flip(); + return read; + } + return 0; + } catch (Exception e) { + // TODO logging + } + return -1; + } + + private int seekOgg(long offset, int whence) { + try { + if (whence == SEEK_SET) { + oggInputStream.seek(offset); + } else if (whence == SEEK_CUR) { + oggInputStream.seek(oggInputStream.tell() + offset); + } else if (whence == SEEK_END) { + oggInputStream.seek(oggInputStream.length() + offset); + } + return 0; + } catch (Exception e) { + // TODO logging + } + return -1; + } + + private int tellOgg() { + try { + return (int) oggInputStream.tell(); + } catch (Exception e) { + // TODO logging + } + return -1; + } + + private native int read(long handle, int len); + + private native int seekMs(long handle, int milliseconds); + + private native int seekSamples(long handle, int samples); + + private native long tellMs(long handle); + + private native long tellSamples(long handle); + + private native long totalSamples(long handle); + + @Override + public int read() throws IOException { + synchronized (isClosed) { + if (isClosed.get()) { + throw new IOException("OggDecodingInputStream already closed!"); + } + jniBuffer.clear(); + int size = read(handle, 1); + + jniBuffer.limit(size); + } + final byte b = jniBuffer.get(); + jniBuffer.clear(); + + return b; + } + + @Override + public synchronized int read(byte[] b, int off, int len) throws IOException { + synchronized (isClosed) { + if (isClosed.get()) { + throw new IOException("read: OggDecodingInputStream already closed!"); + } + + len = Math.min(len, BUFFER_SIZE); + jniBuffer.clear(); + int size = read(handle, len); + if (size > 0) { + jniBuffer.limit(size); + jniBuffer.get(b, off, size); + jniBuffer.clear(); + return size; + } + } + return -1; + } + + @Override + public synchronized int read(byte[] b) throws IOException { + synchronized (isClosed) { + if (isClosed.get()) { + throw new IOException("OggDecodingInputStream already closed!"); + } + return this.read(b, 0, b.length); + } + } + + public synchronized int seekMs(int milliseconds) throws IOException { + synchronized (isClosed) { + if (isClosed.get()) { + throw new IOException("seekMs: OggDecodingInputStream already closed!"); + } + return seekMs(handle, milliseconds); + } + } + + public synchronized int seekSamples(int samples) throws IOException { + synchronized (isClosed) { + if (isClosed.get()) { + throw new IOException("seekSamples: OggDecodingInputStream already closed!"); + } + return seekSamples(handle, samples); + } + } + + public synchronized long tellMs() throws IOException { + synchronized (isClosed) { + if (isClosed.get()) { + throw new IOException("tellMs: OggDecodingInputStream already closed!"); + } + return tellMs(handle); + } + } + + public synchronized long tellSamples() throws IOException { + synchronized (isClosed) { + if (isClosed.get()) { + throw new IOException("tellSamples: OggDecodingInputStream already closed!"); + } + return tellSamples(handle); + } + } + + public synchronized long totalSamples() throws IOException { + synchronized (isClosed) { + if (isClosed.get()) { + throw new IOException("totalSamples: OggDecodingInputStream already closed!"); + } + return totalSamples(handle); + } + } + + @Override + public void close() throws IOException { + if (!isClosed.getAndSet(true)) { + synchronized (isClosed) { + close(handle); + try { + oggInputStream.close(); + } catch (IOException ignored) { + } + } + super.close(); + } else { + // TODO logging + } + } + + public synchronized long seek(long bytes) throws IOException { + final int samples = (int) (bytes / ((16 * 2) / 8)); + + final int success = seekSamples(samples); + if (success == 0) { + return getSamplesToBytes(tellSamples(), 16, 2); + } + + throw new IOException("seek: Failed to seekSamples!"); + } + + private long getSamplesToBytes(long samples, int bits, int channels) { + return (samples * bits * channels) / 8; + } + + private int getBytesToMilliSeconds(long bytes, int bits, int channels) { + long bytesPerSecond = (bits * 44100 * channels) / 8; + long seconds = bytes / bytesPerSecond; + + return (int) (seconds * 1000); + } + + private native void close(long handle); +} diff --git a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/SeekableInputStream.java b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/SeekableInputStream.java new file mode 100644 index 0000000..a58bb9b --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/SeekableInputStream.java @@ -0,0 +1,20 @@ +package xyz.gianlu.librespot.player.codecs.tremolo; + +import java.io.IOException; +import java.io.InputStream; + +/** + * Created by M. Lehmann on 08.12.2016. + */ +public abstract class SeekableInputStream extends InputStream { + + abstract public void seek(long positionBytes) throws IOException; + + abstract public long tell() throws IOException; + + abstract public long length() throws IOException; + + abstract public int read(byte[] bytes) throws IOException; + + abstract public void close() throws IOException; +} diff --git a/librespot-android-decoder-tremolo/src/main/jni/Android.mk b/librespot-android-decoder-tremolo/src/main/jni/Android.mk new file mode 100644 index 0000000..1a6f8ed --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/Android.mk @@ -0,0 +1 @@ +include $(wildcard $(call my-dir)/*/Android.mk) \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/jni/Application.mk b/librespot-android-decoder-tremolo/src/main/jni/Application.mk new file mode 100644 index 0000000..74534e8 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/Application.mk @@ -0,0 +1,4 @@ +APP_PLATFORM := android-14 # proven to work +# TODO: libtremolo _might_ work on x86-devices, you might test it.# +# Otherwise you have to either exclude others or use jorbis for them +APP_ABI := armeabi-v7a arm64-v8a \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/Android.mk b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/Android.mk new file mode 100644 index 0000000..21900b9 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/Android.mk @@ -0,0 +1,43 @@ +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE := tremolo + +LOCAL_SRC_FILES := bitwise.c \ + codebook.c \ + dsp.c \ + floor0.c \ + floor1.c \ + floor_lookup.c \ + framing.c \ + mapping0.c \ + mdct.c \ + misc.c \ + res012.c \ + treminfo.c \ + vorbisfile.c \ + hide.c \ + tremolo-jni.c \ + md5.c + +ifeq ($(TARGET_ARCH),arm) + LOCAL_ARM_MODE := arm + LOCAL_SRC_FILES += bitwiseARM.s \ + dpen.s \ + floor1ARM.s \ + mdctARM.s +endif + +LOCAL_LDFLAGS += -Wl,--gc-sections + +LOCAL_CFLAGS := -ffast-math -O3 -fvisibility=hidden -ffunction-sections -fdata-sections + +ifeq ($(TARGET_ARCH),arm) + LOCAL_CFLAGS += -D_ARM_ASSEM_ +else + LOCAL_CFLAGS += -DONLY_C +endif + +LOCAL_C_INCLUDES:= $(LOCAL_PATH) + +include $(BUILD_SHARED_LIBRARY) \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/asm_arm.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/asm_arm.h new file mode 100644 index 0000000..6303b87 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/asm_arm.h @@ -0,0 +1,265 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: arm7 and later wide math functions + + ************************************************************************/ + +#ifdef _ARM_ASSEM_ + +#if !defined(_V_WIDE_MATH) && !defined(_LOW_ACCURACY_) +#define _V_WIDE_MATH + +static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { + int lo,hi; + asm volatile("smull\t%0, %1, %2, %3" + : "=&r"(lo),"=&r"(hi) + : "%r"(x),"r"(y) + : "cc"); + return(hi); +} + +static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { + return MULT32(x,y)<<1; +} + +static inline ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { + int lo,hi; + asm volatile("smull %0, %1, %2, %3\n\t" + "movs %0, %0, lsr #15\n\t" + "adc %1, %0, %1, lsl #17\n\t" + : "=&r"(lo),"=&r"(hi) + : "%r"(x),"r"(y) + : "cc"); + return(hi); +} + +#define MB() asm volatile ("" : : : "memory") + +static inline void XPROD32(ogg_int32_t a, ogg_int32_t b, + ogg_int32_t t, ogg_int32_t v, + ogg_int32_t *x, ogg_int32_t *y) +{ + int x1, y1, l; + asm( "smull %0, %1, %4, %6\n\t" + "smlal %0, %1, %5, %7\n\t" + "rsb %3, %4, #0\n\t" + "smull %0, %2, %5, %6\n\t" + "smlal %0, %2, %3, %7" + : "=&r" (l), "=&r" (x1), "=&r" (y1), "=r" (a) + : "3" (a), "r" (b), "r" (t), "r" (v) + : "cc" ); + *x = x1; + MB(); + *y = y1; +} + +/* x = (a*t + b*v)>>31, y = (b*t - a*v)>>31 */ +static inline void XPROD31(ogg_int32_t a, ogg_int32_t b, + ogg_int32_t t, ogg_int32_t v, + ogg_int32_t *x, ogg_int32_t *y) +{ + int x1, y1, l; + asm( "smull %0, %1, %4, %6\n\t" + "smlal %0, %1, %5, %7\n\t" + "rsb %3, %4, #0\n\t" + "smull %0, %2, %5, %6\n\t" + "smlal %0, %2, %3, %7" + : "=&r" (l), "=&r" (x1), "=&r" (y1), "=r" (a) + : "3" (a), "r" (b), "r" (t), "r" (v) + : "cc" ); + *x = x1 << 1; + MB(); + *y = y1 << 1; +} + +/* x = (a*t - b*v)>>31, y = (b*t + a*v)>>31 */ +static inline void XNPROD31(ogg_int32_t a, ogg_int32_t b, + ogg_int32_t t, ogg_int32_t v, + ogg_int32_t *x, ogg_int32_t *y) +{ + int x1, y1, l; + asm( "rsb %2, %4, #0\n\t" + "smull %0, %1, %3, %5\n\t" + "smlal %0, %1, %2, %6\n\t" + "smull %0, %2, %4, %5\n\t" + "smlal %0, %2, %3, %6" + : "=&r" (l), "=&r" (x1), "=&r" (y1) + : "r" (a), "r" (b), "r" (t), "r" (v) + : "cc" ); + *x = x1 << 1; + MB(); + *y = y1 << 1; +} + +#endif + +#ifndef _V_CLIP_MATH +#define _V_CLIP_MATH + +static inline ogg_int32_t CLIP_TO_15(ogg_int32_t x) { + int tmp; + asm volatile("subs %1, %0, #32768\n\t" + "movpl %0, #0x7f00\n\t" + "orrpl %0, %0, #0xff\n" + "adds %1, %0, #32768\n\t" + "movmi %0, #0x8000" + : "+r"(x),"=r"(tmp) + : + : "cc"); + return(x); +} + +#endif + +#ifndef _V_LSP_MATH_ASM +#define _V_LSP_MATH_ASM + +static inline void lsp_loop_asm(ogg_uint32_t *qip,ogg_uint32_t *pip, + ogg_int32_t *qexpp, + ogg_int32_t *ilsp,ogg_int32_t wi, + ogg_int32_t m){ + + ogg_uint32_t qi=*qip,pi=*pip; + ogg_int32_t qexp=*qexpp; + + asm("mov r0,%3;" + "mov r1,%5,asr#1;" + "add r0,r0,r1,lsl#3;" + "1:" + + "ldmdb r0!,{r1,r3};" + "subs r1,r1,%4;" //ilsp[j]-wi + "rsbmi r1,r1,#0;" //labs(ilsp[j]-wi) + "umull %0,r2,r1,%0;" //qi*=labs(ilsp[j]-wi) + + "subs r1,r3,%4;" //ilsp[j+1]-wi + "rsbmi r1,r1,#0;" //labs(ilsp[j+1]-wi) + "umull %1,r3,r1,%1;" //pi*=labs(ilsp[j+1]-wi) + + "cmn r2,r3;" // shift down 16? + "beq 0f;" + "add %2,%2,#16;" + "mov %0,%0,lsr #16;" + "orr %0,%0,r2,lsl #16;" + "mov %1,%1,lsr #16;" + "orr %1,%1,r3,lsl #16;" + "0:" + "cmp r0,%3;\n" + "bhi 1b;\n" + + // odd filter assymetry + "ands r0,%5,#1;\n" + "beq 2f;\n" + "add r0,%3,%5,lsl#2;\n" + + "ldr r1,[r0,#-4];\n" + "mov r0,#0x4000;\n" + + "subs r1,r1,%4;\n" //ilsp[j]-wi + "rsbmi r1,r1,#0;\n" //labs(ilsp[j]-wi) + "umull %0,r2,r1,%0;\n" //qi*=labs(ilsp[j]-wi) + "umull %1,r3,r0,%1;\n" //pi*=labs(ilsp[j+1]-wi) + + "cmn r2,r3;\n" // shift down 16? + "beq 2f;\n" + "add %2,%2,#16;\n" + "mov %0,%0,lsr #16;\n" + "orr %0,%0,r2,lsl #16;\n" + "mov %1,%1,lsr #16;\n" + "orr %1,%1,r3,lsl #16;\n" + + //qi=(pi>>shift)*labs(ilsp[j]-wi); + //pi=(qi>>shift)*labs(ilsp[j+1]-wi); + //qexp+=shift; + + //} + + /* normalize to max 16 sig figs */ + "2:" + "mov r2,#0;" + "orr r1,%0,%1;" + "tst r1,#0xff000000;" + "addne r2,r2,#8;" + "movne r1,r1,lsr #8;" + "tst r1,#0x00f00000;" + "addne r2,r2,#4;" + "movne r1,r1,lsr #4;" + "tst r1,#0x000c0000;" + "addne r2,r2,#2;" + "movne r1,r1,lsr #2;" + "tst r1,#0x00020000;" + "addne r2,r2,#1;" + "movne r1,r1,lsr #1;" + "tst r1,#0x00010000;" + "addne r2,r2,#1;" + "mov %0,%0,lsr r2;" + "mov %1,%1,lsr r2;" + "add %2,%2,r2;" + + : "+r"(qi),"+r"(pi),"+r"(qexp) + : "r"(ilsp),"r"(wi),"r"(m) + : "r0","r1","r2","r3","cc"); + + *qip=qi; + *pip=pi; + *qexpp=qexp; +} + +static inline void lsp_norm_asm(ogg_uint32_t *qip,ogg_int32_t *qexpp){ + + ogg_uint32_t qi=*qip; + ogg_int32_t qexp=*qexpp; + + asm("tst %0,#0x0000ff00;" + "moveq %0,%0,lsl #8;" + "subeq %1,%1,#8;" + "tst %0,#0x0000f000;" + "moveq %0,%0,lsl #4;" + "subeq %1,%1,#4;" + "tst %0,#0x0000c000;" + "moveq %0,%0,lsl #2;" + "subeq %1,%1,#2;" + "tst %0,#0x00008000;" + "moveq %0,%0,lsl #1;" + "subeq %1,%1,#1;" + : "+r"(qi),"+r"(qexp) + : + : "cc"); + *qip=qi; + *qexpp=qexp; +} + +#endif +#endif + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/bitwise.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/bitwise.c new file mode 100644 index 0000000..c991ca1 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/bitwise.c @@ -0,0 +1,871 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: packing variable sized words into an octet stream + + ************************************************************************/ + +/* We're 'LSb' endian; if we write a word but read individual bits, + then we'll read the lsb first */ + +#include +#include +#include "misc.h" +#include "ogg.h" + +#include + + +#if !defined(ARM_LITTLE_ENDIAN) || defined(_V_BIT_TEST) +static unsigned long mask[]= +{0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f, + 0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff, + 0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff, + 0x00007fff,0x0000ffff,0x0001ffff,0x0003ffff,0x0007ffff, + 0x000fffff,0x001fffff,0x003fffff,0x007fffff,0x00ffffff, + 0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff, + 0x3fffffff,0x7fffffff,0xffffffff }; +#endif + +#ifdef ARM_LITTLE_ENDIAN + +#ifdef DEBUGGING_BITWISE +extern void oggpack_readinitARM(oggpack_buffer *b,ogg_reference *r); + +void oggpack_readinit(oggpack_buffer *b,ogg_reference *r){ + oggpack_readinitARM(b,r); + //fprintf(stderr, "Init: buffer=(%d,%x,%d,%d) %08x%08x\n", + // b->bitsLeftInSegment, b->ptr, b->bitsLeftInWord, b->count, + // b->ptr[1], b->ptr[0]); + //fflush(stderr); +} + +extern long oggpack_lookARM(oggpack_buffer *b,int bits); + +long oggpack_look(oggpack_buffer *b,int bits){ + long l; + + //fprintf(stderr, "PreLook: buffer=(%x,%x,%x) %08x%08x (%d bits)\n", + // b->bitsLeftInSegment, b->ptr, b->bitsLeftInWord, + // b->ptr[1], b->ptr[0], bits); + //fflush(stderr); + l = oggpack_lookARM(b,bits); + //fprintf(stderr, "Look: buffer=(%d,%x,%d,%d) %08x%08x (%d bits) (result=%x)\n", + // b->bitsLeftInSegment, b->ptr, b->bitsLeftInWord, b->count, + // b->ptr[1], b->ptr[0], bits, l); + //fflush(stderr); + + return l; +} + +extern void oggpack_advARM(oggpack_buffer *b,int bits); + +void oggpack_adv(oggpack_buffer *b,int bits){ + //fprintf(stderr, "Adv before: buffer=(%x,%x,%x) %08x%08x (%d bits)\n", + // b->bitsLeftInSegment, b->ptr, b->bitsLeftInWord, + // b->ptr[1], b->ptr[0],bits); + //fflush(stderr); + oggpack_advARM(b,bits); + //fprintf(stderr, "Adv: buffer=(%d,%x,%d,%d) %08x%08x\n", + // b->bitsLeftInSegment, b->ptr, b->bitsLeftInWord, b->count, + // b->ptr[1], b->ptr[0]); + //fflush(stderr); +} + +extern long oggpack_readARM(oggpack_buffer *b,int bits); + +/* bits <= 32 */ +long oggpack_read(oggpack_buffer *b,int bits){ + long l; + + //fprintf(stderr, "PreRead: buffer=(%d,%x,%d,%d) %08x%08x (%d bits)\n", + // b->bitsLeftInSegment, b->ptr, b->bitsLeftInWord, b->count, + // b->ptr[1], b->ptr[0], bits); + //fflush(stderr); + l = oggpack_readARM(b,bits); + //fprintf(stderr, "Read: buffer=(%d,%x,%d,%d) %08x%08x (%d bits) (result=%x)\n", + // b->bitsLeftInSegment, b->ptr, b->bitsLeftInWord, b->count, + // b->ptr[1], b->ptr[0], bits, l); + //fflush(stderr); + + return l; +} +#endif + +int oggpack_eop(oggpack_buffer *b){ + int ret; + if(b->bitsLeftInSegment<0)ret= -1; + else ret = 0; + //fprintf(stderr, "EOP %d\n", ret); + //fflush(stderr); + return ret; +} + +long oggpack_bytes(oggpack_buffer *b){ + long ret; + if(b->bitsLeftInSegment<0) ret = b->count+b->head->length; + else ret = b->count + b->head->length - (b->bitsLeftInSegment)/8; + //fprintf(stderr, "count=%d length=%d bitsLeftInSegment=%d\n", + // b->count, b->head->length, b->bitsLeftInSegment); + //fflush(stderr); + return ret; +} + +long oggpack_bits(oggpack_buffer *b){ + long ret; + if(b->bitsLeftInSegment<0) ret=(b->count+b->head->length)*8; + else ret = b->count*8 + b->head->length*8 - b->bitsLeftInSegment; + //fprintf(stderr, "count=%d length=%d bitsLeftInSegment=%d\n", + // b->count, b->head->length, b->bitsLeftInSegment); + //fflush(stderr); + return ret; +} + +#else + +/* spans forward, skipping as many bytes as headend is negative; if + headend is zero, simply finds next byte. If we're up to the end + of the buffer, leaves headend at zero. If we've read past the end, + halt the decode process. */ + +static void _span(oggpack_buffer *b){ + while(b->headend-(b->headbit>>3)<1){ + b->headend-=b->headbit>>3; + b->headbit&=0x7; + + if(b->head && b->head->next){ + b->count+=b->head->length; + b->head=b->head->next; + + if(b->headend+b->head->length>0) + b->headptr=b->head->buffer->data+b->head->begin-b->headend; + + b->headend+=b->head->length; + }else{ + /* we've either met the end of decode, or gone past it. halt + only if we're past */ + if(b->headend*8headbit) + /* read has fallen off the end */ + b->headend=-1; + break; + } + } +} + +void oggpack_readinit(oggpack_buffer *b,ogg_reference *r){ + memset(b,0,sizeof(*b)); + + b->tail=b->head=r; + b->count=0; + if (b->head && r->length) { + b->headptr=b->head->buffer->data+b->head->begin; + b->headend=b->head->length; + } else { + b->headptr=0; + b->headend=0; + } + _span(b); + + //fprintf(stderr, + // "Init: buffer=(%d,%x,%d,%d) %02x%02x%02x%02x%02x%02x%02x%02x\n", + // b->headbit, b->headptr, b->headend, b->count, + // b->headptr[7], b->headptr[6], b->headptr[5], b->headptr[4], + // b->headptr[3], b->headptr[2], b->headptr[1], b->headptr[0]); + //fflush(stderr); +} + +#define _lookspan() while(!end){\ + head=head->next;\ + if(!head) return -1;\ + ptr=head->buffer->data + head->begin;\ + end=head->length;\ + } + +/* Read in bits without advancing the bitptr; bits <= 32 */ +long oggpack_look(oggpack_buffer *b,int bits){ + unsigned long m=mask[bits]; + unsigned long ret = 0; + int BITS = bits; + + if (!b->headptr) return 0; + + bits+=b->headbit; + + if(bits >= b->headend<<3){ + int end=b->headend; + unsigned char *ptr=b->headptr; + ogg_reference *head=b->head; + + if(end<0)return 0; + if (!head || !end)return 0; + + if(bits){ + _lookspan(); + ret=*ptr++>>b->headbit; + if(bits>8){ + --end; + _lookspan(); + ret|=*ptr++<<(8-b->headbit); + if(bits>16){ + --end; + _lookspan(); + ret|=*ptr++<<(16-b->headbit); + if(bits>24){ + --end; + _lookspan(); + ret|=*ptr++<<(24-b->headbit); + if(bits>32 && b->headbit){ + --end; + _lookspan(); + ret|=*ptr<<(32-b->headbit); + } + } + } + } + } + + }else{ + + /* make this a switch jump-table */ + ret=b->headptr[0]>>b->headbit; + if(bits>8){ + ret|=b->headptr[1]<<(8-b->headbit); + if(bits>16){ + ret|=b->headptr[2]<<(16-b->headbit); + if(bits>24){ + ret|=b->headptr[3]<<(24-b->headbit); + if(bits>32 && b->headbit) + ret|=b->headptr[4]<<(32-b->headbit); + } + } + } + } + + ret&=m; + //fprintf(stderr, + // "Look: buffer=(%d,%x,%d,%d) %02x%02x%02x%02x%02x%02x%02x%02x (%d bits) return=%x\n", + // b->headbit, b->headptr, b->headend, b->count, + // b->headptr[7], b->headptr[6], b->headptr[5], b->headptr[4], + // b->headptr[3], b->headptr[2], b->headptr[1], b->headptr[0], + // BITS, ret); + //fflush(stderr); + return ret; +} + +/* limited to 32 at a time */ +void oggpack_adv(oggpack_buffer *b,int bits){ + int BITS=bits; + bits+=b->headbit; + b->headbit=bits&7; + b->headend-=(bits>>3); + b->headptr+=(bits>>3); + if(b->headend<1)_span(b); + //fprintf(stderr, "Adv: buffer=(%d,%x,%d,%d) %02x%02x%02x%02x%02x%02x%02x%02x (%d bits)\n", + // b->headbit, b->headptr, b->headend,b->count, + // b->headptr[7], b->headptr[6], b->headptr[5], b->headptr[4], + // b->headptr[3], b->headptr[2], b->headptr[1], b->headptr[0], + // BITS); + //fflush(stderr); +} + +int oggpack_eop(oggpack_buffer *b){ + int ret; + if(b->headend<0)ret= -1; + else ret = 0; + //fprintf(stderr, "EOP %d\n", ret); + //fflush(stderr); + return ret; +} + +long oggpack_bytes(oggpack_buffer *b){ + long ret; + if(b->headend<0) ret = b->count+b->head->length; + ret = b->count + b->head->length-b->headend + (b->headbit+7)/8; + //fprintf(stderr, "Bytes: buffer=(%d,%x,%d,%d) %02x%02x%02x%02x%02x%02x%02x%02x (%d bytes)\n", + // b->headbit, b->headptr, b->headend, b->count, + // b->headptr[7], b->headptr[6], b->headptr[5], b->headptr[4], + // b->headptr[3], b->headptr[2], b->headptr[1], b->headptr[0], + // ret); + //fflush(stderr); + return ret; +} + +long oggpack_bits(oggpack_buffer *b){ + long ret; + if(b->headend<0) ret = (b->count+b->head->length)*8; + else ret = (b->count + b->head->length-b->headend)*8 + b->headbit; + //fprintf(stderr, "Bits: buffer=(%x,%x,%x) %02x%02x%02x%02x%02x%02x%02x%02x (%d bits)\n", + // b->headbit, b->headptr, b->headend, + // b->headptr[7], b->headptr[6], b->headptr[5], b->headptr[4], + // b->headptr[3], b->headptr[2], b->headptr[1], b->headptr[0], + // ret); + //fflush(stderr); + return ret; +} + +/* bits <= 32 */ +long oggpack_read(oggpack_buffer *b,int bits){ + long ret=oggpack_look(b,bits); + oggpack_adv(b,bits); + return(ret); +} + +#endif + +/* Self test of the bitwise routines; everything else is based on + them, so they damned well better be solid. */ + +#ifdef _V_BIT_TEST +#include +#include +#include +#include "framing.c" + +static int ilog(unsigned long v){ + int ret=0; + while(v){ + ret++; + v>>=1; + } + return(ret); +} + +oggpack_buffer r; +oggpack_buffer o; +ogg_buffer_state *bs; +ogg_reference *or; +#define TESTWORDS 256 + +void report(char *in){ + fprintf(stderr,"%s",in); + exit(1); +} + +int getbyte(ogg_reference *or,int position){ + while(or && position>=or->length){ + position-=or->length; + or=or->next; + if(or==NULL){ + fprintf(stderr,"\n\tERROR: getbyte ran off end of buffer.\n"); + exit(1); + } + } + + if((position+or->begin)&1) + return (or->buffer->data[(position+or->begin)>>1])&0xff; + else + return (or->buffer->data[(position+or->begin)>>1]>>8)&0xff; +} + +void cliptest(unsigned long *b,int vals,int bits,int *comp,int compsize){ + long i,bitcount=0; + ogg_reference *or=ogg_buffer_alloc(bs,64); + for(i=0;ibuffer->data[i]= comp[i]; + or->length=i; + + oggpack_readinit(&r,or); + for(i=0;i7) + report("\nERROR: too many bits reported left over.\n"); + + /* does reading to exactly byte alignment *not* trip EOF? */ + if(oggpack_read(&o,leftover)==-1) + report("\nERROR: read to but not past exact end tripped EOF.\n"); + if(oggpack_bits(&o)!=count*8) + report("\nERROR: read to but not past exact end reported bad bitcount.\n"); + + /* does EOF trip properly after a single additional bit? */ + if(oggpack_read(&o,1)!=-1) + report("\nERROR: read past exact end did not trip EOF.\n"); + if(oggpack_bits(&o)!=count*8) + report("\nERROR: read past exact end reported bad bitcount.\n"); + + /* does EOF stay set over additional bit reads? */ + for(i=0;i<=32;i++){ + if(oggpack_read(&o,i)!=-1) + report("\nERROR: EOF did not stay set on stream.\n"); + if(oggpack_bits(&o)!=count*8) + report("\nERROR: read past exact end reported bad bitcount.\n"); + } +} + +void _end_verify2(int count){ + int i; + + /* are the proper number of bits left over? */ + int leftover=count*8-oggpack_bits(&o); + if(leftover>7) + report("\nERROR: too many bits reported left over.\n"); + + /* does reading to exactly byte alignment *not* trip EOF? */ + oggpack_adv(&o,leftover); +#ifdef ARM_LITTLE_ENDIAN + if(o.bitsLeftInSegment!=0) +#else + if(o.headend!=0) +#endif + report("\nERROR: read to but not past exact end tripped EOF.\n"); + if(oggpack_bits(&o)!=count*8) + report("\nERROR: read to but not past exact end reported bad bitcount.\n"); + + /* does EOF trip properly after a single additional bit? */ + oggpack_adv(&o,1); +#ifdef ARM_LITTLE_ENDIAN + if(o.bitsLeftInSegment>=0) +#else + if(o.headend>=0) +#endif + report("\nERROR: read past exact end did not trip EOF.\n"); + if(oggpack_bits(&o)!=count*8) + report("\nERROR: read past exact end reported bad bitcount.\n"); + + /* does EOF stay set over additional bit reads? */ + for(i=0;i<=32;i++){ + oggpack_adv(&o,i); +#ifdef ARM_LITTLE_ENDIAN + if(o.bitsLeftInSegment>=0) +#else + if(o.headend>=0) +#endif + report("\nERROR: EOF did not stay set on stream.\n"); + if(oggpack_bits(&o)!=count*8) + report("\nERROR: read past exact end reported bad bitcount.\n"); + } +} + +long ogg_buffer_length(ogg_reference *or){ + int count=0; + while(or){ + count+=or->length; + or=or->next; + } + return count; +} + +ogg_reference *ogg_buffer_extend(ogg_reference *or,long bytes){ + if(or){ + while(or->next){ + or=or->next; + } + or->next=ogg_buffer_alloc(or->buffer->ptr.owner,bytes); + return(or->next); + } + return 0; +} + +void ogg_buffer_posttruncate(ogg_reference *or,long pos){ + /* walk to the point where we want to begin truncate */ + while(or && pos>or->length){ + pos-=or->length; + or=or->next; + } + if(or){ + ogg_buffer_release(or->next); + or->next=0; + or->length=pos; + } +} + +int main(void){ + long i; + static unsigned long testbuffer1[]= + {18,12,103948,4325,543,76,432,52,3,65,4,56,32,42,34,21,1,23,32,546,456,7, + 567,56,8,8,55,3,52,342,341,4,265,7,67,86,2199,21,7,1,5,1,4}; + int test1size=43; + + static unsigned long testbuffer2[]= + {216531625L,1237861823,56732452,131,3212421,12325343,34547562,12313212, + 1233432,534,5,346435231,14436467,7869299,76326614,167548585, + 85525151,0,12321,1,349528352}; + int test2size=21; + + static unsigned long testbuffer3[]= + {1,0,14,0,1,0,12,0,1,0,0,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,1,1,1,1,0,0,1, + 0,1,30,1,1,1,0,0,1,0,0,0,12,0,11,0,1,0,0,1}; + int test3size=56; + + static unsigned long large[]= + {2136531625L,2137861823,56732452,131,3212421,12325343,34547562,12313212, + 1233432,534,5,2146435231,14436467,7869299,76326614,167548585, + 85525151,0,12321,1,2146528352}; + + int onesize=33; + static int one[33]={146,25,44,151,195,15,153,176,233,131,196,65,85,172,47,40, + 34,242,223,136,35,222,211,86,171,50,225,135,214,75,172, + 223,4}; + + int twosize=6; + static int two[6]={61,255,255,251,231,29}; + + int threesize=54; + static int three[54]={169,2,232,252,91,132,156,36,89,13,123,176,144,32,254, + 142,224,85,59,121,144,79,124,23,67,90,90,216,79,23,83, + 58,135,196,61,55,129,183,54,101,100,170,37,127,126,10, + 100,52,4,14,18,86,77,1}; + + int foursize=38; + static int four[38]={18,6,163,252,97,194,104,131,32,1,7,82,137,42,129,11,72, + 132,60,220,112,8,196,109,64,179,86,9,137,195,208,122,169, + 28,2,133,0,1}; + + int fivesize=45; + static int five[45]={169,2,126,139,144,172,30,4,80,72,240,59,130,218,73,62, + 241,24,210,44,4,20,0,248,116,49,135,100,110,130,181,169, + 84,75,159,2,1,0,132,192,8,0,0,18,22}; + + int sixsize=7; + static int six[7]={17,177,170,242,169,19,148}; + + /* Test read/write together */ + /* Later we test against pregenerated bitstreams */ + bs=ogg_buffer_create(); + + fprintf(stderr,"\nSmall preclipped packing (LSb): "); + cliptest(testbuffer1,test1size,0,one,onesize); + fprintf(stderr,"ok."); + + fprintf(stderr,"\nNull bit call (LSb): "); + cliptest(testbuffer3,test3size,0,two,twosize); + fprintf(stderr,"ok."); + + fprintf(stderr,"\nLarge preclipped packing (LSb): "); + cliptest(testbuffer2,test2size,0,three,threesize); + fprintf(stderr,"ok."); + + fprintf(stderr,"\n32 bit preclipped packing (LSb): "); + + or=ogg_buffer_alloc(bs,128); + for(i=0;ibuffer->data[i*4] = large[i]&0xff; + or->buffer->data[i*4+1] = (large[i]>>8)&0xff; + or->buffer->data[i*4+2] = (large[i]>>16)&0xff; + or->buffer->data[i*4+3] = (large[i]>>24)&0xff; + } + or->length=test2size*4; + oggpack_readinit(&r,or); + for(i=0;i>k)&0x1)<7){ + bit=0; + word++; + } + } + } + } + count2=(bitcount+7)>>3; + + /* construct random-length buffer chain from flat vector; random + byte starting offset within the length of the vector */ + { + ogg_reference *or=NULL,*orl=NULL; + long pos=0; + + /* build buffer chain */ + while(count2){ + int ilen=(rand()%32),k; + int ibegin=(rand()%32); + + + if(ilen>count2)ilen=count2; + + if(or) + orl=ogg_buffer_extend(orl,64); + else + or=orl=ogg_buffer_alloc(bs,64); + + orl->length=ilen; + orl->begin=ibegin; + + for(k=0;kbuffer->data[ibegin++]= flat[pos++]; + + count2-=ilen; + } + + if(ogg_buffer_length(or)!=(bitcount+7)/8){ + fprintf(stderr,"\nERROR: buffer length incorrect after build.\n"); + exit(1); + } + + + { + int begin=0; //=(rand()%TESTWORDS); + int ilen=(rand()%(TESTWORDS-begin)); + int bitoffset,bitcount=0; + unsigned long temp; + + for(j=0;j>(32-bitsLeftInWord) + ADDLE r12,r12,#32 @ r12= bitsLeftInWord += 32 + RSB r14,r14,#32 @ r14= 32-bitsLeftInWord + ORRLT r10,r10,r11,LSL r14 @ r10= Next 32 bits. + MOV r14,#1 + RSB r14,r14,r14,LSL r1 + AND r0,r10,r14 + LDMFD r13!,{r10,r11,PC} + +look_slow: + STMFD r13!,{r5,r6} + ADDS r10,r2,r1 @ r10= bitsLeftInSegment + bits (i.e. + @ the initial value of bitsLeftInSeg) + @ r10 = bitsLeftInSegment (initial) + @ r12 = bitsLeftInWord + RSB r14,r12,#32 @ r14= 32-bitsLeftInWord + MOV r5,r10 @ r5 = bitsLeftInSegment (initial) + BLT look_overrun + BEQ look_next_segment @ r10= r12 = 0, if we branch + CMP r12,r10 @ If bitsLeftInWord < bitsLeftInSeg + @ there must be more in the next word + LDR r10,[r3],#4 @ r10= ptr[0] + LDRLT r6,[r3] @ r6 = ptr[1] + MOV r11,#1 + MOV r10,r10,LSR r14 @ r10= first bitsLeftInWord bits + ORRLT r10,r10,r6,LSL r12 @ r10= first bitsLeftInSeg bits+crap + RSB r11,r11,r11,LSL r5 @ r11= mask + AND r10,r10,r11 @ r10= first r5 bits + @ Load the next segments data +look_next_segment: + @ At this point, r10 contains the first r5 bits of the result + LDR r11,[r0,#12] @ r11= head = b->head + @ Stall + @ Stall +look_next_segment_2: + LDR r11,[r11,#12] @ r11= head = head->next + @ Stall + @ Stall + CMP r11,#0 + BEQ look_out_of_data + LDMIA r11,{r6,r12,r14} @ r6 = buffer + @ r12= begin + @ r14= length + LDR r6,[r6] @ r6 = buffer->data + CMP r14,#0 + BEQ look_next_segment_2 + ADD r6,r6,r12 @ r6 = buffer->data+begin +look_slow_loop: + LDRB r12,[r6],#1 @ r12= *buffer + SUBS r14,r14,#1 @ r14= length + @ Stall + ORR r10,r10,r12,LSL r5 @ r10= first r5+8 bits + ADD r5,r5,#8 + BLE look_really_slow + CMP r5,r1 + BLT look_slow_loop + MOV r14,#1 + RSB r14,r14,r14,LSL r1 + AND r0,r10,r14 + LDMFD r13!,{r5,r6,r10,r11,PC} + + +look_really_slow: + CMP r5,r1 + BLT look_next_segment_2 + MOV r14,#1 + RSB r14,r14,r14,LSL r1 + AND r0,r10,r14 + LDMFD r13!,{r5,r6,r10,r11,PC} + +look_out_of_data: + @MVN r0,#0 ; return -1 + MOV r0,#0 + LDMFD r13!,{r5,r6,r10,r11,PC} + +look_overrun: + @ We had overrun when we started, so we need to skip -r10 bits. + LDR r11,[r0,#12] @ r11 = head = b->head + @ stall + @ stall +look_overrun_next_segment: + LDR r11,[r11,#12] @ r11 = head->next + @ stall + @ stall + CMP r11,#0 + BEQ look_out_of_data + LDMIA r11,{r6,r7,r14} @ r6 = buffer + @ r7 = begin + @ r14= length + LDR r6,[r6] @ r6 = buffer->data + @ stall + @ stall + ADD r6,r6,r7 @ r6 = buffer->data+begin + MOV r14,r14,LSL #3 @ r14= length in bits + ADDS r14,r14,r10 @ r14= length in bits-bits to skip + MOVLE r10,r14 + BLE look_overrun_next_segment + RSB r10,r10,#0 @ r10= bits to skip + ADD r6,r10,r10,LSR #3 @ r6 = pointer to data + MOV r10,#0 + B look_slow_loop + +oggpack_adv: + @ r0 = oggpack_buffer *b + @ r1 = bits + LDMIA r0,{r2,r3,r12} + @ r2 = bitsLeftInSegment + @ r3 = ptr + @ r12= bitsLeftInWord + SUBS r2,r2,r1 @ Does this run us out of bits in the + BLE adv_slow @ segment? If so, do it slowly + SUBS r12,r12,r1 + ADDLE r12,r12,#32 + ADDLE r3,r3,#4 + STMIA r0,{r2,r3,r12} + BX LR +adv_slow: + STMFD r13!,{r10,r14} + + LDR r14,[r0,#12] @ r14= head + @ stall +adv_slow_loop: + LDR r1,[r0,#20] @ r1 = count + LDR r10,[r14,#8] @ r10= head->length + LDR r14,[r14,#12] @ r14= head->next + @ stall + ADD r1,r1,r10 @ r1 = count += head->length + CMP r14,#0 + BEQ adv_end + STR r1,[r0,#20] @ b->count = count + STR r14,[r0,#12] @ b->head = head + LDMIA r14,{r3,r10,r12} @ r3 = buffer + @ r10= begin + @ r12= length + LDR r3,[r3] @ r3 = buffer->data + ADD r3,r3,r10 @ r3 = Pointer to start (byte) + AND r10,r3,#3 @ r10= bytes to backtrk to word align + MOV r10,r10,LSL #3 @ r10= bits to backtrk to word align + RSB r10,r10,#32 @ r10= bits left in word + ADDS r10,r10,r2 @ r10= bits left in word after skip + ADDLE r10,r10,#32 + ADDLE r3,r3,#4 + BIC r3,r3,#3 @ r3 = Pointer to start (word) + ADDS r2,r2,r12,LSL #3 @ r2 = length in bits after advance + BLE adv_slow_loop + STMIA r0,{r2,r3,r10} + + LDMFD r13!,{r10,PC} +adv_end: + MOV r2, #0 + MOV r12,#0 + STMIA r0,{r2,r3,r12} + + LDMFD r13!,{r10,PC} + +oggpack_readinit: + @ r0 = oggpack_buffer *b + @ r1 = oggreference *r + STR r1,[r0,#12] @ b->head = r1 + STR r1,[r0,#16] @ b->tail = r1 + LDMIA r1,{r2,r3,r12} @ r2 = b->head->buffer + @ r3 = b->head->begin + @ r12= b->head->length + LDR r2,[r2] @ r2 = b->head->buffer->data + MOV r1,r12,LSL #3 @ r1 = BitsInSegment + MOV r12,#0 + ADD r3,r2,r3 @ r3 = r2+b->head->begin + BIC r2,r3,#3 @ r2 = b->headptr (word) + AND r3,r3,#3 + MOV r3,r3,LSL #3 + RSB r3,r3,#32 @ r3 = BitsInWord + STMIA r0,{r1,r2,r3} + STR r12,[r0,#20] + BX LR + +oggpack_read: + @ r0 = oggpack_buffer *b + @ r1 = int bits + STMFD r13!,{r10,r11,r14} + LDMIA r0,{r2,r3,r12} + @ r2 = bitsLeftInSegment + @ r3 = ptr + @ r12= bitsLeftInWord + SUBS r2,r2,r1 @ bitsLeftinSegment -= bits + BLT read_slow @ Not enough bits in this segment for + @ this request. Do it slowly. + LDR r10,[r3] @ r10= ptr[0] + RSB r14,r12,#32 @ r14= 32-bitsLeftInWord + SUBS r12,r12,r1 @ r12= bitsLeftInWord -= bits + ADDLE r3,r3,#4 + LDRLT r11,[r3] @ r11= ptr[1] + MOV r10,r10,LSR r14 @ r10= ptr[0]>>(32-bitsLeftInWord) + ADDLE r12,r12,#32 @ r12= bitsLeftInWord += 32 + RSB r14,r14,#32 @ r14= 32-bitsLeftInWord + ORRLT r10,r10,r11,LSL r14 @ r10= Next 32 bits. + STMIA r0,{r2,r3,r12} + MOV r14,#1 + RSB r14,r14,r14,LSL r1 + AND r0,r10,r14 + LDMFD r13!,{r10,r11,PC} + +read_slow: + STMFD r13!,{r5,r6} + ADDS r10,r2,r1 @ r10= bitsLeftInSegment + bits (i.e. + @ the initial value of bitsLeftInSeg) + @ r10 = bitsLeftInSegment (initial) + @ r12 = bitsLeftInWord + RSB r14,r12,#32 @ r14= 32-bitsLeftInWord + MOV r5,r10 @ r5 = bitsLeftInSegment (initial) + BLT read_overrun + BEQ read_next_segment @ r10= r12 = 0, if we branch + CMP r12,r10 @ If bitsLeftInWord < bitsLeftInSeg + @ there must be more in the next word + LDR r10,[r3],#4 @ r10= ptr[0] + LDRLT r6,[r3] @ r6 = ptr[1] + MOV r11,#1 + MOV r10,r10,LSR r14 @ r10= first bitsLeftInWord bits + ORRLT r10,r10,r6,LSL r12 @ r10= first bitsLeftInSeg bits+crap + RSB r11,r11,r11,LSL r5 @ r11= mask + AND r10,r10,r11 @ r10= first r5 bits + @ Load the next segments data +read_next_segment: + @ At this point, r10 contains the first r5 bits of the result + LDR r11,[r0,#12] @ r11= head = b->head + @ Stall +read_next_segment_2: + @ r11 = head + LDR r6,[r0,#20] @ r6 = count + LDR r12,[r11,#8] @ r12= length + LDR r11,[r11,#12] @ r11= head = head->next + @ Stall + ADD r6,r6,r12 @ count += length + CMP r11,#0 + BEQ read_out_of_data + STR r11,[r0,#12] + STR r6,[r0,#20] @ b->count = count + LDMIA r11,{r6,r12,r14} @ r6 = buffer + @ r12= begin + @ r14= length + LDR r6,[r6] @ r6 = buffer->data + CMP r14,#0 + BEQ read_next_segment_2 + ADD r6,r6,r12 @ r6 = buffer->data+begin +read_slow_loop: + LDRB r12,[r6],#1 @ r12= *buffer + SUBS r14,r14,#1 @ r14= length + @ Stall + ORR r10,r10,r12,LSL r5 @ r10= first r5+8 bits + ADD r5,r5,#8 + BLE read_really_slow + CMP r5,r1 + BLT read_slow_loop +read_end: + MOV r12,#1 + RSB r12,r12,r12,LSL r1 + + @ Store back the new position + @ r2 = -number of bits to go from this segment + @ r6 = ptr + @ r14= bytesLeftInSegment + @ r11= New head value + LDMIA r11,{r3,r6,r14} @ r3 = buffer + @ r6 = begin + @ r14= length + LDR r3,[r3] @ r3 = buffer->data + ADD r1,r2,r14,LSL #3 @ r1 = bitsLeftInSegment + @ stall + ADD r6,r3,r6 @ r6 = pointer + AND r3,r6,#3 @ r3 = bytes used in first word + RSB r3,r2,r3,LSL #3 @ r3 = bits used in first word + BIC r2,r6,#3 @ r2 = word ptr + RSBS r3,r3,#32 @ r3 = bitsLeftInWord + ADDLE r3,r3,#32 + ADDLE r2,r2,#4 + STMIA r0,{r1,r2,r3} + + AND r0,r10,r12 + LDMFD r13!,{r5,r6,r10,r11,PC} + + +read_really_slow: + CMP r5,r1 + BGE read_end + LDR r14,[r11,#8] @ r14= length of segment just done + @ stall + @ stall + ADD r2,r2,r14,LSL #3 @ r2 = -bits to use from next seg + B read_next_segment_2 + +read_out_of_data: + @ Store back the new position + @ r2 = -number of bits to go from this segment + @ r6 = ptr + @ r14= bytesLeftInSegment + @ RJW: This may be overkill - we leave the buffer empty, with -1 + @ bits left in it. We might get away with just storing the + @ bitsLeftInSegment as -1. + LDR r11,[r0,#12] @ r11=head + + LDMIA r11,{r3,r6,r14} @ r3 = buffer + @ r6 = begin + @ r14= length + LDR r3,[r3] @ r3 = buffer->data + ADD r6,r3,r6 @ r6 = pointer + ADD r6,r6,r14 + AND r3,r6,#3 @ r3 = bytes used in first word + MOV r3,r3,LSL #3 @ r3 = bits used in first word + BIC r2,r6,#3 @ r2 = word ptr + RSBS r3,r3,#32 @ r3 = bitsLeftInWord + MVN r1,#0 @ r1 = -1 = bitsLeftInSegment + STMIA r0,{r1,r2,r3} + @MVN r0,#0 ; return -1 + MOV r0,#0 + LDMFD r13!,{r5,r6,r10,r11,PC} + +read_overrun: + @ We had overrun when we started, so we need to skip -r10 bits. + LDR r11,[r0,#12] @ r11 = head = b->head + @ stall + @ stall +read_overrun_next_segment: + LDR r11,[r11,#12] @ r11 = head->next + @ stall + @ stall + CMP r11,#0 + BEQ read_out_of_data + LDMIA r11,{r6,r7,r14} @ r6 = buffer + @ r7 = begin + @ r14= length + LDR r6,[r6] @ r6 = buffer->data + @ stall + @ stall + ADD r6,r6,r7 @ r6 = buffer->data+begin + MOV r14,r14,LSL #3 @ r14= length in bits + ADDS r14,r14,r10 @ r14= length in bits-bits to skip + MOVLE r10,r14 + BLE read_overrun_next_segment + RSB r10,r10,#0 @ r10= bits to skip + ADD r6,r10,r10,LSR #3 @ r6 = pointer to data + MOV r10,#0 + B read_slow_loop + + @ END diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codebook.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codebook.c new file mode 100644 index 0000000..3dec3d3 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codebook.c @@ -0,0 +1,920 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: basic codebook pack/unpack/code/decode operations + + ************************************************************************/ + +#include +#include +#include +#include +//#include +#include "ogg.h" +#include "ivorbiscodec.h" +#include "codebook.h" +#include "misc.h" +#include "os.h" + +#define MARKER_SIZE 33 + +/**** pack/unpack helpers ******************************************/ +int _ilog(unsigned int v){ + int ret=0; + while(v){ + ret++; + v>>=1; + } + return(ret); +} + +static ogg_uint32_t decpack(long entry,long used_entry,long quantvals, + codebook *b,oggpack_buffer *opb,int maptype){ + ogg_uint32_t ret=0; + int j; + + switch(b->dec_type){ + + case 0: + return (ogg_uint32_t)entry; + + case 1: + if(maptype==1){ + /* vals are already read into temporary column vector here */ + for(j=0;jdim;j++){ + ogg_uint32_t off=entry%quantvals; + entry/=quantvals; + ret|=((ogg_uint16_t *)(b->q_val))[off]<<(b->q_bits*j); + } + }else{ + for(j=0;jdim;j++) + ret|=oggpack_read(opb,b->q_bits)<<(b->q_bits*j); + } + return ret; + + case 2: + for(j=0;jdim;j++){ + ogg_uint32_t off=entry%quantvals; + entry/=quantvals; + ret|=off<<(b->q_pack*j); + } + return ret; + + case 3: + return (ogg_uint32_t)used_entry; + + } + return 0; /* silence compiler */ +} + +/* 32 bit float (not IEEE; nonnormalized mantissa + + biased exponent) : neeeeeee eeemmmmm mmmmmmmm mmmmmmmm + Why not IEEE? It's just not that important here. */ + +static ogg_int32_t _float32_unpack(long val,int *point){ + long mant=val&0x1fffff; + int sign=val&0x80000000; + + *point=((val&0x7fe00000L)>>21)-788; + + if(mant){ + while(!(mant&0x40000000)){ + mant<<=1; + *point-=1; + } + if(sign)mant= -mant; + }else{ + *point=-9999; + } + return mant; +} + +/* choose the smallest supported node size that fits our decode table. + Legal bytewidths are 1/1 1/2 2/2 2/4 4/4 */ +static int _determine_node_bytes(long used, int leafwidth){ + + /* special case small books to size 4 to avoid multiple special + cases in repack */ + if(used<2) + return 4; + + if(leafwidth==3)leafwidth=4; + if(_ilog(3*used-6)+1 <= leafwidth*4) + return leafwidth/2?leafwidth/2:1; + return leafwidth; +} + +/* convenience/clarity; leaves are specified as multiple of node word + size (1 or 2) */ +static int _determine_leaf_words(int nodeb, int leafwidth){ + if(leafwidth>nodeb)return 2; + return 1; +} + +/* given a list of word lengths, number of used entries, and byte + width of a leaf, generate the decode table */ +static int _make_words(char *l,long n,ogg_uint32_t *r,long quantvals, + codebook *b, oggpack_buffer *opb,int maptype){ + long i,j,count=0; + long top=0; + ogg_uint32_t marker[MARKER_SIZE]; + + if (n<1) + return 1; + + if(n<2){ + r[0]=0x80000000; + }else{ + memset(marker,0,sizeof(marker)); + + for(i=0;i= MARKER_SIZE) { + //ALOGE("b/23881715"); + return 1; + } + ogg_uint32_t entry=marker[length]; + long chase=0; + if(count && !entry)return -1; /* overpopulated tree! */ + + /* chase the tree as far as it's already populated, fill in past */ + for(j=0;j>(length-j-1))&1; + if(chase>=top){ + if (chase < 0 || chase >= n) return 1; + top++; + r[chase*2]=top; + r[chase*2+1]=0; + }else + if (chase < 0 || chase >= n || chase*2+bit > n*2+1) return 1; + if(!r[chase*2+bit]) + r[chase*2+bit]=top; + chase=r[chase*2+bit]; + if (chase < 0 || chase >= n) return 1; + } + { + int bit=(entry>>(length-j-1))&1; + if(chase>=top){ + top++; + r[chase*2+1]=0; + } + r[chase*2+bit]= decpack(i,count++,quantvals,b,opb,maptype) | + 0x80000000; + } + + /* Look to see if the next shorter marker points to the node + above. if so, update it and repeat. */ + for(j=length;j>0;j--){ + if(marker[j]&1){ + marker[j]=marker[j-1]<<1; + break; + } + marker[j]++; + } + + /* prune the tree; the implicit invariant says all the longer + markers were dangling from our just-taken node. Dangle them + from our *new* node. */ + for(j=length+1;j>1) == entry){ + entry=marker[j]; + marker[j]=marker[j-1]<<1; + }else + break; + } + } + } + + // following sanity check copied from libvorbis + /* sanity check the huffman tree; an underpopulated tree must be + rejected. The only exception is the one-node pseudo-nil tree, + which appears to be underpopulated because the tree doesn't + really exist; there's only one possible 'codeword' or zero bits, + but the above tree-gen code doesn't mark that. */ + if(b->used_entries != 1){ + for(i=1;i>(32-i))){ + return 1; + } + } + + + return 0; +} + +static int _make_decode_table(codebook *s,char *lengthlist,long quantvals, + oggpack_buffer *opb,int maptype){ + int i; + ogg_uint32_t *work; + + if (!lengthlist) return 1; + if(s->dec_nodeb==4){ + /* Over-allocate by using s->entries instead of used_entries. + * This means that we can use s->entries to enforce size in + * _make_words without messing up length list looping. + * This probably wastes a bit of space, but it shouldn't + * impact behavior or size too much. + */ + s->dec_table=_ogg_malloc((s->entries*2+1)*sizeof(*work)); + if (!s->dec_table) return 1; + /* +1 (rather than -2) is to accommodate 0 and 1 sized books, + which are specialcased to nodeb==4 */ + if(_make_words(lengthlist,s->entries, + s->dec_table,quantvals,s,opb,maptype))return 1; + + return 0; + } + + if (s->used_entries > INT_MAX/2 || + s->used_entries*2 > INT_MAX/((long) sizeof(*work)) - 1) return 1; + /* Overallocate as above */ + work=calloc((s->entries*2+1),sizeof(*work)); + if (!work) return 1; + if(_make_words(lengthlist,s->entries,work,quantvals,s,opb,maptype)) goto error_out; + if (s->used_entries > INT_MAX/(s->dec_leafw+1)) goto error_out; + if (s->dec_nodeb && s->used_entries * (s->dec_leafw+1) > INT_MAX/s->dec_nodeb) goto error_out; + s->dec_table=_ogg_malloc((s->used_entries*(s->dec_leafw+1)-2)* + s->dec_nodeb); + if (!s->dec_table) goto error_out; + + if(s->dec_leafw==1){ + switch(s->dec_nodeb){ + case 1: + for(i=0;iused_entries*2-2;i++) + ((unsigned char *)s->dec_table)[i]=(unsigned char) + (((work[i] & 0x80000000UL) >> 24) | work[i]); + break; + case 2: + for(i=0;iused_entries*2-2;i++) + ((ogg_uint16_t *)s->dec_table)[i]=(ogg_uint16_t) + (((work[i] & 0x80000000UL) >> 16) | work[i]); + break; + } + + }else{ + /* more complex; we have to do a two-pass repack that updates the + node indexing. */ + long top=s->used_entries*3-2; + if(s->dec_nodeb==1){ + unsigned char *out=(unsigned char *)s->dec_table; + + for(i=s->used_entries*2-4;i>=0;i-=2){ + if(work[i]&0x80000000UL){ + if(work[i+1]&0x80000000UL){ + top-=4; + out[top]=(work[i]>>8 & 0x7f)|0x80; + out[top+1]=(work[i+1]>>8 & 0x7f)|0x80; + out[top+2]=work[i] & 0xff; + out[top+3]=work[i+1] & 0xff; + }else{ + top-=3; + out[top]=(work[i]>>8 & 0x7f)|0x80; + out[top+1]=work[work[i+1]*2]; + out[top+2]=work[i] & 0xff; + } + }else{ + if(work[i+1]&0x80000000UL){ + top-=3; + out[top]=work[work[i]*2]; + out[top+1]=(work[i+1]>>8 & 0x7f)|0x80; + out[top+2]=work[i+1] & 0xff; + }else{ + top-=2; + out[top]=work[work[i]*2]; + out[top+1]=work[work[i+1]*2]; + } + } + work[i]=top; + } + }else{ + ogg_uint16_t *out=(ogg_uint16_t *)s->dec_table; + for(i=s->used_entries*2-4;i>=0;i-=2){ + if(work[i]&0x80000000UL){ + if(work[i+1]&0x80000000UL){ + top-=4; + out[top]=(work[i]>>16 & 0x7fff)|0x8000; + out[top+1]=(work[i+1]>>16 & 0x7fff)|0x8000; + out[top+2]=work[i] & 0xffff; + out[top+3]=work[i+1] & 0xffff; + }else{ + top-=3; + out[top]=(work[i]>>16 & 0x7fff)|0x8000; + out[top+1]=work[work[i+1]*2]; + out[top+2]=work[i] & 0xffff; + } + }else{ + if(work[i+1]&0x80000000UL){ + top-=3; + out[top]=work[work[i]*2]; + out[top+1]=(work[i+1]>>16 & 0x7fff)|0x8000; + out[top+2]=work[i+1] & 0xffff; + }else{ + top-=2; + out[top]=work[work[i]*2]; + out[top+1]=work[work[i+1]*2]; + } + } + work[i]=top; + } + } + } + + free(work); + return 0; +error_out: + free(work); + return 1; +} + +/* most of the time, entries%dimensions == 0, but we need to be + well defined. We define that the possible vales at each + scalar is values == entries/dim. If entries%dim != 0, we'll + have 'too few' values (values*dimentries); + int vals=b->entries>>((bits-1)*(b->dim-1)/b->dim); + + while(1){ + long acc=1; + long acc1=1; + int i; + for(i=0;idim;i++){ + acc*=vals; + acc1*=vals+1; + } + if(acc<=b->entries && acc1>b->entries){ + return(vals); + }else{ + if(acc>b->entries){ + vals--; + }else{ + vals++; + } + } + } +} + +void vorbis_book_clear(codebook *b){ + /* static book is not cleared; we're likely called on the lookup and + the static codebook belongs to the info struct */ + if(b->q_val)_ogg_free(b->q_val); + if(b->dec_table)_ogg_free(b->dec_table); + if(b->dec_buf)_ogg_free(b->dec_buf); + + memset(b,0,sizeof(*b)); +} + +int vorbis_book_unpack(oggpack_buffer *opb,codebook *s){ + char *lengthlist=NULL; + int quantvals=0; + long i,j; + int maptype; + + memset(s,0,sizeof(*s)); + + /* make sure alignment is correct */ + if(oggpack_read(opb,24)!=0x564342)goto _eofout; + + /* first the basic parameters */ + s->dim=oggpack_read(opb,16); + s->dec_buf=_ogg_malloc(sizeof(ogg_int32_t)*s->dim); + if (s->dec_buf == NULL) + goto _errout; + s->entries=oggpack_read(opb,24); + if(s->entries<=0)goto _eofout; + if(s->dim<=0)goto _eofout; + if(_ilog(s->dim)+_ilog(s->entries)>24)goto _eofout; + if (s->dim > INT_MAX/s->entries) goto _eofout; + + /* codeword ordering.... length ordered or unordered? */ + switch((int)oggpack_read(opb,1)){ + case 0: + /* unordered */ + lengthlist=(char *)calloc(s->entries, sizeof(*lengthlist)); + if(!lengthlist) goto _eofout; + + /* allocated but unused entries? */ + if(oggpack_read(opb,1)){ + /* yes, unused entries */ + + for(i=0;ientries;i++){ + if(oggpack_read(opb,1)){ + long num=oggpack_read(opb,5); + if(num==-1)goto _eofout; + lengthlist[i]=(char)(num+1); + s->used_entries++; + if(num+1>s->dec_maxlength)s->dec_maxlength=num+1; + }else + lengthlist[i]=0; + } + }else{ + /* all entries used; no tagging */ + s->used_entries=s->entries; + for(i=0;ientries;i++){ + long num=oggpack_read(opb,5); + if(num==-1)goto _eofout; + lengthlist[i]=(char)(num+1); + if(num+1>s->dec_maxlength)s->dec_maxlength=num+1; + } + } + + break; + case 1: + /* ordered */ + { + long length=oggpack_read(opb,5)+1; + + s->used_entries=s->entries; + lengthlist=(char *)calloc(s->entries, sizeof(*lengthlist)); + if (!lengthlist) goto _eofout; + + for(i=0;ientries;){ + long num=oggpack_read(opb,_ilog(s->entries-i)); + if(num<0)goto _eofout; + for(j=0;jentries;j++,i++) + lengthlist[i]=(char)length; + s->dec_maxlength=length; + length++; + } + } + break; + default: + /* EOF */ + goto _eofout; + } + + + /* Do we have a mapping to unpack? */ + + if((maptype=oggpack_read(opb,4))>0){ + s->q_min=_float32_unpack(oggpack_read(opb,32),&s->q_minp); + s->q_del=_float32_unpack(oggpack_read(opb,32),&s->q_delp); + s->q_bits=oggpack_read(opb,4)+1; + s->q_seq=oggpack_read(opb,1); + + s->q_del>>=s->q_bits; + s->q_delp+=s->q_bits; + } + + switch(maptype){ + case 0: + + /* no mapping; decode type 0 */ + + /* how many bytes for the indexing? */ + /* this is the correct boundary here; we lose one bit to + node/leaf mark */ + s->dec_nodeb=_determine_node_bytes(s->used_entries,_ilog(s->entries)/8+1); + s->dec_leafw=_determine_leaf_words(s->dec_nodeb,_ilog(s->entries)/8+1); + s->dec_type=0; + + if(_make_decode_table(s,lengthlist,quantvals,opb,maptype)) goto _errout; + break; + + case 1: + + /* mapping type 1; implicit values by lattice position */ + quantvals=_book_maptype1_quantvals(s); + + /* dec_type choices here are 1,2; 3 doesn't make sense */ + { + /* packed values */ + long total1=(s->q_bits*s->dim+8)/8; /* remember flag bit */ + if (s->dim > (INT_MAX-8)/s->q_bits) goto _eofout; + /* vector of column offsets; remember flag bit */ + long total2=(_ilog(quantvals-1)*s->dim+8)/8+(s->q_bits+7)/8; + + + if(total1<=4 && total1<=total2){ + /* use dec_type 1: vector of packed values */ + + /* need quantized values before */ + s->q_val=calloc(sizeof(ogg_uint16_t), quantvals); + if (!s->q_val) goto _eofout; + for(i=0;iq_val)[i]=(ogg_uint16_t)oggpack_read(opb,s->q_bits); + + if(oggpack_eop(opb)){ + goto _eofout; + } + + s->dec_type=1; + s->dec_nodeb=_determine_node_bytes(s->used_entries, + (s->q_bits*s->dim+8)/8); + s->dec_leafw=_determine_leaf_words(s->dec_nodeb, + (s->q_bits*s->dim+8)/8); + if(_make_decode_table(s,lengthlist,quantvals,opb,maptype)){ + goto _errout; + } + + free(s->q_val); + s->q_val=0; + + }else{ + /* use dec_type 2: packed vector of column offsets */ + + /* need quantized values before */ + if(s->q_bits<=8){ + s->q_val=_ogg_malloc(quantvals); + if (!s->q_val) goto _eofout; + for(i=0;iq_val)[i]=(unsigned char)oggpack_read(opb,s->q_bits); + }else{ + s->q_val=_ogg_malloc(quantvals*2); + if (!s->q_val) goto _eofout; + for(i=0;iq_val)[i]=(ogg_uint16_t)oggpack_read(opb,s->q_bits); + } + + if(oggpack_eop(opb))goto _eofout; + + s->q_pack=_ilog(quantvals-1); + s->dec_type=2; + s->dec_nodeb=_determine_node_bytes(s->used_entries, + (_ilog(quantvals-1)*s->dim+8)/8); + s->dec_leafw=_determine_leaf_words(s->dec_nodeb, + (_ilog(quantvals-1)*s->dim+8)/8); + if(_make_decode_table(s,lengthlist,quantvals,opb,maptype))goto _errout; + + } + } + break; + case 2: + + /* mapping type 2; explicit array of values */ + quantvals=s->entries*s->dim; + /* dec_type choices here are 1,3; 2 is not possible */ + + if( (s->q_bits*s->dim+8)/8 <=4){ /* remember flag bit */ + /* use dec_type 1: vector of packed values */ + + s->dec_type=1; + s->dec_nodeb=_determine_node_bytes(s->used_entries,(s->q_bits*s->dim+8)/8); + s->dec_leafw=_determine_leaf_words(s->dec_nodeb,(s->q_bits*s->dim+8)/8); + if(_make_decode_table(s,lengthlist,quantvals,opb,maptype))goto _errout; + + }else{ + /* use dec_type 3: scalar offset into packed value array */ + + s->dec_type=3; + s->dec_nodeb=_determine_node_bytes(s->used_entries,_ilog(s->used_entries-1)/8+1); + s->dec_leafw=_determine_leaf_words(s->dec_nodeb,_ilog(s->used_entries-1)/8+1); + if(_make_decode_table(s,lengthlist,quantvals,opb,maptype))goto _errout; + + /* get the vals & pack them */ + s->q_pack=(s->q_bits+7)/8*s->dim; + s->q_val=_ogg_malloc(s->q_pack*s->used_entries); + + if(s->q_bits<=8){ + for(i=0;iused_entries*s->dim;i++) + ((unsigned char *)(s->q_val))[i]=(unsigned char)oggpack_read(opb,s->q_bits); + }else{ + for(i=0;iused_entries*s->dim;i++) + ((ogg_uint16_t *)(s->q_val))[i]=(ogg_uint16_t)oggpack_read(opb,s->q_bits); + } + } + break; + default: + goto _errout; + } + + if (s->dec_nodeb==1) + if (s->dec_leafw == 1) + s->dec_method = 0; + else + s->dec_method = 1; + else if (s->dec_nodeb==2) + if (s->dec_leafw == 1) + s->dec_method = 2; + else + s->dec_method = 3; + else + s->dec_method = 4; + + if(oggpack_eop(opb))goto _eofout; + + free(lengthlist); + return 0; + _errout: + _eofout: + vorbis_book_clear(s); + free(lengthlist); + free(s->q_val); + return -1; +} + +#ifndef ONLY_C +ogg_uint32_t decode_packed_entry_number(codebook *book, + oggpack_buffer *b); +#else +static inline ogg_uint32_t decode_packed_entry_number(codebook *book, + oggpack_buffer *b){ + ogg_uint32_t chase=0; + int read=book->dec_maxlength; + long lok = oggpack_look(b,read),i; + + while(lok<0 && read>1) + lok = oggpack_look(b, --read); + + if(lok<0){ + oggpack_adv(b,1); /* force eop */ + return -1; + } + + /* chase the tree with the bits we got */ + switch (book->dec_method) + { + case 0: + { + /* book->dec_nodeb==1, book->dec_leafw==1 */ + /* 8/8 - Used */ + unsigned char *t=(unsigned char *)book->dec_table; + + for(i=0;i>i)&1)]; + if(chase&0x80UL)break; + } + chase&=0x7fUL; + break; + } + case 1: + { + /* book->dec_nodeb==1, book->dec_leafw!=1 */ + /* 8/16 - Used by infile2 */ + unsigned char *t=(unsigned char *)book->dec_table; + for(i=0;i>i)&1; + int next=t[chase+bit]; + if(next&0x80){ + chase= (next<<8) | t[chase+bit+1+(!bit || t[chase]&0x80)]; + break; + } + chase=next; + } + //chase&=0x7fffUL; + chase&=~0x8000UL; + break; + } + case 2: + { + /* book->dec_nodeb==2, book->dec_leafw==1 */ + /* 16/16 - Used */ + for(i=0;idec_table))[chase*2+((lok>>i)&1)]; + if(chase&0x8000UL)break; + } + //chase&=0x7fffUL; + chase&=~0x8000UL; + break; + } + case 3: + { + /* book->dec_nodeb==2, book->dec_leafw!=1 */ + /* 16/32 - Used by infile2 */ + ogg_uint16_t *t=(ogg_uint16_t *)book->dec_table; + for(i=0;i>i)&1; + int next=t[chase+bit]; + if(next&0x8000){ + chase= (next<<16) | t[chase+bit+1+(!bit || t[chase]&0x8000)]; + break; + } + chase=next; + } + //chase&=0x7fffffffUL; + chase&=~0x80000000UL; + break; + } + case 4: + { + //Output("32/32"); + for(i=0;idec_table))[chase*2+((lok>>i)&1)]; + if(chase&0x80000000UL)break; + } + //chase&=0x7fffffffUL; + chase&=~0x80000000UL; + break; + } + } + + if(idec_type)return -1; + return decode_packed_entry_number(book,b); +} + +#ifndef ONLY_C +int decode_map(codebook *s, oggpack_buffer *b, ogg_int32_t *v, int point); +#else +static int decode_map(codebook *s, oggpack_buffer *b, ogg_int32_t *v, int point){ + ogg_uint32_t entry = decode_packed_entry_number(s,b); + int i; + if(oggpack_eop(b))return(-1); + + /* 1 used by test file 0 */ + + /* according to decode type */ + switch(s->dec_type){ + case 1:{ + /* packed vector of values */ + int mask=(1<q_bits)-1; + for(i=0;idim;i++){ + v[i]=entry&mask; + entry>>=s->q_bits; + } + break; + } + case 2:{ + /* packed vector of column offsets */ + int mask=(1<q_pack)-1; + for(i=0;idim;i++){ + if(s->q_bits<=8) + v[i]=((unsigned char *)(s->q_val))[entry&mask]; + else + v[i]=((ogg_uint16_t *)(s->q_val))[entry&mask]; + entry>>=s->q_pack; + } + break; + } + case 3:{ + /* offset into array */ + void *ptr=((char *)s->q_val)+entry*s->q_pack; + + if(s->q_bits<=8){ + for(i=0;idim;i++) + v[i]=((unsigned char *)ptr)[i]; + }else{ + for(i=0;idim;i++) + v[i]=((ogg_uint16_t *)ptr)[i]; + } + break; + } + default: + return -1; + } + + /* we have the unpacked multiplicands; compute final vals */ + { + int shiftM = point-s->q_delp; + ogg_int32_t add = point-s->q_minp; + int mul = s->q_del; + + if(add>0) + add= s->q_min >> add; + else + add= s->q_min << -add; + if (shiftM<0) + { + mul <<= -shiftM; + shiftM = 0; + } + add <<= shiftM; + + for(i=0;idim;i++) + v[i]= ((add + v[i] * mul) >> shiftM); + + if(s->q_seq) + for(i=1;idim;i++) + v[i]+=v[i-1]; + } + + return 0; +} +#endif + +/* returns 0 on OK or -1 on eof *************************************/ +long vorbis_book_decodevs_add(codebook *book,ogg_int32_t *a, + oggpack_buffer *b,int n,int point){ + if(book->used_entries>0){ + int step=n/book->dim; + ogg_int32_t *v = book->dec_buf;//(ogg_int32_t *)alloca(sizeof(*v)*book->dim); + int i,j,o; + if (!v) return -1; + + for (j=0;jdim;i++,o+=step) + a[o]+=v[i]; + } + } + return 0; +} + +long vorbis_book_decodev_add(codebook *book,ogg_int32_t *a, + oggpack_buffer *b,int n,int point){ + if(book->used_entries>0){ + ogg_int32_t *v = book->dec_buf;//(ogg_int32_t *)alloca(sizeof(*v)*book->dim); + int i,j; + + if (!v) return -1; + for(i=0;idim && i < n;j++) + a[i++]+=v[j]; + } + } + return 0; +} + +long vorbis_book_decodev_set(codebook *book,ogg_int32_t *a, + oggpack_buffer *b,int n,int point){ + if(book->used_entries>0){ + ogg_int32_t *v = book->dec_buf;//(ogg_int32_t *)alloca(sizeof(*v)*book->dim); + int i,j; + + if (!v) return -1; + for(i=0;idim && i < n;j++) + a[i++]=v[j]; + } + }else{ + int i,j; + + for(i=0;idim && i < n;j++) + a[i++]=0; + } + } + + return 0; +} + +#ifndef ONLY_C +long vorbis_book_decodevv_add(codebook *book,ogg_int32_t **a, + long offset,int ch, + oggpack_buffer *b,int n,int point); +#else +long vorbis_book_decodevv_add(codebook *book,ogg_int32_t **a, + long offset,int ch, + oggpack_buffer *b,int n,int point){ + if(book->used_entries>0){ + + ogg_int32_t *v = book->dec_buf;//(ogg_int32_t *)alloca(sizeof(*v)*book->dim); + long i,j; + int chptr=0; + + if (!v) return -1; + for(i=offset;idim && i < offset + n;j++){ + a[chptr++][i]+=v[j]; + if(chptr==ch){ + chptr=0; + i++; + } + } + } + } + + return 0; +} +#endif diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codebook.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codebook.h new file mode 100644 index 0000000..7aff26b --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codebook.h @@ -0,0 +1,89 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: basic shared codebook operations + + ************************************************************************/ + +#ifndef _V_CODEBOOK_H_ +#define _V_CODEBOOK_H_ + +#include "ogg.h" + +typedef struct codebook{ + /* Top 15 used in ARM code */ + int dec_maxlength; + void *dec_table; + int dec_method; + int dec_type; /* 0 = entry number + 1 = packed vector of values + 2 = packed vector of column offsets, maptype 1 + 3 = scalar offset into value array, maptype 2 */ + int q_bits; + long dim; /* codebook dimensions (elements per vector) */ + int q_delp; + int q_minp; + ogg_int32_t q_del; + ogg_int32_t q_min; + int q_seq; + int q_pack; + void *q_val; + long used_entries; /* populated codebook entries */ + ogg_int32_t *dec_buf; + + /* C only */ + int dec_nodeb; + int dec_leafw; + + long entries; /* codebook entries */ + +} codebook; + +extern void vorbis_book_clear(codebook *b); +extern int vorbis_book_unpack(oggpack_buffer *b,codebook *c); + +extern long vorbis_book_decode(codebook *book, oggpack_buffer *b); +extern long vorbis_book_decodevs_add(codebook *book, ogg_int32_t *a, + oggpack_buffer *b,int n,int point); +extern long vorbis_book_decodev_set(codebook *book, ogg_int32_t *a, + oggpack_buffer *b,int n,int point); +extern long vorbis_book_decodev_add(codebook *book, ogg_int32_t *a, + oggpack_buffer *b,int n,int point); +extern long vorbis_book_decodevv_add(codebook *book, ogg_int32_t **a, + long off,int ch, + oggpack_buffer *b,int n,int point); + +extern int _ilog(unsigned int v); + + +#endif diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codec_internal.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codec_internal.h new file mode 100644 index 0000000..c94db5f --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/codec_internal.h @@ -0,0 +1,235 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: libvorbis codec headers + + ************************************************************************/ + +#ifndef _V_CODECI_H_ +#define _V_CODECI_H_ + +#define CHUNKSIZE 1024 + +#include "codebook.h" +#include "ivorbiscodec.h" + +#define VI_TRANSFORMB 1 +#define VI_WINDOWB 1 +#define VI_TIMEB 1 +#define VI_FLOORB 2 +#define VI_RESB 3 +#define VI_MAPB 1 + +typedef void vorbis_info_floor; + +/* vorbis_dsp_state buffers the current vorbis audio + analysis/synthesis state. The DSP state belongs to a specific + logical bitstream ****************************************************/ +struct vorbis_dsp_state{ + vorbis_info *vi; + oggpack_buffer opb; + + ogg_int32_t **work; + ogg_int32_t **mdctright; + int out_begin; + int out_end; + + long lW; + long W; + + ogg_int64_t granulepos; + ogg_int64_t sequence; + ogg_int64_t sample_count; + +}; + + +/* Floor backend generic *****************************************/ + +extern vorbis_info_floor *floor0_info_unpack(vorbis_info *,oggpack_buffer *); +extern void floor0_free_info(vorbis_info_floor *); +extern int floor0_memosize(vorbis_info_floor *); +extern ogg_int32_t *floor0_inverse1(struct vorbis_dsp_state *, + vorbis_info_floor *,ogg_int32_t *); +extern int floor0_inverse2 (struct vorbis_dsp_state *,vorbis_info_floor *, + ogg_int32_t *buffer,ogg_int32_t *); + +extern vorbis_info_floor *floor1_info_unpack(vorbis_info *,oggpack_buffer *); +extern void floor1_free_info(vorbis_info_floor *); +extern int floor1_memosize(vorbis_info_floor *); +extern ogg_int32_t *floor1_inverse1(struct vorbis_dsp_state *, + vorbis_info_floor *,ogg_int32_t *); +extern int floor1_inverse2 (struct vorbis_dsp_state *,vorbis_info_floor *, + ogg_int32_t *buffer,ogg_int32_t *); + +typedef struct{ + int order; + long rate; + long barkmap; + + int ampbits; + int ampdB; + + int numbooks; /* <= 16 */ + char books[16]; + +} vorbis_info_floor0; + +typedef struct{ + char class_dim; /* 1 to 8 */ + char class_subs; /* 0,1,2,3 (bits: 1<max_length + @ r6 = book->dec_table + @ r7 = book->dec_method + MOV r5,r1 @ r5 = b + + MOV r0,r5 @ r0 = b + MOV r1,r4 @ r1 = read + BL oggpack_look +dpen_read_return: + CMP r0,#0 + BLT dpen_readfailed + + @ r0 = lok + @ r4 = read + @ r5 = b + @ r6 = dec_table + @ r7 = dec_method + + CMP r7, #3 + BGT meth4 + BEQ meth3 + CMP r7, #1 + BGT meth2 + BEQ meth1 +meth0: + RSB r1, r4, #0 @ r1 = i-read = 0-read + MOV r7, #0 @ r7 = chase +m0_loop: + MOVS r0, r0, LSR #1 @ r0 = lok>>1 C = bottom bit + ADC r2, r6, r7, LSL #1 @ r8 = &t[chase*2+C] + LDRB r7, [r2] + ADDS r1, r1, #1 @ r1 = i-read++ (i-read<0 => i= 0) === (i >= read) + MVNGT r7, #0 @ if (i >= read) value to return = -1 + ADD r1, r1, r4 @ r1 = i-read+read+1 = i +1 + MOV r0, r5 @ r0 = b + BL oggpack_adv @ oggpack_adv(b, i+1); + MOV r0, r7 @ return chase + LDMFD r13!,{r4-r8,r10,PC} + +meth1: + @ r0 = lok + @ r4 = read + @ r5 = b + @ r6 = dec_table + RSB r1, r4, #0 @ r1 = i = -read + MOV r10,#0 @ r10= next = 0 +m1_loop: + MOV r7, r10 @ r7 = chase=next + MOVS r0, r0, LSR #1 @ r0 = lok>>1 C = bottom bit + ADC r8, r6, r7 @ r8 = t+chase+bit + LDRB r10,[r8], -r6 @ r10= next=t[chase+bit] r8=chase+bit + ADDS r1, r1, #1 @ r1 = i++ + @ stall Xscale + CMPLT r10,#0x80 @ if (next & 0x80) == 0 + BLT m1_loop + + ADD r1, r1, r4 @ r1 = i+read + MOV r0, r5 @ r0 = b + BL oggpack_adv @ oggpack_adv(b, i) + + CMP r10,#0x80 + BLT duff + + CMP r8, r7 @ if bit==0 (chase+bit==chase) (sets C) + LDRNEB r14,[r6, r7] @ r14= t[chase] + MOVEQ r14,#128 + ADC r12,r8, r6 @ r12= chase+bit+1+t + LDRB r14,[r12,r14,LSR #7] @ r14= t[chase+bit+1+(!bit || t[chase]0x0x80)] + BIC r10,r10,#0x80 @ r3 = next &= ~0x80 + @ stall Xscale + ORR r0, r14,r10,LSL #8 @ r7 = chase = (next<<8) | r14 + + LDMFD r13!,{r4-r8,r10,PC} + + +meth2: + RSB r1, r4, #0 @ r1 = i-read = 0-read + MOV r7, #0 @ r7 = chase + MOV r6, r6, LSR #1 +m2_loop: + MOVS r0, r0, LSR #1 @ r0 = lok>>1 C = bottom bit + ADC r2, r6, r7, LSL #1 @ r8 = &t[chase*2+C] + LDRH r7, [r2, r2] + ADDS r1, r1, #1 @ r1 = i-read++ (i-read<0 => i= 0) === (i >= read) + MVNGT r7, #0 @ if (i >= read) value to return = -1 + ADD r1, r1, r4 @ r1 = i-read+read+1 = i +1 + MOV r0, r5 @ r0 = b + BL oggpack_adv @ oggpack_adv(b, i+1); + MOV r0, r7 @ return chase + LDMFD r13!,{r4-r8,r10,PC} + +meth3: + @ r0 = lok + @ r4 = read + @ r5 = b + @ r6 = dec_table + RSB r1, r4, #0 @ r1 = i = -read + MOV r10,#0 @ r10= next = 0 +m3_loop: + MOV r7, r10 @ r7 = chase=next + MOVS r0, r0, LSR #1 @ r0 = lok>>1 C = bottom bit + ADC r8, r7, #0 @ r8 = chase+bit + MOV r8, r8, LSL #1 @ r8 = (chase+bit)<<1 + LDRH r10,[r6, r8] @ r10= next=t[chase+bit] + ADDS r1, r1, #1 @ r1 = i++ + @ stall Xscale + CMPLT r10,#0x8000 @ if (next & 0x8000) == 0 + BLT m3_loop + + ADD r1, r1, r4 @ r1 = i+read + MOV r0, r5 @ r0 = b + BL oggpack_adv @ oggpack_adv(b, i) + + CMP r10,#0x8000 + BLT duff + + MOV r7, r7, LSL #1 + CMP r8, r7 @ if bit==0 (chase+bit==chase) sets C + LDRNEH r14,[r6, r7] @ r14= t[chase] + MOVEQ r14,#0x8000 + ADC r12,r8, r14,LSR #15 @ r12= 1+((chase+bit)<<1)+(!bit || t[chase]0x0x8000) + ADC r12,r12,r14,LSR #15 @ r12= t + (1+chase+bit+(!bit || t[chase]0x0x8000))<<1 + LDRH r14,[r6, r12] @ r14= t[chase+bit+1 + BIC r10,r10,#0x8000 @ r3 = next &= ~0x8000 + @ stall Xscale + ORR r0, r14,r10,LSL #16 @ r7 = chase = (next<<16) | r14 + + LDMFD r13!,{r4-r8,r10,PC} + +meth4: + RSB r1, r4, #0 @ r1 = i-read = 0-read + MOV r7, #0 @ r7 = chase +m4_loop: + MOVS r0, r0, LSR #1 @ r0 = lok>>1 C = bottom bit + ADC r2, r7, r7 @ r8 = chase*2+C + LDR r7, [r6, r2, LSL #2] + ADDS r1, r1, #1 @ r1 = i-read++ (i-read<0 => i= 0) === (i >= read) + MVNGT r7, #0 @ if (i >= read) value to return = -1 + ADD r1, r1, r4 @ r1 = i-read+read+1 = i +1 + MOV r0, r5 @ r0 = b + BL oggpack_adv @ oggpack_adv(b, i+1); + MOV r0, r7 @ return chase + LDMFD r13!,{r4-r8,r10,PC} + +decode_map: + @ r0 = codebook *s + @ r1 = oggpack_buffer *b + @ r2 = int v + @ r3 = int point + STMFD r13!,{r4-r11,r14} + + MOV r4, r0 @ r4 = s + MOV r5, r1 @ r5 = b + MOV r6, r2 @ r6 = v + MOV r7, r3 @ r7 = point + BL decode_packed_entry_number + MOV r8, r0 + + MOV r0, r5 + BL oggpack_eop + CMP r0, #0 + BNE dm_duff + + @ r4 = s + @ r5 = b + @ r6 = v + @ r7 = point + @ r8 = entry + + LDR r1, [r4,#12] @ r1 = s->dec_type + LDR r2, [r4,#16] @ r2 = s->q_bits + LDR r3, [r4,#20] @ r3 = s->dim + LDR r5, [r4,#24] @ r5 = s->q_delp + LDR r11,[r4,#28] @ r11= s->q_minp + LDR r12,[r4,#32] @ r12= s->q_del = mul + LDR r14,[r4,#36] @ r14= s->q_min + SUBS r11,r7, r11 @ r11= add = point - s->q_minp + + MOVGT r14,r14,ASR r11 @ r14= add = s->q_min >> add (if add >0) + RSBLT r11,r11,#0 + MOVLT r14,r14,LSL r11 @ r14= add = s->q_min << -add (if add < 0) + + SUBS r5, r7, r5 @ r5 = shiftM = point - s->q_delp + LDR r7, [r4,#40] @ r7 = s->q_seq + RSBLT r5, r5, #0 @ if (shiftM<0) r5 =-shiftM + MOVLT r12,r12,LSL r5 @ r12=mul<<-shiftM + MOVLT r5, #0 @ r5 =shiftM = 0 + MOVGT r14,r14,LSL r5 @ add <<= shiftM + + CMP r7,#0 @ seqMask = (s->q_seq?-1:0) + MVNNE r7,#0 + + CMP r1, #2 + BEQ dm2 + BGT dm3 + CMP r1,#0 @ probably never happens + BLE dm_duff +dm1: + @ r1 = s->dec_type + @ r2 = s->q_bits + @ r3 = s->dim + @ r5 = shiftM + @ r6 = v + @ r7 = seqMask + @ r8 = entry + @ r12= mul + @ r14= add + MOV r0, #1 + RSB r0, r0, r0, LSL r2 @ r0 = mask = (1<q_bits)-1 + MOV r11,#0 @ r11= prev = 0 +dm1_loop: + AND r1, r8, r0 @ r1 = v = entry & mask + MLA r1, r12, r1, r14 @ r1 = (add + mul*v) + MOV r8, r8, LSR r2 @ r8 = entry>>s->q_bits + SUBS r3, r3, #1 + ADD r1, r11,r1, ASR r5 @ r1 = v = prev+((add+mul*v)>>shiftM) + AND r11,r1, r7 @ r11= prev = seqMask & v + STR r1, [r6], #4 @ *v++ = v + BGT dm1_loop + + MOV r0, #0 + LDMFD r13!,{r4-r11,PC} +dm2: + @ r1 = s->dec_type + @ r2 = s->q_bits + @ r3 = s->dim + @ r4 = s + @ r5 = shiftM + @ r6 = v + @ r7 = seqMask + @ r8 = entry + @ r12= mul + @ r14= add + LDR r1, [r4,#44] @ r1 = s->q_pack + LDR r4, [r4,#48] @ r4 = s->q_val + MOV r11,#0 @ r11= prev + MOV r0, #1 + RSB r0, r0, r0, LSL r1 @ r8 = mask = (1<q_pack)-1 + CMP r2,#8 + BGT dm2_hword +dm2_loop: + AND r2, r8, r0 @ r2 = entry & mask + LDRB r2, [r4, r2] @ r2 = v = q->val[entry & mask] + MOV r8, r8, LSR r1 @ r8 = entry>>q_pack + MLA r2, r12,r2, r14 @ r2 = (add+mul*v) + SUBS r3, r3, #1 + ADD r2, r11,r2, ASR r5 @ r2 = v = prev+(add+mul*v)>>shiftM + AND r11,r2, r7 @ r11= prev = seqMask & v + STR r2, [r6], #4 @ *v++ = v + BGT dm2_loop + MOV r0, #0 + LDMFD r13!,{r4-r11,PC} + +dm2_hword: + AND r2, r8, r0 @ r2 = entry & mask + MOV r2, r2, LSL #1 @ r2 = 2*r2 + LDRH r2, [r4, r2] @ r2 = v = q->val[entry & mask] + MOV r8, r8, LSR r1 @ r8 = entry>>q_pack + MLA r2, r12,r2, r14 @ r2 = (add+mul*v) + SUBS r3, r3, #1 + ADD r2, r11,r2, ASR r5 @ r2 = v = prev+(add+mul*v)>>shiftM + AND r11,r2, r7 @ r11= prev = seqMask & v + STR r2, [r6], #4 @ *v++ = v + BGT dm2_hword + MOV r0, #0 + LDMFD r13!,{r4-r11,PC} + +dm3: + @ r1 = s->dec_type + @ r2 = s->q_bits + @ r3 = s->dim + @ r4 = s + @ r5 = shiftM + @ r6 = v + @ r7 = seqMask + @ r8 = entry + @ r12= mul + @ r14= add + LDR r1, [r4,#44] @ r1 = s->q_pack + LDR r4, [r4,#48] @ r4 = s->q_val + CMP r2,#8 + MOV r11,#0 @ r11= prev + MLA r4,r1,r8,r4 @ r4 = ptr = s->q_val+entry*s->q_pack + + BGT dm3_hword +dm3_loop: + LDRB r2, [r4], #1 @ r2 = v = *ptr++ + SUBS r3, r3, #1 + MLA r2, r12,r2, r14 @ r2 = (add+mul*v) + ADD r2, r11,r2, ASR r5 @ r2 = v = prev+(add+mul*v)>>shiftM + AND r11,r2, r7 @ r11= prev = seqMask & v + STR r2, [r6], #4 @ *v++ = v + BGT dm3_loop + MOV r0, #0 + LDMFD r13!,{r4-r11,PC} + +dm3_hword: + LDRH r2, [r4], #2 @ r2 = *ptr++ + SUBS r3, r3, #1 + MLA r2, r12,r2, r14 @ r2 = (add+mul*v) + ADD r2, r11,r2, ASR r5 @ r2 = v = prev+(add+mul*v)>>shiftM + AND r11,r2, r7 @ r11= prev = seqMask & v + STR r2, [r6], #4 @ *v++ = v + BGT dm3_hword + MOV r0, #0 + LDMFD r13!,{r4-r11,PC} + +dm_duff: + MVN r0,#0 + LDMFD r13!,{r4-r11,PC} + +vorbis_book_decodevv_add: + @ r0 = codebook *book + @ r1 = ogg_int32_t **a + @ r2 = long offset + @ r3 = int ch + @ <> = b + @ <> = n + @ <> = point + STMFD r13!,{r4-r11,R14} + LDR r7, [r0, #13*4] @ r7 = used_entries + MOV r9, r0 @ r9 = book + MOV r10,r1 @ r10= 0xa[chptr] chptr=0 + MOV r6, r3 @ r6 = ch + ADD r8, r10,r3, LSL #2 @ r8 = 0xa[ch] + MOV r11,r2 @ r11= offset + CMP r7, #0 @ if (used_entries <= 0) + BLE vbdvva_exit @ exit + LDR r5, [r13,#10*4] @ r5 = n +vbdvva_loop1: + @ r5 = n + @ r6 = ch + @ r8 = 0xa[ch] + @ r9 = book + @ r10= 0xa[chptr] + @ r11= offset + MOV r0, r9 @ r0 = book + LDR r1, [r13,# 9*4] @ r1 = b + LDR r2, [r9, #14*4] @ r2 = v = dec_buf + LDR r3, [r13,#11*4] @ r3 = point + BL decode_map + CMP r0, #0 + BNE vbdvva_fail + + LDR r0, [r9, # 5*4] @ r0 = book->dim + LDR r1, [r9, #14*4] @ r1 = v = dec_buf +vbdvva_loop2: + CMP r5,#0 + BLE vbdvva_exit + LDR r2, [r10],#4 @ r2 = a[chptr++] + LDR r12,[r1], #4 @ r1 = v[j++] + CMP r10,r8 @ if (chptr == ch) + SUBEQ r10,r10,r6, LSL #2 @ chptr = 0 + LDR r14,[r2, r11,LSL #2]! @ r2 = 0xa[chptr++][i] r14=[r12] + ADDEQ r11,r11,#1 @ i++ + SUBEQ r5, r5, #1 @ n-- + SUBS r0, r0, #1 @ r0-- + ADD r12,r12,r14 @ r12= a[chptr++][i]+ v[j] + STR r12,[r2] @ r12= a[chptr++][i]+=v[j] + BGT vbdvva_loop2 + CMP r5,#0 + BGT vbdvva_loop1 +vbdvva_exit: + MOV r0, #0 @ return 0 + LDMFD r13!,{r4-r11,PC} +vbdvva_fail: + MVN r0, #0 @ return -1 + LDMFD r13!,{r4-r11,PC} + +_checksum: + @ r0 = ogg_reference *or + @ r1 = bytes + STMFD r13!,{r5-r6,r14} + + ADR r6,.Lcrc_lookup + LDR r5,[r6] + ADD r5,r6 + MOV r14,#0 @ r14= crc_reg = 0 + MOVS r12,r0 + BEQ _cs_end +_cs_loop1: + LDMIA r12,{r0,r2,r3,r12} @ r0 = or->buffer + @ r2 = or->begin + @ r3 = or->length + @ r12= or->next + LDR r0,[r0] @ r0 = or->buffer->data + CMP r1,r3 @ r3 = post = (bytes < or->length ? + MOVLT r3,r1 @ bytes : or->length) + MOVS r6,r3 @ r6 = j = post + BEQ _cs_no_bytes + ADD r0,r0,r2 @ r0 = or->buffer->data + or->begin +_cs_loop2: + LDRB r2, [r0],#1 @ r2 = data[j] + @ stall + @ stall Xscale + EOR r2, r2, r14,LSR #24 @ r2 = (crc_reg>>24)^data[j] + LDR r2, [r5, r2, LSL #2] @ r2 = crc_lkp[(crc_reg>>24)^data[j]] + SUBS r6, r6, #1 @ j-- + @ stall Xscale + EOR r14,r2, r14,LSL #8 @ r14= crc_reg = (crc_reg<<8)^r2 + BGT _cs_loop2 +_cs_no_bytes: + SUBS r1, r1, r3 + CMPNE r12,#0 + BNE _cs_loop1 +_cs_end: + MOV r0,r14 + LDMFD r13!,{r5-r6,PC} + +.Lcrc_lookup: + .WORD crc_lookup-.Lcrc_lookup + + @ END diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/dsp.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/dsp.c new file mode 100644 index 0000000..db809de --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/dsp.c @@ -0,0 +1,326 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: PCM data vector blocking, windowing and dis/reassembly + + ************************************************************************/ + +#include +#include "ogg.h" +#include "mdct.h" +#include "ivorbiscodec.h" +#include "codec_internal.h" +#include "misc.h" +#include "window_lookup.h" + +int vorbis_dsp_restart(vorbis_dsp_state *v){ + if(!v)return -1; + { + vorbis_info *vi=v->vi; + codec_setup_info *ci; + + if(!vi)return -1; + ci=vi->codec_setup; + if(!ci)return -1; + + v->out_end=-1; + v->out_begin=-1; + + v->granulepos=-1; + v->sequence=-1; + v->sample_count=-1; + } + return 0; +} + +int vorbis_dsp_init(vorbis_dsp_state *v,vorbis_info *vi){ + int i; + + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + + v->vi=vi; + + v->work=(ogg_int32_t **)_ogg_malloc(vi->channels*sizeof(*v->work)); + v->mdctright=(ogg_int32_t **)_ogg_malloc(vi->channels*sizeof(*v->mdctright)); + for(i=0;ichannels;i++){ + v->work[i]=(ogg_int32_t *)_ogg_calloc(1,(ci->blocksizes[1]>>1)* + sizeof(*v->work[i])); + v->mdctright[i]=(ogg_int32_t *)_ogg_calloc(1,(ci->blocksizes[1]>>2)* + sizeof(*v->mdctright[i])); + } + + v->lW=0; /* previous window size */ + v->W=0; /* current window size */ + + vorbis_dsp_restart(v); + return 0; +} + +vorbis_dsp_state *vorbis_dsp_create(vorbis_info *vi){ + vorbis_dsp_state *v=_ogg_calloc(1,sizeof(*v)); + vorbis_dsp_init(v,vi); + return v; +} + +void vorbis_dsp_clear(vorbis_dsp_state *v){ + int i; + if(v){ + vorbis_info *vi=v->vi; + + if(v->work){ + for(i=0;ichannels;i++) + if(v->work[i])_ogg_free(v->work[i]); + _ogg_free(v->work); + } + if(v->mdctright){ + for(i=0;ichannels;i++) + if(v->mdctright[i])_ogg_free(v->mdctright[i]); + _ogg_free(v->mdctright); + } + } +} + +void vorbis_dsp_destroy(vorbis_dsp_state *v){ + vorbis_dsp_clear(v); + _ogg_free(v); +} + +static LOOKUP_T *_vorbis_window(int left){ + switch(left){ + case 32: + return vwin64; + case 64: + return vwin128; + case 128: + return vwin256; + case 256: + return vwin512; + case 512: + return vwin1024; + case 1024: + return vwin2048; + case 2048: + return vwin4096; +#ifndef LIMIT_TO_64kHz + case 4096: + return vwin8192; +#endif + default: + return(0); + } +} + +/* pcm==0 indicates we just want the pending samples, no more */ +int vorbis_dsp_pcmout(vorbis_dsp_state *v,ogg_int16_t *pcm,int samples){ + vorbis_info *vi=v->vi; + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + if(v->out_begin>-1 && v->out_beginout_end){ + int n=v->out_end-v->out_begin; + if(pcm){ + int i; + if(n>samples)n=samples; + for(i=0;ichannels;i++) + mdct_unroll_lap(ci->blocksizes[0],ci->blocksizes[1], + v->lW,v->W,v->work[i],v->mdctright[i], + _vorbis_window(ci->blocksizes[0]>>1), + _vorbis_window(ci->blocksizes[1]>>1), + pcm+i,vi->channels, + v->out_begin,v->out_begin+n); + } + return(n); + } + return(0); +} + +int vorbis_dsp_read(vorbis_dsp_state *v,int s){ + if(s && v->out_begin+s>v->out_end)return(OV_EINVAL); + v->out_begin+=s; + return(0); +} + +long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op){ + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + oggpack_buffer opb; + int mode; + int modebits=0; + int v=ci->modes; + + oggpack_readinit(&opb,op->packet); + + /* Check the packet type */ + if(oggpack_read(&opb,1)!=0){ + /* Oops. This is not an audio data packet */ + return(OV_ENOTAUDIO); + } + + while(v>1){ + modebits++; + v>>=1; + } + + /* read our mode and pre/post windowsize */ + mode=oggpack_read(&opb,modebits); + if(mode==-1)return(OV_EBADPACKET); + return(ci->blocksizes[ci->mode_param[mode].blockflag]); +} + + +static int ilog(ogg_uint32_t v){ + int ret=0; + if(v)--v; + while(v){ + ret++; + v>>=1; + } + return(ret); +} + +int vorbis_dsp_synthesis(vorbis_dsp_state *vd,ogg_packet *op,int decodep){ + vorbis_info *vi=vd->vi; + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + int mode,i; + + oggpack_readinit(&vd->opb,op->packet); + + /* Check the packet type */ + if(oggpack_read(&vd->opb,1)!=0){ + /* Oops. This is not an audio data packet */ + return OV_ENOTAUDIO ; + } + + /* read our mode and pre/post windowsize */ + mode=oggpack_read(&vd->opb,ilog(ci->modes)); + if(mode==-1 || mode>=ci->modes) return OV_EBADPACKET; + + /* shift information we still need from last window */ + vd->lW=vd->W; + vd->W=ci->mode_param[mode].blockflag; + for(i=0;ichannels;i++) + mdct_shift_right(ci->blocksizes[vd->lW],vd->work[i],vd->mdctright[i]); + + if(vd->W){ + int temp; + oggpack_read(&vd->opb,1); + temp=oggpack_read(&vd->opb,1); + if(temp==-1) return OV_EBADPACKET; + } + + /* packet decode and portions of synthesis that rely on only this block */ + if(decodep){ + mapping_inverse(vd,ci->map_param+ci->mode_param[mode].mapping); + + if(vd->out_begin==-1){ + vd->out_begin=0; + vd->out_end=0; + }else{ + vd->out_begin=0; + vd->out_end=ci->blocksizes[vd->lW]/4+ci->blocksizes[vd->W]/4; + } + } + + /* track the frame number... This is for convenience, but also + making sure our last packet doesn't end with added padding. + + This is not foolproof! It will be confused if we begin + decoding at the last page after a seek or hole. In that case, + we don't have a starting point to judge where the last frame + is. For this reason, vorbisfile will always try to make sure + it reads the last two marked pages in proper sequence */ + + /* if we're out of sequence, dump granpos tracking until we sync back up */ + if(vd->sequence==-1 || vd->sequence+1 != op->packetno-3){ + /* out of sequence; lose count */ + vd->granulepos=-1; + vd->sample_count=-1; + } + + vd->sequence=op->packetno; + vd->sequence=vd->sequence-3; + + if(vd->sample_count==-1){ + vd->sample_count=0; + }else{ + vd->sample_count+= + ci->blocksizes[vd->lW]/4+ci->blocksizes[vd->W]/4; + } + + if(vd->granulepos==-1){ + if(op->granulepos!=-1){ /* only set if we have a + position to set to */ + + vd->granulepos=op->granulepos; + + /* is this a short page? */ + if(vd->sample_count>vd->granulepos){ + /* corner case; if this is both the first and last audio page, + then spec says the end is cut, not beginning */ + if(op->e_o_s){ + /* trim the end */ + /* no preceeding granulepos; assume we started at zero (we'd + have to in a short single-page stream) */ + /* granulepos could be -1 due to a seek, but that would result + in a long coun t, not short count */ + + vd->out_end-=(int)(vd->sample_count-vd->granulepos); + }else{ + /* trim the beginning */ + vd->out_begin+=(int)(vd->sample_count-vd->granulepos); + if(vd->out_begin>vd->out_end) + vd->out_begin=vd->out_end; + } + + } + + } + }else{ + vd->granulepos+= + ci->blocksizes[vd->lW]/4+ci->blocksizes[vd->W]/4; + if(op->granulepos!=-1 && vd->granulepos!=op->granulepos){ + + if(vd->granulepos>op->granulepos){ + long extra=(long)(vd->granulepos-op->granulepos); + + if(extra) + if(op->e_o_s){ + /* partial last frame. Strip the extra samples off */ + vd->out_end-=extra; + } /* else {Shouldn't happen *unless* the bitstream is out of + spec. Either way, believe the bitstream } */ + } /* else {Shouldn't happen *unless* the bitstream is out of + spec. Either way, believe the bitstream } */ + vd->granulepos=op->granulepos; + } + } + + return(0); +} diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor0.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor0.c new file mode 100644 index 0000000..581efcb --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor0.c @@ -0,0 +1,448 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: floor backend 0 implementation + + ************************************************************************/ + +#include +#include +#include +#include "ogg.h" +#include "ivorbiscodec.h" +#include "codec_internal.h" +#include "codebook.h" +#include "misc.h" +#include "os.h" + +#define LSP_FRACBITS 14 +extern const ogg_int32_t FLOOR_fromdB_LOOKUP[]; + +/*************** LSP decode ********************/ + +#include "lsp_lookup.h" + +/* interpolated 1./sqrt(p) where .5 <= a < 1. (.100000... to .111111...) in + 16.16 format + returns in m.8 format */ + +static long ADJUST_SQRT2[2]={8192,5792}; +static inline ogg_int32_t vorbis_invsqlook_i(long a,long e){ + long i=(a&0x7fff)>>(INVSQ_LOOKUP_I_SHIFT-1); + long d=a&INVSQ_LOOKUP_I_MASK; /* 0.10 */ + long val=INVSQ_LOOKUP_I[i]- /* 1.16 */ + ((INVSQ_LOOKUP_IDel[i]*d)>>INVSQ_LOOKUP_I_SHIFT); /* result 1.16 */ + val*=ADJUST_SQRT2[e&1]; + e=(e>>1)+21; + return(val>>e); +} + +/* interpolated lookup based fromdB function, domain -140dB to 0dB only */ +/* a is in n.12 format */ +#ifdef _LOW_ACCURACY_ +static inline ogg_int32_t vorbis_fromdBlook_i(long a){ + if(a>0) return 0x7fffffff; + if(a<(int)(((unsigned)-140)<<12)) return 0; + return FLOOR_fromdB_LOOKUP[((a+140)*467)>>20]<<9; +} +#else +static inline ogg_int32_t vorbis_fromdBlook_i(long a){ + if(a>0) return 0x7fffffff; + if(a<(int)(((unsigned)-140)<<12)) return 0; + return FLOOR_fromdB_LOOKUP[((a+(140<<12))*467)>>20]; +} +#endif + +/* interpolated lookup based cos function, domain 0 to PI only */ +/* a is in 0.16 format, where 0==0, 2^^16-1==PI, return 0.14 */ +static inline ogg_int32_t vorbis_coslook_i(long a){ + int i=a>>COS_LOOKUP_I_SHIFT; + int d=a&COS_LOOKUP_I_MASK; + return COS_LOOKUP_I[i]- ((d*(COS_LOOKUP_I[i]-COS_LOOKUP_I[i+1]))>> + COS_LOOKUP_I_SHIFT); +} + +/* interpolated half-wave lookup based cos function */ +/* a is in 0.16 format, where 0==0, 2^^16==PI, return .LSP_FRACBITS */ +static inline ogg_int32_t vorbis_coslook2_i(long a){ + int i=a>>COS_LOOKUP_I_SHIFT; + int d=a&COS_LOOKUP_I_MASK; + return ((COS_LOOKUP_I[i]<> + (COS_LOOKUP_I_SHIFT-LSP_FRACBITS+14); +} + +static const ogg_uint16_t barklook[54]={ + 0,51,102,154, 206,258,311,365, + 420,477,535,594, 656,719,785,854, + 926,1002,1082,1166, 1256,1352,1454,1564, + 1683,1812,1953,2107, 2276,2463,2670,2900, + 3155,3440,3756,4106, 4493,4919,5387,5901, + 6466,7094,7798,8599, 9528,10623,11935,13524, + 15453,17775,20517,23667, 27183,31004 +}; + +/* used in init only; interpolate the long way */ +static inline ogg_int32_t toBARK(int n){ + int i; + for(i=0;i<54;i++) + if(n>=barklook[i] && n>17); + } +} + +static const unsigned char MLOOP_1[64]={ + 0,10,11,11, 12,12,12,12, 13,13,13,13, 13,13,13,13, + 14,14,14,14, 14,14,14,14, 14,14,14,14, 14,14,14,14, + 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, + 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, +}; + +static const unsigned char MLOOP_2[64]={ + 0,4,5,5, 6,6,6,6, 7,7,7,7, 7,7,7,7, + 8,8,8,8, 8,8,8,8, 8,8,8,8, 8,8,8,8, + 9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9, + 9,9,9,9, 9,9,9,9, 9,9,9,9, 9,9,9,9, +}; + +static const unsigned char MLOOP_3[8]={0,1,2,2,3,3,3,3}; + +void vorbis_lsp_to_curve(ogg_int32_t *curve,int n,int ln, + ogg_int32_t *lsp,int m, + ogg_int32_t amp, + ogg_int32_t ampoffset, + ogg_int32_t nyq){ + + /* 0 <= m < 256 */ + + /* set up for using all int later */ + int i; + int ampoffseti=ampoffset*4096; + int ampi=amp; + ogg_int32_t *ilsp=(ogg_int32_t *)alloca(m*sizeof(*ilsp)); + + ogg_uint32_t inyq= (1UL<<31) / toBARK(nyq); + ogg_uint32_t imap= (1UL<<31) / ln; + ogg_uint32_t tBnyq1 = toBARK(nyq)<<1; + + /* Besenham for frequency scale to avoid a division */ + int f=0; + int fdx=n; + int fbase=nyq/fdx; + int ferr=0; + int fdy=nyq-fbase*fdx; + int map=0; + +#ifdef _LOW_ACCURACY_ + ogg_uint32_t nextbark=((tBnyq1<<11)/ln)>>12; +#else + ogg_uint32_t nextbark=MULT31(imap>>1,tBnyq1); +#endif + int nextf=barklook[nextbark>>14]+(((nextbark&0x3fff)* + (barklook[(nextbark>>14)+1]-barklook[nextbark>>14]))>>14); + + /* lsp is in 8.24, range 0 to PI; coslook wants it in .16 0 to 1*/ + for(i=0;i>10)*0x517d)>>14; +#endif + + /* safeguard against a malicious stream */ + if(val<0 || (val>>COS_LOOKUP_I_SHIFT)>=COS_LOOKUP_I_SZ){ + memset(curve,0,sizeof(*curve)*n); + return; + } + + ilsp[i]=vorbis_coslook_i(val); + } + + i=0; + while(i>15); + + +#ifdef _V_LSP_MATH_ASM + lsp_loop_asm(&qi,&pi,&qexp,ilsp,wi,m); + + pi=((pi*pi)>>16); + qi=((qi*qi)>>16); + + if(m&1){ + qexp= qexp*2-28*((m+1)>>1)+m; + pi*=(1<<14)-((wi*wi)>>14); + qi+=pi>>14; + }else{ + qexp= qexp*2-13*m; + + pi*=(1<<14)-wi; + qi*=(1<<14)+wi; + + qi=(qi+pi)>>14; + } + + if(qi&0xffff0000){ /* checks for 1.xxxxxxxxxxxxxxxx */ + qi>>=1; qexp++; + }else + lsp_norm_asm(&qi,&qexp); + +#else + + qi*=labs(ilsp[0]-wi); + pi*=labs(ilsp[1]-wi); + + for(j=3;j>25])) + if(!(shift=MLOOP_2[(pi|qi)>>19])) + shift=MLOOP_3[(pi|qi)>>16]; + + qi=(qi>>shift)*labs(ilsp[j-1]-wi); + pi=(pi>>shift)*labs(ilsp[j]-wi); + qexp+=shift; + } + if(!(shift=MLOOP_1[(pi|qi)>>25])) + if(!(shift=MLOOP_2[(pi|qi)>>19])) + shift=MLOOP_3[(pi|qi)>>16]; + + /* pi,qi normalized collectively, both tracked using qexp */ + + if(m&1){ + /* odd order filter; slightly assymetric */ + /* the last coefficient */ + qi=(qi>>shift)*labs(ilsp[j-1]-wi); + pi=(pi>>shift)<<14; + qexp+=shift; + + if(!(shift=MLOOP_1[(pi|qi)>>25])) + if(!(shift=MLOOP_2[(pi|qi)>>19])) + shift=MLOOP_3[(pi|qi)>>16]; + + pi>>=shift; + qi>>=shift; + qexp+=shift-14*((m+1)>>1); + + pi=((pi*pi)>>16); + qi=((qi*qi)>>16); + qexp=qexp*2+m; + + pi*=(1<<14)-((wi*wi)>>14); + qi+=pi>>14; + + }else{ + /* even order filter; still symmetric */ + + /* p*=p(1-w), q*=q(1+w), let normalization drift because it isn't + worth tracking step by step */ + + pi>>=shift; + qi>>=shift; + qexp+=shift-7*m; + + pi=((pi*pi)>>16); + qi=((qi*qi)>>16); + qexp=qexp*2+m; + + pi*=(1<<14)-wi; + qi*=(1<<14)+wi; + qi=(qi+pi)>>14; + + } + + + /* we've let the normalization drift because it wasn't important; + however, for the lookup, things must be normalized again. We + need at most one right shift or a number of left shifts */ + + if(qi&0xffff0000){ /* checks for 1.xxxxxxxxxxxxxxxx */ + qi>>=1; qexp++; + }else + while(qi && !(qi&0x8000)){ /* checks for 0.0xxxxxxxxxxxxxxx or less*/ + qi<<=1; qexp--; + } + +#endif + + amp=vorbis_fromdBlook_i(ampi* /* n.4 */ + vorbis_invsqlook_i(qi,qexp)- + /* m.8, m+n<=8 */ + ampoffseti); /* 8.12[0] */ + +#ifdef _LOW_ACCURACY_ + amp>>=9; +#endif + curve[i]= MULT31_SHIFT15(curve[i],amp); + + while(++i=fdx){ + ferr-=fdx; + f++; + } + f+=fbase; + + if(f>=nextf)break; + + curve[i]= MULT31_SHIFT15(curve[i],amp); + } + + while(1){ + map++; + + if(map+1>12; +#else + nextbark=MULT31((map+1)*(imap>>1),tBnyq1); +#endif + nextf=barklook[nextbark>>14]+ + (((nextbark&0x3fff)* + (barklook[(nextbark>>14)+1]-barklook[nextbark>>14]))>>14); + if(f<=nextf)break; + + }else{ + nextf=9999999; + break; + } + } + if(map>=ln){ + map=ln-1; /* guard against the approximation */ + nextf=9999999; + } + } +} + +/*************** vorbis decode glue ************/ + +void floor0_free_info(vorbis_info_floor *i){ + vorbis_info_floor0 *info=(vorbis_info_floor0 *)i; + if(info)_ogg_free(info); +} + +vorbis_info_floor *floor0_info_unpack (vorbis_info *vi,oggpack_buffer *opb){ + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + int j; + + vorbis_info_floor0 *info=(vorbis_info_floor0 *)_ogg_malloc(sizeof(*info)); + info->order=oggpack_read(opb,8); + info->rate=oggpack_read(opb,16); + info->barkmap=oggpack_read(opb,16); + info->ampbits=oggpack_read(opb,6); + info->ampdB=oggpack_read(opb,8); + info->numbooks=oggpack_read(opb,4)+1; + + if(info->order<1)goto err_out; + if(info->rate<1)goto err_out; + if(info->barkmap<1)goto err_out; + + for(j=0;jnumbooks;j++){ + info->books[j]=(char)oggpack_read(opb,8); + if(info->books[j]>=ci->books)goto err_out; + } + + if(oggpack_eop(opb))goto err_out; + return(info); + + err_out: + floor0_free_info(info); + return(NULL); +} + +int floor0_memosize(vorbis_info_floor *i){ + vorbis_info_floor0 *info=(vorbis_info_floor0 *)i; + return info->order+1; +} + +ogg_int32_t *floor0_inverse1(vorbis_dsp_state *vd,vorbis_info_floor *i, + ogg_int32_t *lsp){ + vorbis_info_floor0 *info=(vorbis_info_floor0 *)i; + int j,k; + + int ampraw=oggpack_read(&vd->opb,info->ampbits); + if(ampraw>0){ /* also handles the -1 out of data case */ + long maxval=(1<ampbits)-1; + int amp=((ampraw*info->ampdB)<<4)/maxval; + int booknum=oggpack_read(&vd->opb,_ilog(info->numbooks)); + + if(booknum!=-1 && booknumnumbooks){ /* be paranoid */ + codec_setup_info *ci=(codec_setup_info *)vd->vi->codec_setup; + codebook *b=ci->book_param+info->books[booknum]; + ogg_int32_t last=0; + + for(j=0;jorder;j+=b->dim) + if(vorbis_book_decodev_set(b,lsp+j,&vd->opb,b->dim,-24)==-1)goto eop; + for(j=0;jorder;){ + for(k=0;kdim;k++,j++)lsp[j]+=last; + last=lsp[j-1]; + } + + lsp[info->order]=amp; + return(lsp); + } + } + eop: + return(NULL); +} + +int floor0_inverse2(vorbis_dsp_state *vd,vorbis_info_floor *i, + ogg_int32_t *lsp,ogg_int32_t *out){ + vorbis_info_floor0 *info=(vorbis_info_floor0 *)i; + codec_setup_info *ci=(codec_setup_info *)vd->vi->codec_setup; + + if(lsp){ + ogg_int32_t amp=lsp[info->order]; + + /* take the coefficients back to a spectral envelope curve */ + vorbis_lsp_to_curve(out,ci->blocksizes[vd->W]/2,info->barkmap, + lsp,info->order,amp,info->ampdB, + info->rate>>1); + return(1); + } + memset(out,0,sizeof(*out)*ci->blocksizes[vd->W]/2); + return(0); +} + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor1.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor1.c new file mode 100644 index 0000000..7811aba --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor1.c @@ -0,0 +1,407 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: floor backend 1 implementation + + ************************************************************************/ + +#include +#include +#include +#include "ogg.h" +#include "ivorbiscodec.h" +#include "codec_internal.h" +#include "codebook.h" +#include "misc.h" + +extern const ogg_int32_t FLOOR_fromdB_LOOKUP[]; +#define floor1_rangedB 140 /* floor 1 fixed at -140dB to 0dB range */ +#define VIF_POSIT 63 + +/***********************************************/ + +void floor1_free_info(vorbis_info_floor *i){ + vorbis_info_floor1 *info=(vorbis_info_floor1 *)i; + if(info){ + if(info->klass)_ogg_free(info->klass); + if(info->partitionclass)_ogg_free(info->partitionclass); + if(info->postlist)_ogg_free(info->postlist); + if(info->forward_index)_ogg_free(info->forward_index); + if(info->hineighbor)_ogg_free(info->hineighbor); + if(info->loneighbor)_ogg_free(info->loneighbor); + memset(info,0,sizeof(*info)); + _ogg_free(info); + } +} + +static int ilog(unsigned int v){ + int ret=0; + while(v){ + ret++; + v>>=1; + } + return(ret); +} + +static void mergesort(ogg_uint8_t *index,ogg_uint16_t *vals,ogg_uint16_t n){ + ogg_uint16_t i,j; + ogg_uint8_t *temp,*A=index,*B=_ogg_malloc(n*sizeof(*B)); + + for(i=1;icodec_setup; + int j,k,count=0,maxclass=-1,rangebits; + + vorbis_info_floor1 *info=(vorbis_info_floor1 *)_ogg_calloc(1,sizeof(*info)); + /* read partitions */ + info->partitions=oggpack_read(opb,5); /* only 0 to 31 legal */ + info->partitionclass= + (ogg_uint8_t *)_ogg_malloc(info->partitions*sizeof(*info->partitionclass)); + for(j=0;jpartitions;j++){ + info->partitionclass[j]=(char)oggpack_read(opb,4); /* only 0 to 15 legal */ + if(maxclasspartitionclass[j])maxclass=info->partitionclass[j]; + } + + /* read partition classes */ + info->klass= + (floor1class *)_ogg_malloc((maxclass+1)*sizeof(*info->klass)); + for(j=0;jklass[j].class_dim=(char)oggpack_read(opb,3)+1; /* 1 to 8 */ + info->klass[j].class_subs=(char)oggpack_read(opb,2); /* 0,1,2,3 bits */ + if(oggpack_eop(opb)<0) goto err_out; + if(info->klass[j].class_subs) + info->klass[j].class_book=(unsigned char)oggpack_read(opb,8); + else + info->klass[j].class_book=0; + if(info->klass[j].class_book>=ci->books)goto err_out; + for(k=0;k<(1<klass[j].class_subs);k++){ + info->klass[j].class_subbook[k]=(unsigned char)(oggpack_read(opb,8)-1); + if(info->klass[j].class_subbook[k]>=ci->books && + info->klass[j].class_subbook[k]!=0xff)goto err_out; + } + } + + /* read the post list */ + info->mult=oggpack_read(opb,2)+1; /* only 1,2,3,4 legal now */ + rangebits=oggpack_read(opb,4); + + for(j=0,k=0;jpartitions;j++) + count+=info->klass[info->partitionclass[j]].class_dim; + info->postlist= + (ogg_uint16_t *)_ogg_malloc((count+2)*sizeof(*info->postlist)); + info->forward_index= + (ogg_uint8_t *)_ogg_malloc((count+2)*sizeof(*info->forward_index)); + info->loneighbor= + (ogg_uint8_t *)_ogg_malloc(count*sizeof(*info->loneighbor)); + info->hineighbor= + (ogg_uint8_t *)_ogg_malloc(count*sizeof(*info->hineighbor)); + + count=0; + for(j=0,k=0;jpartitions;j++){ + count+=info->klass[info->partitionclass[j]].class_dim; + for(;kpostlist[k+2]=(ogg_uint16_t)oggpack_read(opb,rangebits); + if(t>=(1<postlist[0]=0; + info->postlist[1]=1<posts=count+2; + + /* also store a sorted position index */ + for(j=0;jposts;j++)info->forward_index[j]=j; + mergesort(info->forward_index,info->postlist,info->posts); + + /* discover our neighbors for decode where we don't use fit flags + (that would push the neighbors outward) */ + for(j=0;jposts-2;j++){ + int lo=0; + int hi=1; + int lx=0; + int hx=info->postlist[1]; + int currentx=info->postlist[j+2]; + for(k=0;kpostlist[k]; + if(x>lx && xcurrentx){ + hi=k; + hx=x; + } + } + info->loneighbor[j]=lo; + info->hineighbor[j]=hi; + } + + return(info); + + err_out: + floor1_free_info(info); + return(NULL); +} + +#ifdef ONLY_C +static +#endif +int render_point(int x0,int x1,int y0,int y1,int x){ + y0&=0x7fff; /* mask off flag */ + y1&=0x7fff; + + { + int dy=y1-y0; + int adx=x1-x0; + int ady=abs(dy); + int err=ady*(x-x0); + + int off=err/adx; + if(dy<0)return(y0-off); + return(y0+off); + } +} + +#ifndef ONLY_C +void render_lineARM(int n, ogg_int32_t *d,const ogg_int32_t *floor, int base, int err, int adx, int ady); +#endif + +static void render_line(int n,int x0,int x1,int y0,int y1,ogg_int32_t *d){ + int dy; + int adx; + int ady; + int base; + int err; + const ogg_int32_t *floor; + + if(n>x1)n=x1; + n -= x0; + if (n <= 0 || y0 < 0 || y0 > 255 || y1 < 0 || y1 > 255) { + return; + } + dy=y1-y0; + adx=x1-x0; + ady=abs(dy); + base=dy/adx; + err=adx-1; + floor=&FLOOR_fromdB_LOOKUP[y0]; + d += x0; + ady-=abs(base*adx); + + /* We should add base each time, and then: + * if dy >=0 we occasionally add 1 + * else occasionally subtract 1. + * As an optimisation we say that if dy <0 we make base 1 smaller. + * Then we need to add 1 occassionally, rather than subtract 1 - but we + * need to add 1 in all the cases when we wouldn't have done so before. + * Previously we'd have added 1 (100*ady/adx)% of the time. Now we want + * to do so (100*(adx-ady)/adx)% of the time. + */ + if (dy < 0){ + base--; + ady = adx-ady; + err = 0; + } + + //if(x0); +#else + render_lineARM(n,d,floor,base,err,adx,ady); +#endif +} + +int floor1_memosize(vorbis_info_floor *i){ + vorbis_info_floor1 *info=(vorbis_info_floor1 *)i; + return info->posts; +} + +static int quant_look[4]={256,128,86,64}; + +ogg_int32_t *floor1_inverse1(vorbis_dsp_state *vd,vorbis_info_floor *in, + ogg_int32_t *fit_value){ + vorbis_info_floor1 *info=(vorbis_info_floor1 *)in; + codec_setup_info *ci=(codec_setup_info *)vd->vi->codec_setup; + + int i,j,k; + codebook *books=ci->book_param; + int quant_q=quant_look[info->mult-1]; + + /* unpack wrapped/predicted values from stream */ + if(oggpack_read(&vd->opb,1)==1){ + fit_value[0]=oggpack_read(&vd->opb,ilog(quant_q-1)); + fit_value[1]=oggpack_read(&vd->opb,ilog(quant_q-1)); + + /* partition by partition */ + /* partition by partition */ + for(i=0,j=2;ipartitions;i++){ + int classv=info->partitionclass[i]; + int cdim=info->klass[classv].class_dim; + int csubbits=info->klass[classv].class_subs; + int csub=1<klass[classv].class_book,&vd->opb); + + if(cval==-1)goto eop; + } + + for(k=0;kklass[classv].class_subbook[cval&(csub-1)]; + cval>>=csubbits; + if(book!=0xff){ + if((fit_value[j+k]=vorbis_book_decode(books+book,&vd->opb))==-1) + goto eop; + }else{ + fit_value[j+k]=0; + } + } + j+=cdim; + } + + /* unwrap positive values and reconsitute via linear interpolation */ + for(i=2;iposts;i++){ + int predicted=render_point(info->postlist[info->loneighbor[i-2]], + info->postlist[info->hineighbor[i-2]], + fit_value[info->loneighbor[i-2]], + fit_value[info->hineighbor[i-2]], + info->postlist[i]); + int hiroom=quant_q-predicted; + int loroom=predicted; + int room=(hiroom=room){ + if(hiroom>loroom){ + val = val-loroom; + }else{ + val = -1-(val-hiroom); + } + }else{ + if(val&1){ + val= -((val+1)>>1); + }else{ + val>>=1; + } + } + + fit_value[i]=val+predicted; + fit_value[info->loneighbor[i-2]]&=0x7fff; + fit_value[info->hineighbor[i-2]]&=0x7fff; + + }else{ + fit_value[i]=predicted|0x8000; + } + + } + + return(fit_value); + } + eop: + return(NULL); +} + +int floor1_inverse2(vorbis_dsp_state *vd,vorbis_info_floor *in, + ogg_int32_t *fit_value,ogg_int32_t *out){ + vorbis_info_floor1 *info=(vorbis_info_floor1 *)in; + + codec_setup_info *ci=(codec_setup_info *)vd->vi->codec_setup; + int n=ci->blocksizes[vd->W]/2; + int j; + + if(fit_value){ + /* render the lines */ + int hx=0; + int lx=0; + int ly=fit_value[0]*info->mult; + for(j=1;jposts;j++){ + int current=info->forward_index[j]; + int hy=fit_value[current]&0x7fff; + if(hy==fit_value[current]){ + + hy*=info->mult; + hx=info->postlist[current]; + + render_line(n,lx,hx,ly,hy,out); + + lx=hx; + ly=hy; + } + } + for(j=hx;j = err + @ <> = adx + @ <> = ady + MOV r12,r13 + STMFD r13!,{r4-r6,r11,r14} + LDMFD r12,{r11,r12,r14} @ r11 = err + @ r12 = adx + @ r14 = ady +rl_loop: + LDR r4,[r1] @ r4 = *d + LDR r5,[r2],r3,LSL #2 @ r5 = *floor r2 = floor+base + SUBS r11,r11,r14 @ err -= ady + ADDLT r11,r11,r12 @ if (err < 0) err+=adx + SMULL r6, r5, r4, r5 @ (r6,r5) = *d * *floor + ADDLT r2, r2, #4 @ floor+=1 + MOVS r6, r6, LSR #15 + ADC r5, r6, r5, LSL #17 @ r5 = MULT31_SHIFT15 + STR r5,[r1],#4 + SUBS r0, r0, #1 + BGT rl_loop + + LDMFD r13!,{r4-r6,r11,PC} + + @ END diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor_lookup.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor_lookup.c new file mode 100644 index 0000000..91c585c --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/floor_lookup.c @@ -0,0 +1,112 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: floor dB lookup + + ************************************************************************/ + +#include "os.h" + +#ifdef _LOW_ACCURACY_ +# define XdB(n) ((((n)>>8)+1)>>1) +#else +# define XdB(n) (n) +#endif + +const ogg_int32_t FLOOR_fromdB_LOOKUP[256]={ + XdB(0x000000e5), XdB(0x000000f4), XdB(0x00000103), XdB(0x00000114), + XdB(0x00000126), XdB(0x00000139), XdB(0x0000014e), XdB(0x00000163), + XdB(0x0000017a), XdB(0x00000193), XdB(0x000001ad), XdB(0x000001c9), + XdB(0x000001e7), XdB(0x00000206), XdB(0x00000228), XdB(0x0000024c), + XdB(0x00000272), XdB(0x0000029b), XdB(0x000002c6), XdB(0x000002f4), + XdB(0x00000326), XdB(0x0000035a), XdB(0x00000392), XdB(0x000003cd), + XdB(0x0000040c), XdB(0x00000450), XdB(0x00000497), XdB(0x000004e4), + XdB(0x00000535), XdB(0x0000058c), XdB(0x000005e8), XdB(0x0000064a), + XdB(0x000006b3), XdB(0x00000722), XdB(0x00000799), XdB(0x00000818), + XdB(0x0000089e), XdB(0x0000092e), XdB(0x000009c6), XdB(0x00000a69), + XdB(0x00000b16), XdB(0x00000bcf), XdB(0x00000c93), XdB(0x00000d64), + XdB(0x00000e43), XdB(0x00000f30), XdB(0x0000102d), XdB(0x0000113a), + XdB(0x00001258), XdB(0x0000138a), XdB(0x000014cf), XdB(0x00001629), + XdB(0x0000179a), XdB(0x00001922), XdB(0x00001ac4), XdB(0x00001c82), + XdB(0x00001e5c), XdB(0x00002055), XdB(0x0000226f), XdB(0x000024ac), + XdB(0x0000270e), XdB(0x00002997), XdB(0x00002c4b), XdB(0x00002f2c), + XdB(0x0000323d), XdB(0x00003581), XdB(0x000038fb), XdB(0x00003caf), + XdB(0x000040a0), XdB(0x000044d3), XdB(0x0000494c), XdB(0x00004e10), + XdB(0x00005323), XdB(0x0000588a), XdB(0x00005e4b), XdB(0x0000646b), + XdB(0x00006af2), XdB(0x000071e5), XdB(0x0000794c), XdB(0x0000812e), + XdB(0x00008993), XdB(0x00009283), XdB(0x00009c09), XdB(0x0000a62d), + XdB(0x0000b0f9), XdB(0x0000bc79), XdB(0x0000c8b9), XdB(0x0000d5c4), + XdB(0x0000e3a9), XdB(0x0000f274), XdB(0x00010235), XdB(0x000112fd), + XdB(0x000124dc), XdB(0x000137e4), XdB(0x00014c29), XdB(0x000161bf), + XdB(0x000178bc), XdB(0x00019137), XdB(0x0001ab4a), XdB(0x0001c70e), + XdB(0x0001e4a1), XdB(0x0002041f), XdB(0x000225aa), XdB(0x00024962), + XdB(0x00026f6d), XdB(0x000297f0), XdB(0x0002c316), XdB(0x0002f109), + XdB(0x000321f9), XdB(0x00035616), XdB(0x00038d97), XdB(0x0003c8b4), + XdB(0x000407a7), XdB(0x00044ab2), XdB(0x00049218), XdB(0x0004de23), + XdB(0x00052f1e), XdB(0x0005855c), XdB(0x0005e135), XdB(0x00064306), + XdB(0x0006ab33), XdB(0x00071a24), XdB(0x0007904b), XdB(0x00080e20), + XdB(0x00089422), XdB(0x000922da), XdB(0x0009bad8), XdB(0x000a5cb6), + XdB(0x000b091a), XdB(0x000bc0b1), XdB(0x000c8436), XdB(0x000d5471), + XdB(0x000e3233), XdB(0x000f1e5f), XdB(0x001019e4), XdB(0x001125c1), + XdB(0x00124306), XdB(0x001372d5), XdB(0x0014b663), XdB(0x00160ef7), + XdB(0x00177df0), XdB(0x001904c1), XdB(0x001aa4f9), XdB(0x001c603d), + XdB(0x001e384f), XdB(0x00202f0f), XdB(0x0022467a), XdB(0x002480b1), + XdB(0x0026dff7), XdB(0x002966b3), XdB(0x002c1776), XdB(0x002ef4fc), + XdB(0x0032022d), XdB(0x00354222), XdB(0x0038b828), XdB(0x003c67c2), + XdB(0x004054ae), XdB(0x004482e8), XdB(0x0048f6af), XdB(0x004db488), + XdB(0x0052c142), XdB(0x005821ff), XdB(0x005ddc33), XdB(0x0063f5b0), + XdB(0x006a74a7), XdB(0x00715faf), XdB(0x0078bdce), XdB(0x0080967f), + XdB(0x0088f1ba), XdB(0x0091d7f9), XdB(0x009b5247), XdB(0x00a56a41), + XdB(0x00b02a27), XdB(0x00bb9ce2), XdB(0x00c7ce12), XdB(0x00d4ca17), + XdB(0x00e29e20), XdB(0x00f15835), XdB(0x0101074b), XdB(0x0111bb4e), + XdB(0x01238531), XdB(0x01367704), XdB(0x014aa402), XdB(0x016020a7), + XdB(0x017702c3), XdB(0x018f6190), XdB(0x01a955cb), XdB(0x01c4f9cf), + XdB(0x01e269a8), XdB(0x0201c33b), XdB(0x0223265a), XdB(0x0246b4ea), + XdB(0x026c9302), XdB(0x0294e716), XdB(0x02bfda13), XdB(0x02ed9793), + XdB(0x031e4e09), XdB(0x03522ee4), XdB(0x03896ed0), XdB(0x03c445e2), + XdB(0x0402efd6), XdB(0x0445ac4b), XdB(0x048cbefc), XdB(0x04d87013), + XdB(0x05290c67), XdB(0x057ee5ca), XdB(0x05da5364), XdB(0x063bb204), + XdB(0x06a36485), XdB(0x0711d42b), XdB(0x0787710e), XdB(0x0804b299), + XdB(0x088a17ef), XdB(0x0918287e), XdB(0x09af747c), XdB(0x0a50957e), + XdB(0x0afc2f19), XdB(0x0bb2ef7f), XdB(0x0c759034), XdB(0x0d44d6ca), + XdB(0x0e2195bc), XdB(0x0f0cad0d), XdB(0x10070b62), XdB(0x1111aeea), + XdB(0x122da66c), XdB(0x135c120f), XdB(0x149e24d9), XdB(0x15f525b1), + XdB(0x176270e3), XdB(0x18e7794b), XdB(0x1a85c9ae), XdB(0x1c3f06d1), + XdB(0x1e14f07d), XdB(0x200963d7), XdB(0x221e5ccd), XdB(0x2455f870), + XdB(0x26b2770b), XdB(0x29363e2b), XdB(0x2be3db5c), XdB(0x2ebe06b6), + XdB(0x31c7a55b), XdB(0x3503ccd4), XdB(0x3875c5aa), XdB(0x3c210f44), + XdB(0x4009632b), XdB(0x4432b8cf), XdB(0x48a149bc), XdB(0x4d59959e), + XdB(0x52606733), XdB(0x57bad899), XdB(0x5d6e593a), XdB(0x6380b298), + XdB(0x69f80e9a), XdB(0x70dafda8), XdB(0x78307d76), XdB(0x7fffffff), +}; + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/framing.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/framing.c new file mode 100644 index 0000000..4aca8ba --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/framing.c @@ -0,0 +1,1169 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: decode Ogg streams back into raw packets + + note: The CRC code is directly derived from public domain code by + Ross Williams (ross@guest.adelaide.edu.au). See docs/framing.html + for details. + + ************************************************************************/ + +#include +#include +#include "ogg.h" +#include "misc.h" + + +/* A complete description of Ogg framing exists in docs/framing.html */ + +/* basic, centralized Ogg memory management based on linked lists of + references to refcounted memory buffers. References and buffers + are both recycled. Buffers are passed around and consumed in + reference form. */ + +static ogg_buffer_state *ogg_buffer_create(void){ + ogg_buffer_state *bs=_ogg_calloc(1,sizeof(*bs)); + return bs; +} + +/* destruction is 'lazy'; there may be memory references outstanding, + and yanking the buffer state out from underneath would be + antisocial. Dealloc what is currently unused and have + _release_one watch for the stragglers to come in. When they do, + finish destruction. */ + +/* call the helper while holding lock */ +static void _ogg_buffer_destroy(ogg_buffer_state *bs){ + ogg_buffer *bt; + ogg_reference *rt; + + if(bs->shutdown){ + + bt=bs->unused_buffers; + rt=bs->unused_references; + + while(bt){ + ogg_buffer *b=bt; + bt=b->ptr.next; + if(b->data)_ogg_free(b->data); + _ogg_free(b); + } + bs->unused_buffers=0; + while(rt){ + ogg_reference *r=rt; + rt=r->next; + _ogg_free(r); + } + bs->unused_references=0; + + if(!bs->outstanding) + _ogg_free(bs); + + } +} + +static void ogg_buffer_destroy(ogg_buffer_state *bs){ + bs->shutdown=1; + _ogg_buffer_destroy(bs); +} + +static ogg_buffer *_fetch_buffer(ogg_buffer_state *bs,long bytes){ + ogg_buffer *ob; + bs->outstanding++; + + /* do we have an unused buffer sitting in the pool? */ + if(bs->unused_buffers){ + ob=bs->unused_buffers; + bs->unused_buffers=ob->ptr.next; + + /* if the unused buffer is too small, grow it */ + if(ob->sizedata=_ogg_realloc(ob->data,bytes); + ob->size=bytes; + } + }else{ + /* allocate a new buffer */ + ob=_ogg_malloc(sizeof(*ob)); + ob->data=_ogg_malloc(bytes<16?16:bytes); + ob->size=bytes; + } + + ob->refcount=1; + ob->ptr.owner=bs; + return ob; +} + +static ogg_reference *_fetch_ref(ogg_buffer_state *bs){ + ogg_reference *or; + bs->outstanding++; + + /* do we have an unused reference sitting in the pool? */ + if(bs->unused_references){ + or=bs->unused_references; + bs->unused_references=or->next; + }else{ + /* allocate a new reference */ + or=_ogg_malloc(sizeof(*or)); + } + + or->begin=0; + or->length=0; + or->next=0; + return or; +} + +/* fetch a reference pointing to a fresh, initially continguous buffer + of at least [bytes] length */ +static ogg_reference *ogg_buffer_alloc(ogg_buffer_state *bs,long bytes){ + ogg_buffer *ob=_fetch_buffer(bs,bytes); + ogg_reference *or=_fetch_ref(bs); + or->buffer=ob; + return or; +} + +/* enlarge the data buffer in the current link */ +static void ogg_buffer_realloc(ogg_reference *or,long bytes){ + ogg_buffer *ob=or->buffer; + + /* if the unused buffer is too small, grow it */ + if(ob->sizedata=_ogg_realloc(ob->data,bytes); + ob->size=bytes; + } +} + +static void _ogg_buffer_mark_one(ogg_reference *or){ + or->buffer->refcount++; +} + +/* increase the refcount of the buffers to which the reference points */ +static void ogg_buffer_mark(ogg_reference *or){ + while(or){ + _ogg_buffer_mark_one(or); + or=or->next; + } +} + +/* duplicate a reference (pointing to the same actual buffer memory) + and increment buffer refcount. If the desired segment is zero + length, a zero length ref is returned. */ +static ogg_reference *ogg_buffer_sub(ogg_reference *or,long length){ + ogg_reference *ret=0,*head=0; + + /* duplicate the reference chain; increment refcounts */ + while(or && length){ + ogg_reference *temp=_fetch_ref(or->buffer->ptr.owner); + if(head) + head->next=temp; + else + ret=temp; + head=temp; + head->buffer=or->buffer; + head->begin=or->begin; + head->length=length; + if(head->length>or->length) + head->length=or->length; + + length-=head->length; + or=or->next; + } + + ogg_buffer_mark(ret); + return ret; +} + +ogg_reference *ogg_buffer_dup(ogg_reference *or){ + ogg_reference *ret=0,*head=0; + /* duplicate the reference chain; increment refcounts */ + while(or){ + ogg_reference *temp=_fetch_ref(or->buffer->ptr.owner); + if(head) + head->next=temp; + else + ret=temp; + head=temp; + head->buffer=or->buffer; + head->begin=or->begin; + head->length=or->length; + or=or->next; + } + + ogg_buffer_mark(ret); + return ret; +} + +/* split a reference into two references; 'return' is a reference to + the buffer preceeding pos and 'head'/'tail' are the buffer past the + split. If pos is at or past the end of the passed in segment, + 'head/tail' are NULL */ +static ogg_reference *ogg_buffer_split(ogg_reference **tail, + ogg_reference **head,long pos){ + + /* walk past any preceeding fragments to one of: + a) the exact boundary that seps two fragments + b) the fragment that needs split somewhere in the middle */ + ogg_reference *ret=*tail; + ogg_reference *or=*tail; + + while(or && pos>or->length){ + pos-=or->length; + or=or->next; + } + + if(!or || pos==0){ + + return 0; + + }else{ + + if(pos>=or->length){ + /* exact split, or off the end? */ + if(or->next){ + + /* a split */ + *tail=or->next; + or->next=0; + + }else{ + + /* off or at the end */ + *tail=*head=0; + + } + }else{ + + /* split within a fragment */ + long lengthA=pos; + long beginB=or->begin+pos; + long lengthB=or->length-pos; + + /* make a new reference to tail the second piece */ + *tail=_fetch_ref(or->buffer->ptr.owner); + + (*tail)->buffer=or->buffer; + (*tail)->begin=beginB; + (*tail)->length=lengthB; + (*tail)->next=or->next; + _ogg_buffer_mark_one(*tail); + if(head && or==*head)*head=*tail; + + /* update the first piece */ + or->next=0; + or->length=lengthA; + + } + } + return ret; +} + +static void ogg_buffer_release_one(ogg_reference *or){ + ogg_buffer *ob=or->buffer; + ogg_buffer_state *bs=ob->ptr.owner; + + ob->refcount--; + if(ob->refcount==0){ + bs->outstanding--; /* for the returned buffer */ + ob->ptr.next=bs->unused_buffers; + bs->unused_buffers=ob; + } + + bs->outstanding--; /* for the returned reference */ + or->next=bs->unused_references; + bs->unused_references=or; + + _ogg_buffer_destroy(bs); /* lazy cleanup (if needed) */ + +} + +/* release the references, decrease the refcounts of buffers to which + they point, release any buffers with a refcount that drops to zero */ +static void ogg_buffer_release(ogg_reference *or){ + while(or){ + ogg_reference *next=or->next; + ogg_buffer_release_one(or); + or=next; + } +} + +static ogg_reference *ogg_buffer_pretruncate(ogg_reference *or,long pos){ + /* release preceeding fragments we don't want */ + while(or && pos>=or->length){ + ogg_reference *next=or->next; + pos-=or->length; + ogg_buffer_release_one(or); + or=next; + } + if (or) { + or->begin+=pos; + or->length-=pos; + } + return or; +} + +static ogg_reference *ogg_buffer_walk(ogg_reference *or){ + if(!or)return NULL; + while(or->next){ + or=or->next; + } + return(or); +} + +/* *head is appended to the front end (head) of *tail; both continue to + be valid pointers, with *tail at the tail and *head at the head */ +static ogg_reference *ogg_buffer_cat(ogg_reference *tail, ogg_reference *head){ + if(!tail)return head; + + while(tail->next){ + tail=tail->next; + } + tail->next=head; + return ogg_buffer_walk(head); +} + +static void _positionB(oggbyte_buffer *b,int pos){ + if(pospos){ + /* start at beginning, scan forward */ + b->ref=b->baseref; + b->pos=0; + b->end=b->pos+b->ref->length; + b->ptr=b->ref->buffer->data+b->ref->begin; + } +} + +static void _positionF(oggbyte_buffer *b,int pos){ + /* scan forward for position */ + while(pos>=b->end){ + /* just seek forward */ + b->pos+=b->ref->length; + b->ref=b->ref->next; + b->end=b->ref->length+b->pos; + b->ptr=b->ref->buffer->data+b->ref->begin; + } +} + +static int oggbyte_init(oggbyte_buffer *b,ogg_reference *or){ + memset(b,0,sizeof(*b)); + if(or){ + b->ref=b->baseref=or; + b->pos=0; + b->end=b->ref->length; + b->ptr=b->ref->buffer->data+b->ref->begin; + return 0; + }else + return -1; +} + +static void oggbyte_set4(oggbyte_buffer *b,ogg_uint32_t val,int pos){ + int i; + _positionB(b,pos); + for(i=0;i<4;i++){ + _positionF(b,pos); + b->ptr[pos-b->pos]=val; + val>>=8; + ++pos; + } +} + +static unsigned char oggbyte_read1(oggbyte_buffer *b,int pos){ + _positionB(b,pos); + _positionF(b,pos); + return b->ptr[pos-b->pos]; +} + +static ogg_uint32_t oggbyte_read4(oggbyte_buffer *b,int pos){ + ogg_uint32_t ret; + _positionB(b,pos); + _positionF(b,pos); + ret=b->ptr[pos-b->pos]; + _positionF(b,++pos); + ret|=b->ptr[pos-b->pos]<<8; + _positionF(b,++pos); + ret|=b->ptr[pos-b->pos]<<16; + _positionF(b,++pos); + ret|=b->ptr[pos-b->pos]<<24; + return ret; +} + +static ogg_int64_t oggbyte_read8(oggbyte_buffer *b,int pos){ + ogg_int64_t ret; + unsigned char t[7]; + int i; + _positionB(b,pos); + for(i=0;i<7;i++){ + _positionF(b,pos); + t[i]=b->ptr[pos++ -b->pos]; + } + + _positionF(b,pos); + ret=b->ptr[pos-b->pos]; + + for(i=6;i>=0;--i) + ret= ret<<8 | t[i]; + + return ret; +} + +/* Now we get to the actual framing code */ + +int ogg_page_version(ogg_page *og){ + oggbyte_buffer ob; + if(oggbyte_init(&ob,og->header))return -1; + return oggbyte_read1(&ob,4); +} + +int ogg_page_continued(ogg_page *og){ + oggbyte_buffer ob; + if(oggbyte_init(&ob,og->header))return -1; + return oggbyte_read1(&ob,5)&0x01; +} + +int ogg_page_bos(ogg_page *og){ + oggbyte_buffer ob; + if(oggbyte_init(&ob,og->header))return -1; + return oggbyte_read1(&ob,5)&0x02; +} + +int ogg_page_eos(ogg_page *og){ + oggbyte_buffer ob; + if(oggbyte_init(&ob,og->header))return -1; + return oggbyte_read1(&ob,5)&0x04; +} + +ogg_int64_t ogg_page_granulepos(ogg_page *og){ + oggbyte_buffer ob; + if(oggbyte_init(&ob,og->header))return -1; + return oggbyte_read8(&ob,6); +} + +ogg_uint32_t ogg_page_serialno(ogg_page *og){ + oggbyte_buffer ob; + if(oggbyte_init(&ob,og->header)) return 0xffffffffUL; + return oggbyte_read4(&ob,14); +} + +ogg_uint32_t ogg_page_pageno(ogg_page *og){ + oggbyte_buffer ob; + if(oggbyte_init(&ob,og->header))return 0xffffffffUL; + return oggbyte_read4(&ob,18); +} + +/* returns the number of packets that are completed on this page (if + the leading packet is begun on a previous page, but ends on this + page, it's counted */ + +/* NOTE: +If a page consists of a packet begun on a previous page, and a new +packet begun (but not completed) on this page, the return will be: + ogg_page_packets(page) ==1, + ogg_page_continued(page) !=0 + +If a page happens to be a single packet that was begun on a +previous page, and spans to the next page (in the case of a three or +more page packet), the return will be: + ogg_page_packets(page) ==0, + ogg_page_continued(page) !=0 +*/ + +int ogg_page_packets(ogg_page *og){ + int i; + int n; + int count=0; + oggbyte_buffer ob; + oggbyte_init(&ob,og->header); + + n=oggbyte_read1(&ob,26); + for(i=0;ibufferpool=ogg_buffer_create(); +} + +ogg_sync_state *ogg_sync_create(void){ + ogg_sync_state *oy=_ogg_calloc(1,sizeof(*oy)); + memset(oy,0,sizeof(*oy)); + oy->bufferpool=ogg_buffer_create(); + return oy; +} + +int ogg_sync_clear(ogg_sync_state *oy){ + if(oy){ + ogg_sync_reset(oy); + ogg_buffer_destroy(oy->bufferpool); + memset(oy,0,sizeof(*oy)); + } + return OGG_SUCCESS; +} + +int ogg_sync_destroy(ogg_sync_state *oy){ + if(oy){ + ogg_sync_reset(oy); + ogg_buffer_destroy(oy->bufferpool); + memset(oy,0,sizeof(*oy)); + _ogg_free(oy); + } + return OGG_SUCCESS; +} + +unsigned char *ogg_sync_bufferin(ogg_sync_state *oy, long bytes){ + + /* [allocate and] expose a buffer for data submission. + + If there is no head fragment + allocate one and expose it + else + if the current head fragment has sufficient unused space + expose it + else + if the current head fragment is unused + resize and expose it + else + allocate new fragment and expose it + */ + + /* base case; fifo uninitialized */ + if(!oy->fifo_head){ + oy->fifo_head=oy->fifo_tail=ogg_buffer_alloc(oy->bufferpool,bytes); + return oy->fifo_head->buffer->data; + } + + /* space left in current fragment case */ + if(oy->fifo_head->buffer->size- + oy->fifo_head->length- + oy->fifo_head->begin >= bytes) + return oy->fifo_head->buffer->data+ + oy->fifo_head->length+oy->fifo_head->begin; + + /* current fragment is unused, but too small */ + if(!oy->fifo_head->length){ + ogg_buffer_realloc(oy->fifo_head,bytes); + return oy->fifo_head->buffer->data+oy->fifo_head->begin; + } + + /* current fragment used/full; get new fragment */ + { + ogg_reference *new=ogg_buffer_alloc(oy->bufferpool,bytes); + oy->fifo_head->next=new; + oy->fifo_head=new; + } + return oy->fifo_head->buffer->data; +} + +int ogg_sync_wrote(ogg_sync_state *oy, long bytes){ + if(!oy->fifo_head)return OGG_EINVAL; + if(oy->fifo_head->buffer->size-oy->fifo_head->length-oy->fifo_head->begin < + bytes)return OGG_EINVAL; + oy->fifo_head->length+=bytes; + oy->fifo_fill+=bytes; + return OGG_SUCCESS; +} + +#ifndef ONLY_C +ogg_uint32_t _checksum(ogg_reference *or, int bytes); +#else +static ogg_uint32_t _checksum(ogg_reference *or, int bytes){ + ogg_uint32_t crc_reg=0; + int j,post; + + while(or){ + unsigned char *data=or->buffer->data+or->begin; + post=(byteslength?bytes:or->length); + for(j=0;j> 24)&0xff)^data[j]]; + bytes-=j; + or=or->next; + } + + return crc_reg; +} +#endif + +/* sync the stream. This is meant to be useful for finding page + boundaries. + + return values for this: + -n) skipped n bytes + 0) page not ready; more data (no bytes skipped) + n) page synced at current location; page length n bytes + +*/ + +long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){ + oggbyte_buffer page; + long bytes,ret=0; + + ogg_page_release(og); + + bytes=oy->fifo_fill; + oggbyte_init(&page,oy->fifo_tail); + + if(oy->headerbytes==0){ + if(bytes<27)goto sync_out; /* not enough for even a minimal header */ + + /* verify capture pattern */ + if(oggbyte_read1(&page,0)!=(int)'O' || + oggbyte_read1(&page,1)!=(int)'g' || + oggbyte_read1(&page,2)!=(int)'g' || + oggbyte_read1(&page,3)!=(int)'S' ) goto sync_fail; + + oy->headerbytes=oggbyte_read1(&page,26)+27; + } + if(bytesheaderbytes)goto sync_out; /* not enough for header + + seg table */ + if(oy->bodybytes==0){ + int i; + /* count up body length in the segment table */ + for(i=0;iheaderbytes-27;i++) + oy->bodybytes+=oggbyte_read1(&page,27+i); + } + + if(oy->bodybytes+oy->headerbytes>bytes)goto sync_out; + + /* we have what appears to be a complete page; last test: verify + checksum */ + { + ogg_uint32_t chksum=oggbyte_read4(&page,22); + oggbyte_set4(&page,0,22); + + /* Compare checksums; memory continues to be common access */ + if(chksum!=_checksum(oy->fifo_tail,oy->bodybytes+oy->headerbytes)){ + + /* D'oh. Mismatch! Corrupt page (or miscapture and not a page + at all). replace the computed checksum with the one actually + read in; remember all the memory is common access */ + + oggbyte_set4(&page,chksum,22); + goto sync_fail; + } + oggbyte_set4(&page,chksum,22); + } + + /* We have a page. Set up page return. */ + if(og){ + /* set up page output */ + og->header=ogg_buffer_split(&oy->fifo_tail,&oy->fifo_head,oy->headerbytes); + og->header_len=oy->headerbytes; + og->body=ogg_buffer_split(&oy->fifo_tail,&oy->fifo_head,oy->bodybytes); + og->body_len=oy->bodybytes; + }else{ + /* simply advance */ + oy->fifo_tail= + ogg_buffer_pretruncate(oy->fifo_tail,oy->headerbytes+oy->bodybytes); + if(!oy->fifo_tail)oy->fifo_head=0; + } + + ret=oy->headerbytes+oy->bodybytes; + oy->unsynced=0; + oy->headerbytes=0; + oy->bodybytes=0; + oy->fifo_fill-=ret; + + return ret; + + sync_fail: + + oy->headerbytes=0; + oy->bodybytes=0; + oy->fifo_tail=ogg_buffer_pretruncate(oy->fifo_tail,1); + ret--; + + /* search forward through fragments for possible capture */ + while(oy->fifo_tail){ + /* invariant: fifo_cursor points to a position in fifo_tail */ + unsigned char *now=oy->fifo_tail->buffer->data+oy->fifo_tail->begin; + unsigned char *next=memchr(now, 'O', oy->fifo_tail->length); + + if(next){ + /* possible capture in this segment */ + long bytes=next-now; + oy->fifo_tail=ogg_buffer_pretruncate(oy->fifo_tail,bytes); + ret-=bytes; + break; + }else{ + /* no capture. advance to next segment */ + long bytes=oy->fifo_tail->length; + ret-=bytes; + oy->fifo_tail=ogg_buffer_pretruncate(oy->fifo_tail,bytes); + } + } + if(!oy->fifo_tail)oy->fifo_head=0; + oy->fifo_fill+=ret; + + sync_out: + return ret; +} + +/* sync the stream and get a page. Keep trying until we find a page. + Supress 'sync errors' after reporting the first. + + return values: + OGG_HOLE) recapture (hole in data) + 0) need more data + 1) page returned + + Returns pointers into buffered data; invalidated by next call to + _stream, _clear, _init, or _buffer */ + +int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){ + + /* all we need to do is verify a page at the head of the stream + buffer. If it doesn't verify, we look for the next potential + frame */ + + while(1){ + long ret=ogg_sync_pageseek(oy,og); + if(ret>0){ + /* have a page */ + return 1; + } + if(ret==0){ + /* need more data */ + return 0; + } + + /* head did not start a synced page... skipped some bytes */ + if(!oy->unsynced){ + oy->unsynced=1; + return OGG_HOLE; + } + + /* loop. keep looking */ + + } +} + +/* clear things to an initial state. Good to call, eg, before seeking */ +int ogg_sync_reset(ogg_sync_state *oy){ + + ogg_buffer_release(oy->fifo_tail); + oy->fifo_tail=0; + oy->fifo_head=0; + oy->fifo_fill=0; + + oy->unsynced=0; + oy->headerbytes=0; + oy->bodybytes=0; + return OGG_SUCCESS; +} + +void ogg_stream_init(ogg_stream_state *os, int serialno){ + memset(os, 0, sizeof(*os)); + os->serialno=serialno; + os->pageno=-1; +} + +ogg_stream_state *ogg_stream_create(int serialno){ + ogg_stream_state *os=_ogg_calloc(1,sizeof(*os)); + os->serialno=serialno; + os->pageno=-1; + return os; +} + +int ogg_stream_clear(ogg_stream_state *os){ + if(os){ + ogg_buffer_release(os->header_tail); + ogg_buffer_release(os->body_tail); + memset(os,0,sizeof(*os)); + } + return OGG_SUCCESS; +} + +int ogg_stream_destroy(ogg_stream_state *os){ + if(os){ + ogg_buffer_release(os->header_tail); + ogg_buffer_release(os->body_tail); + memset(os,0,sizeof(*os)); + _ogg_free(os); + } + return OGG_SUCCESS; +} + + +#define FINFLAG 0x80000000UL +#define FINMASK 0x7fffffffUL + +static void _next_lace(oggbyte_buffer *ob,ogg_stream_state *os){ + /* search ahead one lace */ + os->body_fill_next=0; + while(os->laceptrlacing_fill){ + int val=oggbyte_read1(ob,27+os->laceptr++); + os->body_fill_next+=val; + if(val<255){ + os->body_fill_next|=FINFLAG; + os->clearflag=1; + break; + } + } +} + +static void _span_queued_page(ogg_stream_state *os){ + while( !(os->body_fill&FINFLAG) ){ + + if(!os->header_tail)break; + + /* first flush out preceeding page header (if any). Body is + flushed as it's consumed, so that's not done here. */ + + if(os->lacing_fill>=0) + os->header_tail=ogg_buffer_pretruncate(os->header_tail, + os->lacing_fill+27); + os->lacing_fill=0; + os->laceptr=0; + os->clearflag=0; + + if(!os->header_tail){ + os->header_head=0; + break; + }else{ + + /* process/prepare next page, if any */ + + long pageno; + oggbyte_buffer ob; + ogg_page og; /* only for parsing header values */ + og.header=os->header_tail; /* only for parsing header values */ + pageno=ogg_page_pageno(&og); + + oggbyte_init(&ob,os->header_tail); + os->lacing_fill=oggbyte_read1(&ob,26); + + /* are we in sequence? */ + if(pageno!=os->pageno){ + if(os->pageno==-1) /* indicates seek or reset */ + os->holeflag=1; /* set for internal use */ + else + os->holeflag=2; /* set for external reporting */ + + os->body_tail=ogg_buffer_pretruncate(os->body_tail, + os->body_fill); + if(os->body_tail==0)os->body_head=0; + os->body_fill=0; + + } + + if(ogg_page_continued(&og)){ + if(os->body_fill==0){ + /* continued packet, but no preceeding data to continue */ + /* dump the first partial packet on the page */ + _next_lace(&ob,os); + os->body_tail= + ogg_buffer_pretruncate(os->body_tail,os->body_fill_next&FINMASK); + if(os->body_tail==0)os->body_head=0; + /* set span flag */ + if(!os->spanflag && !os->holeflag)os->spanflag=2; + } + }else{ + if(os->body_fill>0){ + /* preceeding data to continue, but not a continued page */ + /* dump body_fill */ + os->body_tail=ogg_buffer_pretruncate(os->body_tail, + os->body_fill); + if(os->body_tail==0)os->body_head=0; + os->body_fill=0; + + /* set espan flag */ + if(!os->spanflag && !os->holeflag)os->spanflag=2; + } + } + + if(os->laceptrlacing_fill){ + os->granulepos=ogg_page_granulepos(&og); + + /* get current packet size & flag */ + _next_lace(&ob,os); + os->body_fill+=os->body_fill_next; /* addition handles the flag fine; + unsigned on purpose */ + /* ...and next packet size & flag */ + _next_lace(&ob,os); + + } + + os->pageno=pageno+1; + os->e_o_s=ogg_page_eos(&og); + os->b_o_s=ogg_page_bos(&og); + + } + } +} + +/* add the incoming page to the stream state; we decompose the page + into packet segments here as well. */ + +int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og){ + + int serialno=ogg_page_serialno(og); + int version=ogg_page_version(og); + + /* check the serial number */ + if(serialno!=os->serialno){ + //ogg_page_release(og); + return OGG_ESERIAL; + } + if(version>0){ + //ogg_page_release(og); + return OGG_EVERSION; + } + + /* add to fifos */ + if(!os->body_tail){ + os->body_tail=og->body; + os->body_head=ogg_buffer_walk(og->body); + }else{ + os->body_head=ogg_buffer_cat(os->body_head,og->body); + } + if(!os->header_tail){ + os->header_tail=og->header; + os->header_head=ogg_buffer_walk(og->header); + os->lacing_fill=-27; + }else{ + os->header_head=ogg_buffer_cat(os->header_head,og->header); + } + + memset(og,0,sizeof(*og)); + return OGG_SUCCESS; +} + +int ogg_stream_reset(ogg_stream_state *os){ + + ogg_buffer_release(os->header_tail); + ogg_buffer_release(os->body_tail); + os->header_tail=os->header_head=0; + os->body_tail=os->body_head=0; + + os->e_o_s=0; + os->b_o_s=0; + os->pageno=-1; + os->packetno=0; + os->granulepos=0; + + os->body_fill=0; + os->lacing_fill=0; + + os->holeflag=0; + os->spanflag=0; + os->clearflag=0; + os->laceptr=0; + os->body_fill_next=0; + + return OGG_SUCCESS; +} + +int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){ + ogg_stream_reset(os); + os->serialno=serialno; + return OGG_SUCCESS; +} + +static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){ + + ogg_packet_release(op); + _span_queued_page(os); + + if(os->holeflag){ + int temp=os->holeflag; + if(os->clearflag) + os->holeflag=0; + else + os->holeflag=1; + if(temp==2){ + os->packetno++; + return OGG_HOLE; + } + } + if(os->spanflag){ + int temp=os->spanflag; + if(os->clearflag) + os->spanflag=0; + else + os->spanflag=1; + if(temp==2){ + os->packetno++; + return OGG_SPAN; + } + } + + if(!(os->body_fill&FINFLAG)) return 0; + if(!op && !adv)return 1; /* just using peek as an inexpensive way + to ask if there's a whole packet + waiting */ + if(op){ + op->b_o_s=os->b_o_s; + if(os->e_o_s && os->body_fill_next==0) + op->e_o_s=os->e_o_s; + else + op->e_o_s=0; + if( (os->body_fill&FINFLAG) && !(os->body_fill_next&FINFLAG) ) + op->granulepos=os->granulepos; + else + op->granulepos=-1; + op->packetno=os->packetno; + } + + if(adv){ + oggbyte_buffer ob; + oggbyte_init(&ob,os->header_tail); + + /* split the body contents off */ + if(op){ + op->packet=ogg_buffer_split(&os->body_tail,&os->body_head, + os->body_fill&FINMASK); + op->bytes=os->body_fill&FINMASK; + }else{ + os->body_tail=ogg_buffer_pretruncate(os->body_tail, + os->body_fill&FINMASK); + if(os->body_tail==0)os->body_head=0; + } + + /* update lacing pointers */ + os->body_fill=os->body_fill_next; + _next_lace(&ob,os); + }else{ + if(op){ + op->packet=ogg_buffer_sub(os->body_tail,os->body_fill&FINMASK); + op->bytes=os->body_fill&FINMASK; + } + } + + if(adv){ + os->packetno++; + os->b_o_s=0; + } + + return 1; +} + +int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){ + return _packetout(os,op,1); +} + +int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){ + return _packetout(os,op,0); +} + +int ogg_packet_release(ogg_packet *op) { + if(op){ + ogg_buffer_release(op->packet); + memset(op, 0, sizeof(*op)); + } + return OGG_SUCCESS; +} + +int ogg_page_release(ogg_page *og) { + if(og){ + ogg_buffer_release(og->header); + ogg_buffer_release(og->body); + memset(og, 0, sizeof(*og)); + } + return OGG_SUCCESS; +} + +void ogg_page_dup(ogg_page *dup,ogg_page *orig){ + dup->header_len=orig->header_len; + dup->body_len=orig->body_len; + dup->header=ogg_buffer_dup(orig->header); + dup->body=ogg_buffer_dup(orig->body); +} + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/hide.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/hide.c new file mode 100644 index 0000000..a0604ee --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/hide.c @@ -0,0 +1,97 @@ +/* + * hide.c - USE LIGHTAIDRA AT YOUR OWN RISK! + * + * Lightaidra - IRC-based mass router scanner/exploiter. + * Copyright (C) Federico Fazzi, . + * + * example: ./hide -encode "127.0.0.1:6667" + * ./hide -decode ">@.CU,,,." <- copy into config.h + * CHANGE THE POSITION OF ENCODES[] VALUES IF YOU WANT YOUR PRIVATE ENCODING. + */ + +#include +#include + +char encodes[] = { + '<', '>', '@', '_', ';', ':', ',', '.', '-', '+', '*', '^', '?', '=', ')', '(', + '|', 'A', 'B', '&', '%', '$', 'D', '"', '!', 'w', 'k', 'y', 'x', 'z', 'v', 'u', + 't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'i', 'h', 'g', 'f', 'e', 'd', 'c', + 'b', 'a', '~', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'F', 'U', 'C', 'K', + '/', '{', '}', '#', '\'', '°' +}; +char decodes[] = { + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', + 'g', 'h', 'i', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'z', 'y', + 'w', 'k', 'x', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'Z', 'Y', 'W', 'K', 'X', '|', ':', '.', ' ', + '_', '+', '/', 'j', 'J', ',' +}; + +char encoded[512], decoded[512]; +char* encode(const char *str) +{ + int x = 0, i = 0, c; + + memset(encoded, 0, sizeof(encoded)); + while(x < strlen(str)) + { + for(c = 0; c <= sizeof(decodes); c++) + { + if(str[x] == decodes[c]) + { + encoded[i] = encodes[c]; + i++; + } + } + x++; + } + encoded[i] = '\0'; + + return encoded; +} + +char* decode(const char *str) +{ + int x = 0, i = 0, c; + + memset(decoded, 0, sizeof(decoded)); + while(x < strlen(str)) + { + for(c = 0; c <= sizeof(encodes); c++) + { + if(str[x] == encodes[c]) + { + decoded[i] = decodes[c]; + i++; + } + } + x++; + } + decoded[i] = '\0'; + + return decoded; +} +/* +int main(int argc, char *argv[]) +{ + if(argv[1] == 0 || argv[2] == 0) + { + printf("./lighthide [-encode|-decode] [string]\n"); + return(1); + } + else if(!strncmp(argv[1], "-encode", 7)) + { + encode(argv[2]); + decode(encoded); + printf("encoded[%s]:\n%s\n", decoded, encoded); + } + else if(!strncmp(argv[1], "-decode", 7)) + { + decode(argv[2]); + encode(decoded); + printf("decoded[%s]:\n%s\n", argv[2], decoded); + } + + return(0); +} +*/ diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/hide.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/hide.h new file mode 100644 index 0000000..5d26197 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/hide.h @@ -0,0 +1,7 @@ +#ifndef LIB_DECODE__H +#define LIB_DECODE__H + +char *decode(const char *str); +char *encode(const char *str); + +#endif diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ivorbiscodec.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ivorbiscodec.h new file mode 100644 index 0000000..5d1bf95 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ivorbiscodec.h @@ -0,0 +1,124 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: libvorbis codec headers + + ************************************************************************/ + +#ifndef _vorbis_codec_h_ +#define _vorbis_codec_h_ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include "ogg.h" + +struct vorbis_dsp_state; +typedef struct vorbis_dsp_state vorbis_dsp_state; + +typedef struct vorbis_info{ + int version; + int channels; + long rate; + + /* The below bitrate declarations are *hints*. + Combinations of the three values carry the following implications: + + all three set to the same value: + implies a fixed rate bitstream + only nominal set: + implies a VBR stream that averages the nominal bitrate. No hard + upper/lower limit + upper and or lower set: + implies a VBR bitstream that obeys the bitrate limits. nominal + may also be set to give a nominal rate. + none set: + the coder does not care to speculate. + */ + + long bitrate_upper; + long bitrate_nominal; + long bitrate_lower; + long bitrate_window; + + void *codec_setup; +} vorbis_info; + +typedef struct vorbis_comment{ + char **user_comments; + int *comment_lengths; + int comments; + char *vendor; + +} vorbis_comment; + + +/* Vorbis PRIMITIVES: general ***************************************/ + +extern void vorbis_info_init(vorbis_info *vi); +extern void vorbis_info_clear(vorbis_info *vi); +extern int vorbis_info_blocksize(vorbis_info *vi,int zo); +extern void vorbis_comment_init(vorbis_comment *vc); +extern void vorbis_comment_add(vorbis_comment *vc, char *comment); +extern void vorbis_comment_add_tag(vorbis_comment *vc, + char *tag, char *contents); +extern char *vorbis_comment_query(vorbis_comment *vc, char *tag, int count); +extern int vorbis_comment_query_count(vorbis_comment *vc, char *tag); +extern void vorbis_comment_clear(vorbis_comment *vc); + +/* Vorbis ERRORS and return codes ***********************************/ + +#define OV_FALSE -1 +#define OV_EOF -2 +#define OV_HOLE -3 + +#define OV_EREAD -128 +#define OV_EFAULT -129 +#define OV_EIMPL -130 +#define OV_EINVAL -131 +#define OV_ENOTVORBIS -132 +#define OV_EBADHEADER -133 +#define OV_EVERSION -134 +#define OV_ENOTAUDIO -135 +#define OV_EBADPACKET -136 +#define OV_EBADLINK -137 +#define OV_ENOSEEK -138 + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ivorbisfile.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ivorbisfile.h new file mode 100644 index 0000000..8c4fe77 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ivorbisfile.h @@ -0,0 +1,142 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: stdio-based convenience library for opening/seeking/decoding + + ************************************************************************/ + +#ifndef _OV_FILE_H_ +#define _OV_FILE_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include +#include "ivorbiscodec.h" + +/* The function prototypes for the callbacks are basically the same as for + * the stdio functions fread, fseek, fclose, ftell. + * The one difference is that the FILE * arguments have been replaced with + * a void * - this is to be used as a pointer to whatever internal data these + * functions might need. In the stdio case, it's just a FILE * cast to a void * + * + * If you use other functions, check the docs for these functions and return + * the right values. For seek_func(), you *MUST* return -1 if the stream is + * unseekable + */ +typedef struct { + size_t (*read_func) (void *ptr, size_t size, size_t nmemb, void *datasource); + int (*seek_func) (void *datasource, ogg_int64_t offset, int whence); + int (*close_func) (void *datasource); + long (*tell_func) (void *datasource); +} ov_callbacks; + +typedef struct OggVorbis_File { + void *datasource; /* Pointer to a FILE *, etc. */ + int seekable; + ogg_int64_t offset; + ogg_int64_t end; + ogg_sync_state *oy; + + /* If the FILE handle isn't seekable (eg, a pipe), only the current + stream appears */ + int links; + ogg_int64_t *offsets; + ogg_int64_t *dataoffsets; + ogg_uint32_t *serialnos; + ogg_int64_t *pcmlengths; + vorbis_info vi; + vorbis_comment vc; + + /* Decoding working state local storage */ + ogg_int64_t pcm_offset; + int ready_state; + ogg_uint32_t current_serialno; + int current_link; + + ogg_int64_t bittrack; + ogg_int64_t samptrack; + + ogg_stream_state *os; /* take physical pages, weld into a logical + stream of packets */ + vorbis_dsp_state *vd; /* central working state for the packet->PCM decoder */ + + ov_callbacks callbacks; + +} OggVorbis_File; + +extern int ov_clear(OggVorbis_File *vf); +extern int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes); +extern int ov_open_callbacks(void *datasource, OggVorbis_File *vf, + char *initial, long ibytes, ov_callbacks callbacks); + +extern int ov_test(FILE *f,OggVorbis_File *vf,char *initial,long ibytes); +extern int ov_test_callbacks(void *datasource, OggVorbis_File *vf, + char *initial, long ibytes, ov_callbacks callbacks); +extern int ov_test_open(OggVorbis_File *vf); + +extern long ov_bitrate(OggVorbis_File *vf,int i); +extern long ov_bitrate_instant(OggVorbis_File *vf); +extern long ov_streams(OggVorbis_File *vf); +extern long ov_seekable(OggVorbis_File *vf); +extern long ov_serialnumber(OggVorbis_File *vf,int i); + +extern ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i); +extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i); +extern ogg_int64_t ov_time_total(OggVorbis_File *vf,int i); + +extern int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_time_seek(OggVorbis_File *vf,ogg_int64_t pos); +extern int ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t pos); + +extern ogg_int64_t ov_raw_tell(OggVorbis_File *vf); +extern ogg_int64_t ov_pcm_tell(OggVorbis_File *vf); +extern ogg_int64_t ov_time_tell(OggVorbis_File *vf); + +extern vorbis_info *ov_info(OggVorbis_File *vf,int link); +extern vorbis_comment *ov_comment(OggVorbis_File *vf,int link); + +extern long ov_read(OggVorbis_File *vf,void *buffer,int length, + int *bitstream); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif + + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/lsp_lookup.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/lsp_lookup.h new file mode 100644 index 0000000..8338251 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/lsp_lookup.h @@ -0,0 +1,128 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: lookup data + + ************************************************************************/ + +#ifndef _V_LOOKUP_DATA_H_ +#define _V_LOOKUP_DATA_H_ + +#include "os_types.h" + +#define INVSQ_LOOKUP_I_SHIFT 10 +#define INVSQ_LOOKUP_I_MASK 1023 +static const long INVSQ_LOOKUP_I[64+1]={ + 92682, 91966, 91267, 90583, + 89915, 89261, 88621, 87995, + 87381, 86781, 86192, 85616, + 85051, 84497, 83953, 83420, + 82897, 82384, 81880, 81385, + 80899, 80422, 79953, 79492, + 79039, 78594, 78156, 77726, + 77302, 76885, 76475, 76072, + 75674, 75283, 74898, 74519, + 74146, 73778, 73415, 73058, + 72706, 72359, 72016, 71679, + 71347, 71019, 70695, 70376, + 70061, 69750, 69444, 69141, + 68842, 68548, 68256, 67969, + 67685, 67405, 67128, 66855, + 66585, 66318, 66054, 65794, + 65536, +}; + +static const long INVSQ_LOOKUP_IDel[64]={ + 716, 699, 684, 668, + 654, 640, 626, 614, + 600, 589, 576, 565, + 554, 544, 533, 523, + 513, 504, 495, 486, + 477, 469, 461, 453, + 445, 438, 430, 424, + 417, 410, 403, 398, + 391, 385, 379, 373, + 368, 363, 357, 352, + 347, 343, 337, 332, + 328, 324, 319, 315, + 311, 306, 303, 299, + 294, 292, 287, 284, + 280, 277, 273, 270, + 267, 264, 260, 258, +}; + +#define COS_LOOKUP_I_SHIFT 9 +#define COS_LOOKUP_I_MASK 511 +#define COS_LOOKUP_I_SZ 128 +static const ogg_int32_t COS_LOOKUP_I[COS_LOOKUP_I_SZ+1]={ + 16384, 16379, 16364, 16340, + 16305, 16261, 16207, 16143, + 16069, 15986, 15893, 15791, + 15679, 15557, 15426, 15286, + 15137, 14978, 14811, 14635, + 14449, 14256, 14053, 13842, + 13623, 13395, 13160, 12916, + 12665, 12406, 12140, 11866, + 11585, 11297, 11003, 10702, + 10394, 10080, 9760, 9434, + 9102, 8765, 8423, 8076, + 7723, 7366, 7005, 6639, + 6270, 5897, 5520, 5139, + 4756, 4370, 3981, 3590, + 3196, 2801, 2404, 2006, + 1606, 1205, 804, 402, + 0, -401, -803, -1204, + -1605, -2005, -2403, -2800, + -3195, -3589, -3980, -4369, + -4755, -5138, -5519, -5896, + -6269, -6638, -7004, -7365, + -7722, -8075, -8422, -8764, + -9101, -9433, -9759, -10079, + -10393, -10701, -11002, -11296, + -11584, -11865, -12139, -12405, + -12664, -12915, -13159, -13394, + -13622, -13841, -14052, -14255, + -14448, -14634, -14810, -14977, + -15136, -15285, -15425, -15556, + -15678, -15790, -15892, -15985, + -16068, -16142, -16206, -16260, + -16304, -16339, -16363, -16378, + -16383, +}; + +#endif + + + + + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mapping0.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mapping0.c new file mode 100644 index 0000000..ccc84da --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mapping0.c @@ -0,0 +1,261 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: channel mapping 0 implementation + + ************************************************************************/ + +#include +#include +#include +#include +#include "ogg.h" +#include "os.h" +#include "ivorbiscodec.h" +#include "mdct.h" +#include "codec_internal.h" +#include "codebook.h" +#include "misc.h" + +void mapping_clear_info(vorbis_info_mapping *info){ + if(info){ + if(info->chmuxlist)_ogg_free(info->chmuxlist); + if(info->submaplist)_ogg_free(info->submaplist); + if(info->coupling)_ogg_free(info->coupling); + memset(info,0,sizeof(*info)); + } +} + +static int ilog(unsigned int v){ + int ret=0; + if(v)--v; + while(v){ + ret++; + v>>=1; + } + return(ret); +} + +/* also responsible for range checking */ +int mapping_info_unpack(vorbis_info_mapping *info,vorbis_info *vi, + oggpack_buffer *opb){ + int i; + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + memset(info,0,sizeof(*info)); + + if(oggpack_read(opb,1)) + info->submaps=oggpack_read(opb,4)+1; + else + info->submaps=1; + + if(oggpack_read(opb,1)){ + info->coupling_steps=oggpack_read(opb,8)+1; + info->coupling= + _ogg_malloc(info->coupling_steps*sizeof(*info->coupling)); + + for(i=0;icoupling_steps;i++){ + int testM=info->coupling[i].mag=(unsigned char)(oggpack_read(opb,ilog(vi->channels))); + int testA=info->coupling[i].ang=(unsigned char)(oggpack_read(opb,ilog(vi->channels))); + + if(testM<0 || + testA<0 || + testM==testA || + testM>=vi->channels || + testA>=vi->channels) goto err_out; + } + + } + + if(oggpack_read(opb,2)>0)goto err_out; /* 2,3:reserved */ + + if(info->submaps>1){ + info->chmuxlist=_ogg_malloc(sizeof(*info->chmuxlist)*vi->channels); + for(i=0;ichannels;i++){ + info->chmuxlist[i]=(unsigned char)(oggpack_read(opb,4)); + if(info->chmuxlist[i]>=info->submaps)goto err_out; + } + } + + info->submaplist=_ogg_malloc(sizeof(*info->submaplist)*info->submaps); + for(i=0;isubmaps;i++){ + int temp=oggpack_read(opb,8); + info->submaplist[i].floor=(char)oggpack_read(opb,8); + if(info->submaplist[i].floor>=ci->floors)goto err_out; + info->submaplist[i].residue=(char)oggpack_read(opb,8); + if(info->submaplist[i].residue>=ci->residues)goto err_out; + } + + return 0; + + err_out: + mapping_clear_info(info); + return -1; +} + +int mapping_inverse(vorbis_dsp_state *vd,vorbis_info_mapping *info){ + vorbis_info *vi=vd->vi; + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + + int i,j; + long n=ci->blocksizes[vd->W]; + + ogg_int32_t **pcmbundle= + alloca(sizeof(*pcmbundle)*vi->channels); + int *zerobundle= + alloca(sizeof(*zerobundle)*vi->channels); + int *nonzero= + alloca(sizeof(*nonzero)*vi->channels); + ogg_int32_t **floormemo= + alloca(sizeof(*floormemo)*vi->channels); + + /* recover the spectral envelope; store it in the PCM vector for now */ + for(i=0;ichannels;i++){ + int submap=0; + int floorno; + + if(info->submaps>1) + submap=info->chmuxlist[i]; + floorno=info->submaplist[submap].floor; + + if(ci->floor_type[floorno]){ + /* floor 1 */ + floormemo[i]=alloca(sizeof(*floormemo[i])* + floor1_memosize(ci->floor_param[floorno])); + floormemo[i]=floor1_inverse1(vd,ci->floor_param[floorno],floormemo[i]); + }else{ + /* floor 0 */ + floormemo[i]=alloca(sizeof(*floormemo[i])* + floor0_memosize(ci->floor_param[floorno])); + floormemo[i]=floor0_inverse1(vd,ci->floor_param[floorno],floormemo[i]); + } + + if(floormemo[i]) + nonzero[i]=1; + else + nonzero[i]=0; + memset(vd->work[i],0,sizeof(*vd->work[i])*n/2); + } + + /* channel coupling can 'dirty' the nonzero listing */ + for(i=0;icoupling_steps;i++){ + if(nonzero[info->coupling[i].mag] || + nonzero[info->coupling[i].ang]){ + nonzero[info->coupling[i].mag]=1; + nonzero[info->coupling[i].ang]=1; + } + } + + /* recover the residue into our working vectors */ + for(i=0;isubmaps;i++){ + int ch_in_bundle=0; + for(j=0;jchannels;j++){ + if(!info->chmuxlist || info->chmuxlist[j]==i){ + if(nonzero[j]) + zerobundle[ch_in_bundle]=1; + else + zerobundle[ch_in_bundle]=0; + pcmbundle[ch_in_bundle++]=vd->work[j]; + } + } + + res_inverse(vd,ci->residue_param+info->submaplist[i].residue, + pcmbundle,zerobundle,ch_in_bundle); + } + + //for(j=0;jchannels;j++) + //_analysis_output("coupled",seq+j,vb->pcm[j],-8,n/2,0,0); + + /* channel coupling */ + for(i=info->coupling_steps-1;i>=0;i--){ + ogg_int32_t *pcmM=vd->work[info->coupling[i].mag]; + ogg_int32_t *pcmA=vd->work[info->coupling[i].ang]; + + for(j=0;j0) + if(ang>0){ + pcmM[j]=mag; + pcmA[j]=mag-ang; + }else{ + pcmA[j]=mag; + pcmM[j]=mag+ang; + } + else + if(ang>0){ + pcmM[j]=mag; + pcmA[j]=mag+ang; + }else{ + pcmA[j]=mag; + pcmM[j]=mag-ang; + } + } + } + + //for(j=0;jchannels;j++) + //_analysis_output("residue",seq+j,vb->pcm[j],-8,n/2,0,0); + + /* compute and apply spectral envelope */ + for(i=0;ichannels;i++){ + ogg_int32_t *pcm=vd->work[i]; + int submap=0; + int floorno; + + if(info->submaps>1) + submap=info->chmuxlist[i]; + floorno=info->submaplist[submap].floor; + + if(ci->floor_type[floorno]){ + /* floor 1 */ + floor1_inverse2(vd,ci->floor_param[floorno],floormemo[i],pcm); + }else{ + /* floor 0 */ + floor0_inverse2(vd,ci->floor_param[floorno],floormemo[i],pcm); + } + } + + //for(j=0;jchannels;j++) + //_analysis_output("mdct",seq+j,vb->pcm[j],-24,n/2,0,1); + + /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */ + /* only MDCT right now.... */ + for(i=0;ichannels;i++) + mdct_backward(n,vd->work[i]); + + //for(j=0;jchannels;j++) + //_analysis_output("imdct",seq+j,vb->pcm[j],-24,n,0,0); + + /* all done! */ + return(0); +} diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/md5.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/md5.c new file mode 100644 index 0000000..9b0b0e3 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/md5.c @@ -0,0 +1,329 @@ +/* + * This code implements the MD5 message-digest algorithm. + * The algorithm is due to Ron Rivest. This code was + * written by Colin Plumb in 1993, no copyright is claimed. + * This code is in the public domain; do with it what you wish. + * + * Equivalent code is available from RSA Data Security, Inc. + * This code has been tested against that, and is equivalent, + * except that you don't need to include two pages of legalese + * with every copy. + * + * To compute the message digest of a chunk of bytes, declare an + * MD5Context structure, pass it to MD5Init, call MD5Update as + * needed on buffers full of bytes, and then call MD5Final, which + * will fill a supplied 16-byte array with the digest. + */ + +/* This code was modified in 1997 by Jim Kingdon of Cyclic Software to + not require an integer type which is exactly 32 bits. This work + draws on the changes for the same purpose by Tatu Ylonen + as part of SSH, but since I didn't actually use + that code, there is no copyright issue. I hereby disclaim + copyright in any changes I have made; this code remains in the + public domain. */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#if HAVE_STRING_H || STDC_HEADERS +#include /* for memcpy() */ +#endif + +/* Add prototype support. */ +#ifndef PROTO +#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__) +#define PROTO(ARGS) ARGS +#else +#define PROTO(ARGS) () +#endif +#endif + +#include "md5.h" + +/* Little-endian byte-swapping routines. Note that these do not + depend on the size of datatypes such as uint32, nor do they require + us to detect the endianness of the machine we are running on. It + is possible they should be macros for speed, but I would be + surprised if they were a performance bottleneck for MD5. */ + +static uint32 +getu32 (addr) + const unsigned char *addr; +{ + return (((((unsigned long)addr[3] << 8) | addr[2]) << 8) + | addr[1]) << 8 | addr[0]; +} + +static void +putu32 (data, addr) + uint32 data; + unsigned char *addr; +{ + addr[0] = (unsigned char)data; + addr[1] = (unsigned char)(data >> 8); + addr[2] = (unsigned char)(data >> 16); + addr[3] = (unsigned char)(data >> 24); +} + +/* + * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious + * initialization constants. + */ +void +MD5Init(ctx) + struct MD5Context *ctx; +{ + ctx->buf[0] = 0x67452301; + ctx->buf[1] = 0xefcdab89; + ctx->buf[2] = 0x98badcfe; + ctx->buf[3] = 0x10325476; + + ctx->bits[0] = 0; + ctx->bits[1] = 0; +} + +/* + * Update context to reflect the concatenation of another buffer full + * of bytes. + */ +void +MD5Update(ctx, buf, len) + struct MD5Context *ctx; + unsigned char const *buf; + unsigned len; +{ + uint32 t; + + /* Update bitcount */ + + t = ctx->bits[0]; + if ((ctx->bits[0] = (t + ((uint32)len << 3)) & 0xffffffff) < t) + ctx->bits[1]++; /* Carry from low to high */ + ctx->bits[1] += len >> 29; + + t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */ + + /* Handle any leading odd-sized chunks */ + + if ( t ) { + unsigned char *p = ctx->in + t; + + t = 64-t; + if (len < t) { + memcpy(p, buf, len); + return; + } + memcpy(p, buf, t); + MD5Transform(ctx->buf, ctx->in); + buf += t; + len -= t; + } + + /* Process data in 64-byte chunks */ + + while (len >= 64) { + memcpy(ctx->in, buf, 64); + MD5Transform(ctx->buf, ctx->in); + buf += 64; + len -= 64; + } + + /* Handle any remaining bytes of data. */ + + memcpy(ctx->in, buf, len); +} + +/* + * Final wrapup - pad to 64-byte boundary with the bit pattern + * 1 0* (64-bit count of bits processed, MSB-first) + */ +void +MD5Final(digest, ctx) + unsigned char digest[16]; + struct MD5Context *ctx; +{ + unsigned count; + unsigned char *p; + + /* Compute number of bytes mod 64 */ + count = (ctx->bits[0] >> 3) & 0x3F; + + /* Set the first char of padding to 0x80. This is safe since there is + always at least one byte free */ + p = ctx->in + count; + *p++ = 0x80; + + /* Bytes of padding needed to make 64 bytes */ + count = 64 - 1 - count; + + /* Pad out to 56 mod 64 */ + if (count < 8) { + /* Two lots of padding: Pad the first block to 64 bytes */ + memset(p, 0, count); + MD5Transform(ctx->buf, ctx->in); + + /* Now fill the next block with 56 bytes */ + memset(ctx->in, 0, 56); + } else { + /* Pad block to 56 bytes */ + memset(p, 0, count-8); + } + + /* Append length in bits and transform */ + putu32(ctx->bits[0], ctx->in + 56); + putu32(ctx->bits[1], ctx->in + 60); + + MD5Transform(ctx->buf, ctx->in); + putu32(ctx->buf[0], digest); + putu32(ctx->buf[1], digest + 4); + putu32(ctx->buf[2], digest + 8); + putu32(ctx->buf[3], digest + 12); + memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */ +} + +#ifndef ASM_MD5 + +/* The four core functions - F1 is optimized somewhat */ + +/* #define F1(x, y, z) (x & y | ~x & z) */ +#define F1(x, y, z) (z ^ (x & (y ^ z))) +#define F2(x, y, z) F1(z, x, y) +#define F3(x, y, z) (x ^ y ^ z) +#define F4(x, y, z) (y ^ (x | ~z)) + +/* This is the central step in the MD5 algorithm. */ +#define MD5STEP(f, w, x, y, z, data, s) \ + ( w += f(x, y, z) + data, w &= 0xffffffff, w = w<>(32-s), w += x ) + +/* + * The core of the MD5 algorithm, this alters an existing MD5 hash to + * reflect the addition of 16 longwords of new data. MD5Update blocks + * the data and converts bytes into longwords for this routine. + */ +void +MD5Transform(buf, inraw) + uint32 buf[4]; + const unsigned char inraw[64]; +{ + register uint32 a, b, c, d; + uint32 in[16]; + int i; + + for (i = 0; i < 16; ++i) + in[i] = getu32 (inraw + 4 * i); + + a = buf[0]; + b = buf[1]; + c = buf[2]; + d = buf[3]; + + MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7); + MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12); + MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17); + MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22); + MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7); + MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12); + MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17); + MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22); + MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7); + MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12); + MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17); + MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22); + MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7); + MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12); + MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17); + MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22); + + MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5); + MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9); + MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14); + MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20); + MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5); + MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9); + MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14); + MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20); + MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5); + MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9); + MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14); + MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20); + MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5); + MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9); + MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14); + MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20); + + MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4); + MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11); + MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16); + MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23); + MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4); + MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11); + MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16); + MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23); + MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4); + MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11); + MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16); + MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23); + MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4); + MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11); + MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16); + MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23); + + MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6); + MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10); + MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15); + MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21); + MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6); + MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10); + MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15); + MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21); + MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6); + MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10); + MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15); + MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21); + MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6); + MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10); + MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15); + MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21); + + buf[0] += a; + buf[1] += b; + buf[2] += c; + buf[3] += d; +} +#endif + +#ifdef TEST +/* Simple test program. Can use it to manually run the tests from + RFC1321 for example. */ +#include + +int +main (int argc, char **argv) +{ + struct MD5Context context; + unsigned char checksum[16]; + int i; + int j; + + if (argc < 2) + { + fprintf (stderr, "usage: %s string-to-hash\n", argv[0]); + exit (1); + } + for (j = 1; j < argc; ++j) + { + printf ("MD5 (\"%s\") = ", argv[j]); + MD5Init (&context); + MD5Update (&context, argv[j], strlen (argv[j])); + MD5Final (checksum, &context); + for (i = 0; i < 16; i++) + { + printf ("%02x", (unsigned int) checksum[i]); + } + printf ("\n"); + } + return 0; +} +#endif /* TEST */ \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/md5.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/md5.h new file mode 100644 index 0000000..dc970b5 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/md5.h @@ -0,0 +1,29 @@ +/* See md5.c for explanation and copyright information. */ + +#ifndef MD5_H +#define MD5_H + +/* Unlike previous versions of this code, uint32 need not be exactly + 32 bits, merely 32 bits or more. Choosing a data type which is 32 + bits instead of 64 is not important; speed is considerably more + important. ANSI guarantees that "unsigned long" will be big enough, + and always using it seems to have few disadvantages. */ +typedef unsigned long uint32; + +struct MD5Context { + uint32 buf[4]; + uint32 bits[2]; + unsigned char in[64]; +}; + +void MD5Init(struct MD5Context *context); +void MD5Update(struct MD5Context *context, unsigned char const *buf, unsigned len); +void MD5Final(unsigned char digest[16], struct MD5Context *context); +void MD5Transform(uint32 buf[4], const unsigned char in[64]); + +/* + * This is needed to make RSAREF happy on some MS-DOS compilers. + */ +typedef struct MD5Context MD5_CTX; + +#endif /* !MD5_H */ \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct.c new file mode 100644 index 0000000..32b3525 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct.c @@ -0,0 +1,582 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: normalized modified discrete cosine transform + power of two length transform only [64 <= n ] + last mod: $Id: mdct.c,v 1.9.6.5 2003/04/29 04:03:27 xiphmont Exp $ + + Original algorithm adapted long ago from _The use of multirate filter + banks for coding of high quality digital audio_, by T. Sporer, + K. Brandenburg and B. Edler, collection of the European Signal + Processing Conference (EUSIPCO), Amsterdam, June 1992, Vol.1, pp + 211-214 + + The below code implements an algorithm that no longer looks much like + that presented in the paper, but the basic structure remains if you + dig deep enough to see it. + + This module DOES NOT INCLUDE code to generate/apply the window + function. Everybody has their own weird favorite including me... I + happen to like the properties of y=sin(.5PI*sin^2(x)), but others may + vehemently disagree. + + ************************************************************************/ + +#include "ivorbiscodec.h" +#include "os.h" +#include "misc.h" +#include "mdct.h" +#include "mdct_lookup.h" + +#include + +#if defined(ONLY_C) +STIN void presymmetry(DATA_TYPE *in,int n2,int step){ + DATA_TYPE *aX; + DATA_TYPE *bX; + LOOKUP_T *T; + int n4=n2>>1; + + aX = in+n2-3; + T = sincos_lookup0; + + do{ + REG_TYPE s0= aX[0]; + REG_TYPE s2= aX[2]; + XPROD31( s0, s2, T[0], T[1], &aX[0], &aX[2] ); T+=step; + aX-=4; + }while(aX>=in+n4); + do{ + REG_TYPE s0= aX[0]; + REG_TYPE s2= aX[2]; + XPROD31( s0, s2, T[1], T[0], &aX[0], &aX[2] ); T-=step; + aX-=4; + }while(aX>=in); + + aX = in+n2-4; + bX = in; + T = sincos_lookup0; + do{ + REG_TYPE ri0= aX[0]; + REG_TYPE ri2= aX[2]; + REG_TYPE ro0= bX[0]; + REG_TYPE ro2= bX[2]; + + XNPROD31( ro2, ro0, T[1], T[0], &aX[0], &aX[2] ); T+=step; + XNPROD31( ri2, ri0, T[0], T[1], &bX[0], &bX[2] ); + + aX-=4; + bX+=4; + }while(aX>=bX); +} + +/* 8 point butterfly (in place) */ +STIN void mdct_butterfly_8(DATA_TYPE *x){ + + REG_TYPE s0 = x[0] + x[1]; + REG_TYPE s1 = x[0] - x[1]; + REG_TYPE s2 = x[2] + x[3]; + REG_TYPE s3 = x[2] - x[3]; + REG_TYPE s4 = x[4] + x[5]; + REG_TYPE s5 = x[4] - x[5]; + REG_TYPE s6 = x[6] + x[7]; + REG_TYPE s7 = x[6] - x[7]; + + x[0] = s5 + s3; + x[1] = s7 - s1; + x[2] = s5 - s3; + x[3] = s7 + s1; + x[4] = s4 - s0; + x[5] = s6 - s2; + x[6] = s4 + s0; + x[7] = s6 + s2; + MB(); +} + +/* 16 point butterfly (in place, 4 register) */ +STIN void mdct_butterfly_16(DATA_TYPE *x){ + + REG_TYPE s0, s1, s2, s3; + + s0 = x[ 8] - x[ 9]; x[ 8] += x[ 9]; + s1 = x[10] - x[11]; x[10] += x[11]; + s2 = x[ 1] - x[ 0]; x[ 9] = x[ 1] + x[0]; + s3 = x[ 3] - x[ 2]; x[11] = x[ 3] + x[2]; + x[ 0] = MULT31((s0 - s1) , cPI2_8); + x[ 1] = MULT31((s2 + s3) , cPI2_8); + x[ 2] = MULT31((s0 + s1) , cPI2_8); + x[ 3] = MULT31((s3 - s2) , cPI2_8); + MB(); + + s2 = x[12] - x[13]; x[12] += x[13]; + s3 = x[14] - x[15]; x[14] += x[15]; + s0 = x[ 4] - x[ 5]; x[13] = x[ 5] + x[ 4]; + s1 = x[ 7] - x[ 6]; x[15] = x[ 7] + x[ 6]; + x[ 4] = s2; x[ 5] = s1; + x[ 6] = s3; x[ 7] = s0; + MB(); + + mdct_butterfly_8(x); + mdct_butterfly_8(x+8); +} + +/* 32 point butterfly (in place, 4 register) */ +STIN void mdct_butterfly_32(DATA_TYPE *x){ + + REG_TYPE s0, s1, s2, s3; + + s0 = x[16] - x[17]; x[16] += x[17]; + s1 = x[18] - x[19]; x[18] += x[19]; + s2 = x[ 1] - x[ 0]; x[17] = x[ 1] + x[ 0]; + s3 = x[ 3] - x[ 2]; x[19] = x[ 3] + x[ 2]; + XNPROD31( s0, s1, cPI3_8, cPI1_8, &x[ 0], &x[ 2] ); + XPROD31 ( s2, s3, cPI1_8, cPI3_8, &x[ 1], &x[ 3] ); + MB(); + + s0 = x[20] - x[21]; x[20] += x[21]; + s1 = x[22] - x[23]; x[22] += x[23]; + s2 = x[ 5] - x[ 4]; x[21] = x[ 5] + x[ 4]; + s3 = x[ 7] - x[ 6]; x[23] = x[ 7] + x[ 6]; + x[ 4] = MULT31((s0 - s1) , cPI2_8); + x[ 5] = MULT31((s3 + s2) , cPI2_8); + x[ 6] = MULT31((s0 + s1) , cPI2_8); + x[ 7] = MULT31((s3 - s2) , cPI2_8); + MB(); + + s0 = x[24] - x[25]; x[24] += x[25]; + s1 = x[26] - x[27]; x[26] += x[27]; + s2 = x[ 9] - x[ 8]; x[25] = x[ 9] + x[ 8]; + s3 = x[11] - x[10]; x[27] = x[11] + x[10]; + XNPROD31( s0, s1, cPI1_8, cPI3_8, &x[ 8], &x[10] ); + XPROD31 ( s2, s3, cPI3_8, cPI1_8, &x[ 9], &x[11] ); + MB(); + + s0 = x[28] - x[29]; x[28] += x[29]; + s1 = x[30] - x[31]; x[30] += x[31]; + s2 = x[12] - x[13]; x[29] = x[13] + x[12]; + s3 = x[15] - x[14]; x[31] = x[15] + x[14]; + x[12] = s0; x[13] = s3; + x[14] = s1; x[15] = s2; + MB(); + + mdct_butterfly_16(x); + mdct_butterfly_16(x+16); +} + +/* N/stage point generic N stage butterfly (in place, 2 register) */ +STIN void mdct_butterfly_generic(DATA_TYPE *x,int points,int step){ + LOOKUP_T *T = sincos_lookup0; + DATA_TYPE *x1 = x + points - 4; + DATA_TYPE *x2 = x + (points>>1) - 4; + REG_TYPE s0, s1, s2, s3; + + do{ + s0 = x1[0] - x1[1]; x1[0] += x1[1]; + s1 = x1[3] - x1[2]; x1[2] += x1[3]; + s2 = x2[1] - x2[0]; x1[1] = x2[1] + x2[0]; + s3 = x2[3] - x2[2]; x1[3] = x2[3] + x2[2]; + XPROD31( s1, s0, T[0], T[1], &x2[0], &x2[2] ); + XPROD31( s2, s3, T[0], T[1], &x2[1], &x2[3] ); T+=step; + x1-=4; + x2-=4; + }while(T>1) + (points>>2) - 4; + x2 = x + (points>>2) - 4; + T = sincos_lookup0+1024; + do{ + s0 = x1[0] - x1[1]; x1[0] += x1[1]; + s1 = x1[2] - x1[3]; x1[2] += x1[3]; + s2 = x2[0] - x2[1]; x1[1] = x2[1] + x2[0]; + s3 = x2[3] - x2[2]; x1[3] = x2[3] + x2[2]; + XNPROD31( s0, s1, T[0], T[1], &x2[0], &x2[2] ); + XNPROD31( s3, s2, T[0], T[1], &x2[1], &x2[3] ); T-=step; + x1-=4; + x2-=4; + }while(T>sincos_lookup0); +} + +STIN void mdct_butterflies(DATA_TYPE *x,int points,int shift){ + + int stages=7-shift; + int i,j; + + for(i=0;--stages>=0;i++){ + for(j=0;j<(1<>i)*j,points>>i,4<<(i+shift)); + } + } + + for(j=0;j>8]|(bitrev[(x&0x0f0)>>4]<<4)|(((int)bitrev[x&0x00f])<<8); +} + +STIN void mdct_bitreverse(DATA_TYPE *x,int n,int shift){ + int bit = 0; + DATA_TYPE *w = x+(n>>1); + + do{ + DATA_TYPE b = bitrev12(bit++); + DATA_TYPE *xx = x + (b>>shift); + REG_TYPE r; + + w -= 2; + + if(w>xx){ + + r = xx[0]; + xx[0] = w[0]; + w[0] = r; + + r = xx[1]; + xx[1] = w[1]; + w[1] = r; + } + }while(w>x); +} + +STIN void mdct_step7(DATA_TYPE *x,int n,int step){ + DATA_TYPE *w0 = x; + DATA_TYPE *w1 = x+(n>>1); + LOOKUP_T *T = (step>=4)?(sincos_lookup0+(step>>1)):sincos_lookup1; + LOOKUP_T *Ttop = T+1024; + REG_TYPE s0, s1, s2, s3; + + do{ + w1 -= 2; + + s0 = w0[0] + w1[0]; + s1 = w1[1] - w0[1]; + s2 = MULT32(s0, T[1]) + MULT32(s1, T[0]); + s3 = MULT32(s1, T[1]) - MULT32(s0, T[0]); + T+=step; + + s0 = (w0[1] + w1[1])>>1; + s1 = (w0[0] - w1[0])>>1; + w0[0] = s0 + s2; + w0[1] = s1 + s3; + w1[0] = s0 - s2; + w1[1] = s3 - s1; + + w0 += 2; + }while(T>1; + s1 = (w0[0] - w1[0])>>1; + w0[0] = s0 + s2; + w0[1] = s1 + s3; + w1[0] = s0 - s2; + w1[1] = s3 - s1; + + w0 += 2; + }while(w0>1); + + switch(step) { +#if defined(ONLY_C) + default: + T=(step>=4)?(sincos_lookup0+(step>>1)):sincos_lookup1; + do{ + REG_TYPE s0 = x[0]; + REG_TYPE s1 = -x[1]; + XPROD31( s0, s1, T[0], T[1], x, x+1); T+=step; + x +=2; + }while(x>1; + t1 = (*T++)>>1; + do{ + s0 = x[0]; + s1 = -x[1]; + t0 += (v0 = (*V++)>>1); + t1 += (v1 = (*V++)>>1); + XPROD31( s0, s1, t0, t1, x, x+1 ); + + s0 = x[2]; + s1 = -x[3]; + v0 += (t0 = (*T++)>>1); + v1 += (t1 = (*T++)>>1); + XPROD31( s0, s1, v0, v1, x+2, x+3 ); + + x += 4; + }while(x>2); + t1 += (q1 = (v1-t1)>>2); + s0 = x[0]; + s1 = -x[1]; + XPROD31( s0, s1, t0, t1, x, x+1 ); + t0 = v0-q0; + t1 = v1-q1; + s0 = x[2]; + s1 = -x[3]; + XPROD31( s0, s1, t0, t1, x+2, x+3 ); + + t0 = *T++; + t1 = *T++; + v0 += (q0 = (t0-v0)>>2); + v1 += (q1 = (t1-v1)>>2); + s0 = x[4]; + s1 = -x[5]; + XPROD31( s0, s1, v0, v1, x+4, x+5 ); + v0 = t0-q0; + v1 = t1-q1; + s0 = x[6]; + s1 = -x[7]; + XPROD31( s0, s1, v0, v1, x+5, x+6 ); + + x+=8; + }while(x>1,step); + mdct_butterflies(in,n>>1,shift); + mdct_bitreverse(in,n,shift); + mdct_step7(in,n,step); + mdct_step8(in,n,step>>2); +#else + step = mdct_backwardARM(n, in); + if (step <= 1) + mdct_step8(in,n,step); +#endif +} + +#if defined(ONLY_C) +void mdct_shift_right(int n, DATA_TYPE *in, DATA_TYPE *right){ + int i; + n>>=2; + in+=1; + + for(i=0;i>1 : n0>>1); + DATA_TYPE *r=right+(lW ? n1>>2 : n0>>2); + DATA_TYPE *post; + LOOKUP_T *wR=(W && lW ? w1+(n1>>1) : w0+(n0>>1)); + LOOKUP_T *wL=(W && lW ? w1 : w0 ); + + int preLap=(lW && !W ? (n1>>2)-(n0>>2) : 0 ); + int halfLap=(lW && W ? (n1>>2) : (n0>>2) ); + int postLap=(!lW && W ? (n1>>2)-(n0>>2) : 0 ); + int n,off; + + /* preceeding direct-copy lapping from previous frame, if any */ + if(preLap){ + n = (endpost){ + *out = CLIP_TO_15((*--r)>>9); + out+=step; + } +#else + out = mdct_unroll_prelap(out,post,r,step); + n -= off; + if (n < 0) + n = 0; + r -= n; +#endif + } + + /* cross-lap; two halves due to wrap-around */ + n = (endpost){ + l-=2; + *out = CLIP_TO_15((MULT31(*--r,*--wR) + MULT31(*l,*wL++))>>9); + out+=step; + } +#else + out = mdct_unroll_part2(out, post, l, r, step, wL, wR); + n -= off; + if (n < 0) + n = 0; + l -= 2*n; + r -= n; + wR -= n; + wL += n; +#endif + + n = (end>9); + out+=step; + l+=2; + } +#else + out = mdct_unroll_part3(out, post, l, r, step, wL, wR); + n -= off; + if (n < 0) + n = 0; + l += 2*n; + r += n; + wR -= n; + wL += n; +#endif + + /* preceeding direct-copy lapping from previous frame, if any */ + if(postLap){ + n = (end>9); + out+=step; + l+=2; + } +#else + out = mdct_unroll_postlap(out,post,l,step); +#endif + } +} + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct.h new file mode 100644 index 0000000..0878359 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct.h @@ -0,0 +1,79 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: modified discrete cosine transform prototypes + + ************************************************************************/ + +#ifndef _OGG_mdct_H_ +#define _OGG_mdct_H_ + +#include "ivorbiscodec.h" +#include "misc.h" + +#define DATA_TYPE ogg_int32_t +#define REG_TYPE register ogg_int32_t + +#ifdef _LOW_ACCURACY_ +#define cPI3_8 (0x0062) +#define cPI2_8 (0x00b5) +#define cPI1_8 (0x00ed) +#else +#define cPI3_8 (0x30fbc54d) +#define cPI2_8 (0x5a82799a) +#define cPI1_8 (0x7641af3d) +#endif + +extern void mdct_backward(int n, DATA_TYPE *in); +extern void mdct_shift_right(int n, DATA_TYPE *in, DATA_TYPE *right); +extern void mdct_unroll_lap(int n0,int n1, + int lW,int W, + DATA_TYPE *in,DATA_TYPE *right, + LOOKUP_T *w0,LOOKUP_T *w1, + ogg_int16_t *out, + int step, + int start,int end /* samples, this frame */); + +#endif + + + + + + + + + + + + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdctARM.s b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdctARM.s new file mode 100644 index 0000000..0fcc68e --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdctARM.s @@ -0,0 +1,1234 @@ +@ Tremolo library +@----------------------------------------------------------------------- +@ Copyright (C) 2002-2009, Xiph.org Foundation +@ Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd +@ All rights reserved. + +@ Redistribution and use in source and binary forms, with or without +@ modification, are permitted provided that the following conditions +@ are met: + +@ * Redistributions of source code must retain the above copyright +@ notice, this list of conditions and the following disclaimer. +@ * Redistributions in binary form must reproduce the above +@ copyright notice, this list of conditions and the following disclaimer +@ in the documentation and/or other materials provided with the +@ distribution. +@ * Neither the names of the Xiph.org Foundation nor Pinknoise +@ Productions Ltd nor the names of its contributors may be used to +@ endorse or promote products derived from this software without +@ specific prior written permission. +@ +@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +@ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +@ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +@ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +@ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +@ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +@ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +@ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +@ ---------------------------------------------------------------------- + + .text + + @ full accuracy version + + .global mdct_backwardARM + .global mdct_shift_right + .global mdct_unroll_prelap + .global mdct_unroll_part2 + .global mdct_unroll_part3 + .global mdct_unroll_postlap + + .extern sincos_lookup0 + .extern sincos_lookup1 + .hidden sincos_lookup0 + .hidden sincos_lookup1 + +mdct_unroll_prelap: + @ r0 = out + @ r1 = post + @ r2 = r + @ r3 = step + STMFD r13!,{r4-r7,r14} + MVN r4, #0x8000 + MOV r3, r3, LSL #1 + SUB r1, r2, r1 @ r1 = r - post + SUBS r1, r1, #16 @ r1 = r - post - 16 + BLT unroll_over +unroll_loop: + LDMDB r2!,{r5,r6,r7,r12} + + MOV r5, r5, ASR #9 @ r5 = (*--r)>>9 + MOV r6, r6, ASR #9 @ r6 = (*--r)>>9 + MOV r7, r7, ASR #9 @ r7 = (*--r)>>9 + MOV r12,r12,ASR #9 @ r12= (*--r)>>9 + + MOV r14,r12,ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r12,r4, r14,ASR #31 + STRH r12,[r0], r3 + + MOV r14,r7, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r7, r4, r14,ASR #31 + STRH r7, [r0], r3 + + MOV r14,r6, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r6, r4, r14,ASR #31 + STRH r6, [r0], r3 + + MOV r14,r5, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r5, r4, r14,ASR #31 + STRH r5, [r0], r3 + + SUBS r1, r1, #16 + BGE unroll_loop + +unroll_over: + ADDS r1, r1, #16 + BLE unroll_end +unroll_loop2: + LDR r5,[r2,#-4]! + @ stall + @ stall (Xscale) + MOV r5, r5, ASR #9 @ r5 = (*--r)>>9 + MOV r14,r5, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r5, r4, r14,ASR #31 + STRH r5, [r0], r3 + SUBS r1, r1, #4 + BGT unroll_loop2 +unroll_end: + LDMFD r13!,{r4-r7,PC} + +mdct_unroll_postlap: + @ r0 = out + @ r1 = post + @ r2 = l + @ r3 = step + STMFD r13!,{r4-r7,r14} + MVN r4, #0x8000 + MOV r3, r3, LSL #1 + SUB r1, r1, r2 @ r1 = post - l + MOV r1, r1, ASR #1 @ r1 = (post - l)>>1 + SUBS r1, r1, #16 @ r1 = ((post - l)>>1) - 4 + BLT unroll_over3 +unroll_loop3: + LDR r12,[r2],#8 + LDR r7, [r2],#8 + LDR r6, [r2],#8 + LDR r5, [r2],#8 + + RSB r12,r12,#0 + RSB r5, r5, #0 + RSB r6, r6, #0 + RSB r7, r7, #0 + + MOV r12, r12,ASR #9 @ r12= (-*l)>>9 + MOV r5, r5, ASR #9 @ r5 = (-*l)>>9 + MOV r6, r6, ASR #9 @ r6 = (-*l)>>9 + MOV r7, r7, ASR #9 @ r7 = (-*l)>>9 + + MOV r14,r12,ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r12,r4, r14,ASR #31 + STRH r12,[r0], r3 + + MOV r14,r7, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r7, r4, r14,ASR #31 + STRH r7, [r0], r3 + + MOV r14,r6, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r6, r4, r14,ASR #31 + STRH r6, [r0], r3 + + MOV r14,r5, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r5, r4, r14,ASR #31 + STRH r5, [r0], r3 + + SUBS r1, r1, #16 + BGE unroll_loop3 + +unroll_over3: + ADDS r1, r1, #16 + BLE unroll_over4 +unroll_loop4: + LDR r5,[r2], #8 + @ stall + @ stall (Xscale) + RSB r5, r5, #0 + MOV r5, r5, ASR #9 @ r5 = (-*l)>>9 + MOV r14,r5, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r5, r4, r14,ASR #31 + STRH r5, [r0], r3 + SUBS r1, r1, #4 + BGT unroll_loop4 +unroll_over4: + LDMFD r13!,{r4-r7,PC} + +mdct_unroll_part2: + @ r0 = out + @ r1 = post + @ r2 = l + @ r3 = r + @ <> = step + @ <> = wL + @ <> = wR + MOV r12,r13 + STMFD r13!,{r4,r6-r11,r14} + LDMFD r12,{r8,r9,r10} @ r8 = step + @ r9 = wL + @ r10= wR + MVN r4, #0x8000 + MOV r8, r8, LSL #1 + SUBS r1, r3, r1 @ r1 = (r - post) + BLE unroll_over5 +unroll_loop5: + LDR r12,[r2, #-8]! @ r12= *l (but l -= 2 first) + LDR r11,[r9],#4 @ r11= *wL++ + LDR r7, [r3, #-4]! @ r7 = *--r + LDR r6, [r10,#-4]! @ r6 = *--wR + + @ Can save a cycle here, at the cost of 1bit errors in rounding + SMULL r14,r11,r12,r11 @ (r14,r11) = *l * *wL++ + SMULL r14,r6, r7, r6 @ (r14,r6) = *--r * *--wR + ADD r6, r6, r11 + MOV r6, r6, ASR #8 + MOV r14,r6, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r6, r4, r14,ASR #31 + STRH r6, [r0], r8 + + SUBS r1, r1, #4 + BGT unroll_loop5 + +unroll_over5: + LDMFD r13!,{r4,r6-r11,PC} + +mdct_unroll_part3: + @ r0 = out + @ r1 = post + @ r2 = l + @ r3 = r + @ <> = step + @ <> = wL + @ <> = wR + MOV r12,r13 + STMFD r13!,{r4,r6-r11,r14} + LDMFD r12,{r8,r9,r10} @ r8 = step + @ r9 = wL + @ r10= wR + MVN r4, #0x8000 + MOV r8, r8, LSL #1 + SUBS r1, r1, r3 @ r1 = (post - r) + BLE unroll_over6 +unroll_loop6: + LDR r12,[r2],#8 @ r12= *l (but l += 2 first) + LDR r11,[r9],#4 @ r11= *wL++ + LDR r7, [r3],#4 @ r7 = *r++ + LDR r6, [r10,#-4]! @ r6 = *--wR + + @ Can save a cycle here, at the cost of 1bit errors in rounding + SMULL r14,r11,r12,r11 @ (r14,r11) = *l * *wL++ + SMULL r14,r6, r7, r6 @ (r14,r6) = *--r * *--wR + SUB r6, r6, r11 + MOV r6, r6, ASR #8 + MOV r14,r6, ASR #15 + TEQ r14,r14,ASR #31 @ if r14==0 || r14==-1 then in range + EORNE r6, r4, r14,ASR #31 + STRH r6, [r0], r8 + + SUBS r1, r1, #4 + BGT unroll_loop6 + +unroll_over6: + LDMFD r13!,{r4,r6-r11,PC} + +mdct_shift_right: + @ r0 = n + @ r1 = in + @ r2 = right + STMFD r13!,{r4-r11,r14} + + MOV r0, r0, LSR #2 @ n >>= 2 + ADD r1, r1, #4 + + SUBS r0, r0, #8 + BLT sr_less_than_8 +sr_loop: + LDR r3, [r1], #8 + LDR r4, [r1], #8 + LDR r5, [r1], #8 + LDR r6, [r1], #8 + LDR r7, [r1], #8 + LDR r8, [r1], #8 + LDR r12,[r1], #8 + LDR r14,[r1], #8 + SUBS r0, r0, #8 + STMIA r2!,{r3,r4,r5,r6,r7,r8,r12,r14} + BGE sr_loop +sr_less_than_8: + ADDS r0, r0, #8 + BEQ sr_end +sr_loop2: + LDR r3, [r1], #8 + SUBS r0, r0, #1 + STR r3, [r2], #4 + BGT sr_loop2 +sr_end: + LDMFD r13!,{r4-r11,PC} + +mdct_backwardARM: + @ r0 = n + @ r1 = in + STMFD r13!,{r4-r11,r14} + + MOV r2,#1<<4 @ r2 = 1<>1) + ADD r14,r1, r0 @ r14= in+(n>>2) + SUB r4, r4, #3*4 @ r4 = aX = in+n2-3 + ADRL r7, .Lsincos_lookup + LDR r5, [r7] @ r5 = T=sincos_lookup0 + ADD r5, r7 + +presymmetry_loop1: + LDR r7, [r4,#8] @ r6 = s2 = aX[2] + LDR r11,[r5,#4] @ r11= T[1] + LDR r6, [r4] @ r6 = s0 = aX[0] + LDR r10,[r5],r2,LSL #2 @ r10= T[0] T += step + + @ XPROD31(s0, s2, T[0], T[1], 0xaX[0], &ax[2]) + SMULL r8, r9, r7, r11 @ (r8, r9) = s2*T[1] + @ stall + @ stall ? + SMLAL r8, r9, r6, r10 @ (r8, r9) += s0*T[0] + RSB r6, r6, #0 + @ stall ? + SMULL r8, r12,r7, r10 @ (r8, r12) = s2*T[0] + MOV r9, r9, LSL #1 + @ stall ? + SMLAL r8, r12,r6, r11 @ (r8, r12) -= s0*T[1] + STR r9, [r4],#-16 @ aX[0] = r9 + CMP r4,r14 + MOV r12,r12,LSL #1 + STR r12,[r4,#8+16] @ aX[2] = r12 + + BGE presymmetry_loop1 @ while (aX >= in+n4) + +presymmetry_loop2: + LDR r6,[r4] @ r6 = s0 = aX[0] + LDR r10,[r5,#4] @ r10= T[1] + LDR r7,[r4,#8] @ r6 = s2 = aX[2] + LDR r11,[r5],-r2,LSL #2 @ r11= T[0] T -= step + + @ XPROD31(s0, s2, T[1], T[0], 0xaX[0], &ax[2]) + SMULL r8, r9, r6, r10 @ (r8, r9) = s0*T[1] + @ stall + @ stall ? + SMLAL r8, r9, r7, r11 @ (r8, r9) += s2*T[0] + RSB r6, r6, #0 + @ stall ? + SMULL r8, r12,r7, r10 @ (r8, r12) = s2*T[1] + MOV r9, r9, LSL #1 + @ stall ? + SMLAL r8, r12,r6, r11 @ (r8, r12) -= s0*T[0] + STR r9, [r4],#-16 @ aX[0] = r9 + CMP r4,r1 + MOV r12,r12,LSL #1 + STR r12,[r4,#8+16] @ aX[2] = r12 + + BGE presymmetry_loop2 @ while (aX >= in) + + @ r0 = n + @ r1 = in + @ r2 = step + @ r3 = shift + STMFD r13!,{r3} + ADRL r4, .Lsincos_lookup + LDR r5, [r4] @ r5 = T=sincos_lookup0 + ADD r5, r4 + ADD r4, r1, r0, LSL #1 @ r4 = aX = in+(n>>1) + SUB r4, r4, #4*4 @ r4 = aX = in+(n>>1)-4 + LDR r11,[r5,#4] @ r11= T[1] + LDR r10,[r5],r2, LSL #2 @ r10= T[0] T += step +presymmetry_loop3: + LDR r8,[r1],#16 @ r8 = ro0 = bX[0] + LDR r9,[r1,#8-16] @ r9 = ro2 = bX[2] + LDR r6,[r4] @ r6 = ri0 = aX[0] + + @ XNPROD31( ro2, ro0, T[1], T[0], 0xaX[0], &aX[2] ) + @ aX[0] = (ro2*T[1] - ro0*T[0])>>31 aX[2] = (ro0*T[1] + ro2*T[0])>>31 + SMULL r14,r12,r8, r11 @ (r14,r12) = ro0*T[1] + RSB r8,r8,#0 @ r8 = -ro0 + @ Stall ? + SMLAL r14,r12,r9, r10 @ (r14,r12) += ro2*T[0] + LDR r7,[r4,#8] @ r7 = ri2 = aX[2] + @ Stall ? + SMULL r14,r3, r9, r11 @ (r14,r3) = ro2*T[1] + MOV r12,r12,LSL #1 + LDR r11,[r5,#4] @ r11= T[1] + SMLAL r14,r3, r8, r10 @ (r14,r3) -= ro0*T[0] + LDR r10,[r5],r2, LSL #2 @ r10= T[0] T += step + STR r12,[r4,#8] + MOV r3, r3, LSL #1 + STR r3, [r4],#-16 + + @ XNPROD31( ri2, ri0, T[0], T[1], 0xbX[0], &bX[2] ) + @ bX[0] = (ri2*T[0] - ri0*T[1])>>31 bX[2] = (ri0*T[0] + ri2*T[1])>>31 + SMULL r14,r12,r6, r10 @ (r14,r12) = ri0*T[0] + RSB r6,r6,#0 @ r6 = -ri0 + @ stall ? + SMLAL r14,r12,r7, r11 @ (r14,r12) += ri2*T[1] + @ stall ? + @ stall ? + SMULL r14,r3, r7, r10 @ (r14,r3) = ri2*T[0] + MOV r12,r12,LSL #1 + @ stall ? + SMLAL r14,r3, r6, r11 @ (r14,r3) -= ri0*T[1] + CMP r4,r1 + STR r12,[r1,#8-16] + MOV r3, r3, LSL #1 + STR r3, [r1,#-16] + + BGE presymmetry_loop3 + + SUB r1,r1,r0 @ r1 = in -= n>>2 (i.e. restore in) + + LDR r3,[r13] + STR r2,[r13,#-4]! + + @ mdct_butterflies + @ r0 = n = (points * 2) + @ r1 = in = x + @ r2 = i + @ r3 = shift + STMFD r13!,{r0-r1} + ADRL r4, .Lsincos_lookup + LDR r5, [r4] + ADD r5, r4 + RSBS r4,r3,#6 @ r4 = stages = 7-shift then --stages + BLE no_generics + MOV r14,#4 @ r14= 4 (i=0) + MOV r6, r14,LSL r3 @ r6 = (4<>i = POINTS + MOV r2, r14,LSR #2 @ r2 = (1<>1) + ADD r7,r1,r0,LSL #1 @ r7 = x1+4 = x + POINTS + ADD r12,r5,#1024*4 @ r12= sincos_lookup0+1024 + +mdct_bufferfly_generic_loop1: + LDMDB r7!,{r2,r3,r8,r11} @ r2 = x1[0] + @ r3 = x1[1] + @ r8 = x1[2] + @ r11= x1[3] x1 -= 4 + LDMDB r1!,{r4,r9,r10,r14} @ r4 = x2[0] + @ r9 = x2[1] + @ r10= x2[2] + @ r14= x2[3] x2 -= 4 + + SUB r2, r2, r3 @ r2 = s0 = x1[0] - x1[1] + ADD r3, r2, r3, LSL #1 @ r3 = x1[0] + x1[1] (-> x1[0]) + SUB r11,r11,r8 @ r11= s1 = x1[3] - x1[2] + ADD r8, r11,r8, LSL #1 @ r8 = x1[3] + x1[2] (-> x1[2]) + SUB r9, r9, r4 @ r9 = s2 = x2[1] - x2[0] + ADD r4, r9, r4, LSL #1 @ r4 = x2[1] + x2[0] (-> x1[1]) + SUB r14,r14,r10 @ r14= s3 = x2[3] - x2[2] + ADD r10,r14,r10,LSL #1 @ r10= x2[3] + x2[2] (-> x1[3]) + STMIA r7,{r3,r4,r8,r10} + + @ r0 = points + @ r1 = x2 + @ r2 = s0 + @ r3 free + @ r4 free + @ r5 = T + @ r6 = step + @ r7 = x1 + @ r8 free + @ r9 = s2 + @ r10 free + @ r11= s1 + @ r12= limit + @ r14= s3 + + LDR r8, [r5,#4] @ r8 = T[1] + LDR r10,[r5],r6,LSL #2 @ r10= T[0] T += step + + @ XPROD31(s1, s0, T[0], T[1], &x2[0], &x2[2]) + @ x2[0] = (s1*T[0] + s0*T[1])>>31 x2[2] = (s0*T[0] - s1*T[1])>>31 + @ stall Xscale + SMULL r4, r3, r2, r8 @ (r4, r3) = s0*T[1] + SMLAL r4, r3, r11,r10 @ (r4, r3) += s1*T[0] + RSB r11,r11,#0 + SMULL r11,r4, r8, r11 @ (r11,r4) = -s1*T[1] + SMLAL r11,r4, r2, r10 @ (r11,r4) += s0*T[0] + MOV r2, r3, LSL #1 @ r2 = r3<<1 = Value for x2[0] + + @ XPROD31(s2, s3, T[0], T[1], &x2[1], &x2[3]) + @ x2[1] = (s2*T[0] + s3*T[1])>>31 x2[3] = (s3*T[0] - s2*T[1])>>31 + SMULL r11,r3, r9, r10 @ (r11,r3) = s2*T[0] + MOV r4, r4, LSL #1 @ r4 = r4<<1 = Value for x2[2] + SMLAL r11,r3, r14,r8 @ (r11,r3) += s3*T[1] + RSB r9, r9, #0 + SMULL r10,r11,r14,r10 @ (r10,r11) = s3*T[0] + MOV r3, r3, LSL #1 @ r3 = r3<<1 = Value for x2[1] + SMLAL r10,r11,r9,r8 @ (r10,r11) -= s2*T[1] + CMP r5, r12 + MOV r11,r11,LSL #1 @ r11= r11<<1 = Value for x2[3] + + STMIA r1,{r2,r3,r4,r11} + + BLT mdct_bufferfly_generic_loop1 + + SUB r12,r12,#1024*4 +mdct_bufferfly_generic_loop2: + LDMDB r7!,{r2,r3,r9,r10} @ r2 = x1[0] + @ r3 = x1[1] + @ r9 = x1[2] + @ r10= x1[3] x1 -= 4 + LDMDB r1!,{r4,r8,r11,r14} @ r4 = x2[0] + @ r8 = x2[1] + @ r11= x2[2] + @ r14= x2[3] x2 -= 4 + + SUB r2, r2, r3 @ r2 = s0 = x1[0] - x1[1] + ADD r3, r2, r3, LSL #1 @ r3 = x1[0] + x1[1] (-> x1[0]) + SUB r9, r9,r10 @ r9 = s1 = x1[2] - x1[3] + ADD r10,r9,r10, LSL #1 @ r10= x1[2] + x1[3] (-> x1[2]) + SUB r4, r4, r8 @ r4 = s2 = x2[0] - x2[1] + ADD r8, r4, r8, LSL #1 @ r8 = x2[0] + x2[1] (-> x1[1]) + SUB r14,r14,r11 @ r14= s3 = x2[3] - x2[2] + ADD r11,r14,r11,LSL #1 @ r11= x2[3] + x2[2] (-> x1[3]) + STMIA r7,{r3,r8,r10,r11} + + @ r0 = points + @ r1 = x2 + @ r2 = s0 + @ r3 free + @ r4 = s2 + @ r5 = T + @ r6 = step + @ r7 = x1 + @ r8 free + @ r9 = s1 + @ r10 free + @ r11 free + @ r12= limit + @ r14= s3 + + LDR r8, [r5,#4] @ r8 = T[1] + LDR r10,[r5],-r6,LSL #2 @ r10= T[0] T -= step + + @ XNPROD31(s0, s1, T[0], T[1], &x2[0], &x2[2]) + @ x2[0] = (s0*T[0] - s1*T[1])>>31 x2[2] = (s1*T[0] + s0*T[1])>>31 + @ stall Xscale + SMULL r3, r11,r2, r8 @ (r3, r11) = s0*T[1] + SMLAL r3, r11,r9, r10 @ (r3, r11) += s1*T[0] + RSB r9, r9, #0 + SMULL r3, r2, r10,r2 @ (r3, r2) = s0*T[0] + SMLAL r3, r2, r9, r8 @ (r3, r2) += -s1*T[1] + MOV r9, r11,LSL #1 @ r9 = r11<<1 = Value for x2[2] + + @ XNPROD31(s3, s2, T[0], T[1], &x2[1], &x2[3]) + @ x2[1] = (s3*T[0] - s2*T[1])>>31 x2[3] = (s2*T[0] + s3*T[1])>>31 + SMULL r3, r11,r4, r10 @ (r3,r11) = s2*T[0] + MOV r2, r2, LSL #1 @ r2 = r2<<1 = Value for x2[0] + SMLAL r3, r11,r14,r8 @ (r3,r11) += s3*T[1] + RSB r4, r4, #0 + SMULL r10,r3,r14,r10 @ (r10,r3) = s3*T[0] + MOV r11,r11,LSL #1 @ r11= r11<<1 = Value for x2[3] + SMLAL r10,r3, r4, r8 @ (r10,r3) -= s2*T[1] + CMP r5, r12 + MOV r3, r3, LSL #1 @ r3 = r3<<1 = Value for x2[1] + + STMIA r1,{r2,r3,r9,r11} + + BGT mdct_bufferfly_generic_loop2 + + LDR r2,[r13],#4 @ unstack r2 + ADD r1, r1, r0, LSL #2 @ r1 = x+POINTS*j + @ stall Xscale + SUBS r2, r2, #1 @ r2-- (j++) + BGT mdct_butterflies_loop2 + + LDMFD r13!,{r4,r14} + + LDR r1,[r13,#4] + + SUBS r4, r4, #1 @ stages-- + MOV r14,r14,LSL #1 @ r14= 4< x[16] + SUB r9, r9, r10 @ r9 = s1 = x[18] - x[19] + ADD r10,r9, r10,LSL #1 @ r10= x[18] + x[19] -> x[18] + SUB r8, r8, r7 @ r8 = s2 = x[ 1] - x[ 0] + ADD r7, r8, r7, LSL #1 @ r7 = x[ 1] + x[ 0] -> x[17] + SUB r12,r12,r11 @ r12= s3 = x[ 3] - x[ 2] + ADD r11,r12,r11, LSL #1 @ r11= x[ 3] + x[ 2] -> x[19] + STMIA r4!,{r6,r7,r10,r11} + + LDR r6,cPI1_8 + LDR r7,cPI3_8 + + @ XNPROD31( s0, s1, cPI3_8, cPI1_8, &x[ 0], &x[ 2] ) + @ x[0] = s0*cPI3_8 - s1*cPI1_8 x[2] = s1*cPI3_8 + s0*cPI1_8 + @ stall Xscale + SMULL r14,r11,r5, r6 @ (r14,r11) = s0*cPI1_8 + SMLAL r14,r11,r9, r7 @ (r14,r11) += s1*cPI3_8 + RSB r9, r9, #0 + SMULL r14,r5, r7, r5 @ (r14,r5) = s0*cPI3_8 + SMLAL r14,r5, r9, r6 @ (r14,r5) -= s1*cPI1_8 + MOV r11,r11,LSL #1 + MOV r5, r5, LSL #1 + + @ XPROD31 ( s2, s3, cPI1_8, cPI3_8, &x[ 1], &x[ 3] ) + @ x[1] = s2*cPI1_8 + s3*cPI3_8 x[3] = s3*cPI1_8 - s2*cPI3_8 + SMULL r14,r9, r8, r6 @ (r14,r9) = s2*cPI1_8 + SMLAL r14,r9, r12,r7 @ (r14,r9) += s3*cPI3_8 + RSB r8,r8,#0 + SMULL r14,r12,r6, r12 @ (r14,r12) = s3*cPI1_8 + SMLAL r14,r12,r8, r7 @ (r14,r12) -= s2*cPI3_8 + MOV r9, r9, LSL #1 + MOV r12,r12,LSL #1 + STMIA r1!,{r5,r9,r11,r12} + + @ block2 + LDMIA r4,{r5,r6,r9,r10} @ r5 = x[20] + @ r6 = x[21] + @ r9 = x[22] + @ r10= x[23] + LDMIA r1,{r7,r8,r11,r12} @ r7 = x[4] + @ r8 = x[5] + @ r11= x[6] + @ r12= x[7] + SUB r5, r5, r6 @ r5 = s0 = x[20] - x[21] + ADD r6, r5, r6, LSL #1 @ r6 = x[20] + x[21] -> x[20] + SUB r9, r9, r10 @ r9 = s1 = x[22] - x[23] + ADD r10,r9, r10,LSL #1 @ r10= x[22] + x[23] -> x[22] + SUB r8, r8, r7 @ r8 = s2 = x[ 5] - x[ 4] + ADD r7, r8, r7, LSL #1 @ r7 = x[ 5] + x[ 4] -> x[21] + SUB r12,r12,r11 @ r12= s3 = x[ 7] - x[ 6] + ADD r11,r12,r11, LSL #1 @ r11= x[ 7] + x[ 6] -> x[23] + LDR r14,cPI2_8 + STMIA r4!,{r6,r7,r10,r11} + + SUB r5, r5, r9 @ r5 = s0 - s1 + ADD r9, r5, r9, LSL #1 @ r9 = s0 + s1 + SMULL r6, r5, r14,r5 @ (r6,r5) = (s0-s1)*cPI2_8 + SUB r12,r12,r8 @ r12= s3 - s2 + ADD r8, r12,r8, LSL #1 @ r8 = s3 + s2 + + SMULL r6, r8, r14,r8 @ (r6,r8) = (s3+s2)*cPI2_8 + MOV r5, r5, LSL #1 + SMULL r6, r9, r14,r9 @ (r6,r9) = (s0+s1)*cPI2_8 + MOV r8, r8, LSL #1 + SMULL r6, r12,r14,r12 @ (r6,r12) = (s3-s2)*cPI2_8 + MOV r9, r9, LSL #1 + MOV r12,r12,LSL #1 + STMIA r1!,{r5,r8,r9,r12} + + @ block3 + LDMIA r4,{r5,r6,r9,r10} @ r5 = x[24] + @ r6 = x[25] + @ r9 = x[25] + @ r10= x[26] + LDMIA r1,{r7,r8,r11,r12} @ r7 = x[8] + @ r8 = x[9] + @ r11= x[10] + @ r12= x[11] + SUB r5, r5, r6 @ r5 = s0 = x[24] - x[25] + ADD r6, r5, r6, LSL #1 @ r6 = x[24] + x[25] -> x[25] + SUB r9, r9, r10 @ r9 = s1 = x[26] - x[27] + ADD r10,r9, r10,LSL #1 @ r10= x[26] + x[27] -> x[26] + SUB r8, r8, r7 @ r8 = s2 = x[ 9] - x[ 8] + ADD r7, r8, r7, LSL #1 @ r7 = x[ 9] + x[ 8] -> x[25] + SUB r12,r12,r11 @ r12= s3 = x[11] - x[10] + ADD r11,r12,r11, LSL #1 @ r11= x[11] + x[10] -> x[27] + STMIA r4!,{r6,r7,r10,r11} + + LDR r6,cPI3_8 + LDR r7,cPI1_8 + + @ XNPROD31( s0, s1, cPI1_8, cPI3_8, &x[ 8], &x[10] ) + @ x[8] = s0*cPI1_8 - s1*cPI3_8 x[10] = s1*cPI1_8 + s0*cPI3_8 + @ stall Xscale + SMULL r14,r11,r5, r6 @ (r14,r11) = s0*cPI3_8 + SMLAL r14,r11,r9, r7 @ (r14,r11) += s1*cPI1_8 + RSB r9, r9, #0 + SMULL r14,r5, r7, r5 @ (r14,r5) = s0*cPI1_8 + SMLAL r14,r5, r9, r6 @ (r14,r5) -= s1*cPI3_8 + MOV r11,r11,LSL #1 + MOV r5, r5, LSL #1 + + @ XPROD31 ( s2, s3, cPI3_8, cPI1_8, &x[ 9], &x[11] ) + @ x[9] = s2*cPI3_8 + s3*cPI1_8 x[11] = s3*cPI3_8 - s2*cPI1_8 + SMULL r14,r9, r8, r6 @ (r14,r9) = s2*cPI3_8 + SMLAL r14,r9, r12,r7 @ (r14,r9) += s3*cPI1_8 + RSB r8,r8,#0 + SMULL r14,r12,r6, r12 @ (r14,r12) = s3*cPI3_8 + SMLAL r14,r12,r8, r7 @ (r14,r12) -= s2*cPI1_8 + MOV r9, r9, LSL #1 + MOV r12,r12,LSL #1 + STMIA r1!,{r5,r9,r11,r12} + + @ block4 + LDMIA r4,{r5,r6,r10,r11} @ r5 = x[28] + @ r6 = x[29] + @ r10= x[30] + @ r11= x[31] + LDMIA r1,{r8,r9,r12,r14} @ r8 = x[12] + @ r9 = x[13] + @ r12= x[14] + @ r14= x[15] + SUB r5, r5, r6 @ r5 = s0 = x[28] - x[29] + ADD r6, r5, r6, LSL #1 @ r6 = x[28] + x[29] -> x[28] + SUB r7, r14,r12 @ r7 = s3 = x[15] - x[14] + ADD r12,r7, r12, LSL #1 @ r12= x[15] + x[14] -> x[31] + SUB r10,r10,r11 @ r10= s1 = x[30] - x[31] + ADD r11,r10,r11,LSL #1 @ r11= x[30] + x[31] -> x[30] + SUB r14, r8, r9 @ r14= s2 = x[12] - x[13] + ADD r9, r14, r9, LSL #1 @ r9 = x[12] + x[13] -> x[29] + STMIA r4!,{r6,r9,r11,r12} + STMIA r1!,{r5,r7,r10,r14} + + @ mdct_butterfly16 (1st version) + @ block 1 + SUB r1,r1,#16*4 + ADD r4,r1,#8*4 + LDMIA r4,{r5,r6,r9,r10} @ r5 = x[ 8] + @ r6 = x[ 9] + @ r9 = x[10] + @ r10= x[11] + LDMIA r1,{r7,r8,r11,r12} @ r7 = x[0] + @ r8 = x[1] + @ r11= x[2] + @ r12= x[3] + SUB r5, r5, r6 @ r5 = s0 = x[ 8] - x[ 9] + ADD r6, r5, r6, LSL #1 @ r6 = x[ 8] + x[ 9] -> x[ 8] + SUB r9, r9, r10 @ r9 = s1 = x[10] - x[11] + ADD r10,r9, r10,LSL #1 @ r10= x[10] + x[11] -> x[10] + SUB r8, r8, r7 @ r8 = s2 = x[ 1] - x[ 0] + ADD r7, r8, r7, LSL #1 @ r7 = x[ 1] + x[ 0] -> x[ 9] + SUB r12,r12,r11 @ r12= s3 = x[ 3] - x[ 2] + ADD r11,r12,r11, LSL #1 @ r11= x[ 3] + x[ 2] -> x[11] + LDR r14,cPI2_8 + STMIA r4!,{r6,r7,r10,r11} + + SUB r5, r5, r9 @ r5 = s0 - s1 + ADD r9, r5, r9, LSL #1 @ r9 = s0 + s1 + SMULL r6, r5, r14,r5 @ (r6,r5) = (s0-s1)*cPI2_8 + SUB r12,r12,r8 @ r12= s3 - s2 + ADD r8, r12,r8, LSL #1 @ r8 = s3 + s2 + + SMULL r6, r8, r14,r8 @ (r6,r8) = (s3+s2)*cPI2_8 + MOV r5, r5, LSL #1 + SMULL r6, r9, r14,r9 @ (r6,r9) = (s0+s1)*cPI2_8 + MOV r8, r8, LSL #1 + SMULL r6, r12,r14,r12 @ (r6,r12) = (s3-s2)*cPI2_8 + MOV r9, r9, LSL #1 + MOV r12,r12,LSL #1 + STMIA r1!,{r5,r8,r9,r12} + + @ block4 + LDMIA r4,{r5,r6,r9,r10} @ r5 = x[12] + @ r6 = x[13] + @ r9 = x[14] + @ r10= x[15] + LDMIA r1,{r7,r8,r11,r12} @ r7 = x[ 4] + @ r8 = x[ 5] + @ r11= x[ 6] + @ r12= x[ 7] + SUB r14,r7, r8 @ r14= s0 = x[ 4] - x[ 5] + ADD r8, r14,r8, LSL #1 @ r8 = x[ 4] + x[ 5] -> x[13] + SUB r7, r12,r11 @ r7 = s1 = x[ 7] - x[ 6] + ADD r11,r7, r11, LSL #1 @ r11= x[ 7] + x[ 6] -> x[15] + SUB r5, r5, r6 @ r5 = s2 = x[12] - x[13] + ADD r6, r5, r6, LSL #1 @ r6 = x[12] + x[13] -> x[12] + SUB r12,r9, r10 @ r12= s3 = x[14] - x[15] + ADD r10,r12,r10,LSL #1 @ r10= x[14] + x[15] -> x[14] + STMIA r4!,{r6,r8,r10,r11} + STMIA r1!,{r5,r7,r12,r14} + + @ mdct_butterfly_8 + LDMDB r1,{r6,r7,r8,r9,r10,r11,r12,r14} + @ r6 = x[0] + @ r7 = x[1] + @ r8 = x[2] + @ r9 = x[3] + @ r10= x[4] + @ r11= x[5] + @ r12= x[6] + @ r14= x[7] + ADD r6, r6, r7 @ r6 = s0 = x[0] + x[1] + SUB r7, r6, r7, LSL #1 @ r7 = s1 = x[0] - x[1] + ADD r8, r8, r9 @ r8 = s2 = x[2] + x[3] + SUB r9, r8, r9, LSL #1 @ r9 = s3 = x[2] - x[3] + ADD r10,r10,r11 @ r10= s4 = x[4] + x[5] + SUB r11,r10,r11,LSL #1 @ r11= s5 = x[4] - x[5] + ADD r12,r12,r14 @ r12= s6 = x[6] + x[7] + SUB r14,r12,r14,LSL #1 @ r14= s7 = x[6] - x[7] + + ADD r2, r11,r9 @ r2 = x[0] = s5 + s3 + SUB r4, r2, r9, LSL #1 @ r4 = x[2] = s5 - s3 + SUB r3, r14,r7 @ r3 = x[1] = s7 - s1 + ADD r5, r3, r7, LSL #1 @ r5 = x[3] = s7 + s1 + SUB r10,r10,r6 @ r10= x[4] = s4 - s0 + SUB r11,r12,r8 @ r11= x[5] = s6 - s2 + ADD r12,r10,r6, LSL #1 @ r12= x[6] = s4 + s0 + ADD r14,r11,r8, LSL #1 @ r14= x[7] = s6 + s2 + STMDB r1,{r2,r3,r4,r5,r10,r11,r12,r14} + + @ mdct_butterfly_8 + LDMIA r1,{r6,r7,r8,r9,r10,r11,r12,r14} + @ r6 = x[0] + @ r7 = x[1] + @ r8 = x[2] + @ r9 = x[3] + @ r10= x[4] + @ r11= x[5] + @ r12= x[6] + @ r14= x[7] + ADD r6, r6, r7 @ r6 = s0 = x[0] + x[1] + SUB r7, r6, r7, LSL #1 @ r7 = s1 = x[0] - x[1] + ADD r8, r8, r9 @ r8 = s2 = x[2] + x[3] + SUB r9, r8, r9, LSL #1 @ r9 = s3 = x[2] - x[3] + ADD r10,r10,r11 @ r10= s4 = x[4] + x[5] + SUB r11,r10,r11,LSL #1 @ r11= s5 = x[4] - x[5] + ADD r12,r12,r14 @ r12= s6 = x[6] + x[7] + SUB r14,r12,r14,LSL #1 @ r14= s7 = x[6] - x[7] + + ADD r2, r11,r9 @ r2 = x[0] = s5 + s3 + SUB r4, r2, r9, LSL #1 @ r4 = x[2] = s5 - s3 + SUB r3, r14,r7 @ r3 = x[1] = s7 - s1 + ADD r5, r3, r7, LSL #1 @ r5 = x[3] = s7 + s1 + SUB r10,r10,r6 @ r10= x[4] = s4 - s0 + SUB r11,r12,r8 @ r11= x[5] = s6 - s2 + ADD r12,r10,r6, LSL #1 @ r12= x[6] = s4 + s0 + ADD r14,r11,r8, LSL #1 @ r14= x[7] = s6 + s2 + STMIA r1,{r2,r3,r4,r5,r10,r11,r12,r14} + + @ block 2 + ADD r1,r1,#16*4-8*4 + ADD r4,r1,#8*4 + LDMIA r4,{r5,r6,r9,r10} @ r5 = x[ 8] + @ r6 = x[ 9] + @ r9 = x[10] + @ r10= x[11] + LDMIA r1,{r7,r8,r11,r12} @ r7 = x[0] + @ r8 = x[1] + @ r11= x[2] + @ r12= x[3] + SUB r5, r5, r6 @ r5 = s0 = x[ 8] - x[ 9] + ADD r6, r5, r6, LSL #1 @ r6 = x[ 8] + x[ 9] -> x[ 8] + SUB r9, r9, r10 @ r9 = s1 = x[10] - x[11] + ADD r10,r9, r10,LSL #1 @ r10= x[10] + x[11] -> x[10] + SUB r8, r8, r7 @ r8 = s2 = x[ 1] - x[ 0] + ADD r7, r8, r7, LSL #1 @ r7 = x[ 1] + x[ 0] -> x[ 9] + SUB r12,r12,r11 @ r12= s3 = x[ 3] - x[ 2] + ADD r11,r12,r11, LSL #1 @ r11= x[ 3] + x[ 2] -> x[11] + LDR r14,cPI2_8 + STMIA r4!,{r6,r7,r10,r11} + + SUB r5, r5, r9 @ r5 = s0 - s1 + ADD r9, r5, r9, LSL #1 @ r9 = s0 + s1 + SMULL r6, r5, r14,r5 @ (r6,r5) = (s0-s1)*cPI2_8 + SUB r12,r12,r8 @ r12= s3 - s2 + ADD r8, r12,r8, LSL #1 @ r8 = s3 + s2 + + SMULL r6, r8, r14,r8 @ (r6,r8) = (s3+s2)*cPI2_8 + MOV r5, r5, LSL #1 + SMULL r6, r9, r14,r9 @ (r6,r9) = (s0+s1)*cPI2_8 + MOV r8, r8, LSL #1 + SMULL r6, r12,r14,r12 @ (r6,r12) = (s3-s2)*cPI2_8 + MOV r9, r9, LSL #1 + MOV r12,r12,LSL #1 + STMIA r1!,{r5,r8,r9,r12} + + @ block4 + LDMIA r4,{r5,r6,r9,r10} @ r5 = x[12] + @ r6 = x[13] + @ r9 = x[14] + @ r10= x[15] + LDMIA r1,{r7,r8,r11,r12} @ r7 = x[ 4] + @ r8 = x[ 5] + @ r11= x[ 6] + @ r12= x[ 7] + SUB r5, r5, r6 @ r5 = s2 = x[12] - x[13] + ADD r6, r5, r6, LSL #1 @ r6 = x[12] + x[13] -> x[12] + SUB r9, r9, r10 @ r9 = s3 = x[14] - x[15] + ADD r10,r9, r10,LSL #1 @ r10= x[14] + x[15] -> x[14] + SUB r14,r7, r8 @ r14= s0 = x[ 4] - x[ 5] + ADD r8, r14,r8, LSL #1 @ r8 = x[ 4] + x[ 5] -> x[13] + SUB r7, r12,r11 @ r7 = s1 = x[ 7] - x[ 6] + ADD r11,r7, r11, LSL #1 @ r11= x[ 7] + x[ 6] -> x[15] + STMIA r4!,{r6,r8,r10,r11} + STMIA r1!,{r5,r7,r9,r14} + + @ mdct_butterfly_8 + LDMDB r1,{r6,r7,r8,r9,r10,r11,r12,r14} + @ r6 = x[0] + @ r7 = x[1] + @ r8 = x[2] + @ r9 = x[3] + @ r10= x[4] + @ r11= x[5] + @ r12= x[6] + @ r14= x[7] + ADD r6, r6, r7 @ r6 = s0 = x[0] + x[1] + SUB r7, r6, r7, LSL #1 @ r7 = s1 = x[0] - x[1] + ADD r8, r8, r9 @ r8 = s2 = x[2] + x[3] + SUB r9, r8, r9, LSL #1 @ r9 = s3 = x[2] - x[3] + ADD r10,r10,r11 @ r10= s4 = x[4] + x[5] + SUB r11,r10,r11,LSL #1 @ r11= s5 = x[4] - x[5] + ADD r12,r12,r14 @ r12= s6 = x[6] + x[7] + SUB r14,r12,r14,LSL #1 @ r14= s7 = x[6] - x[7] + + ADD r2, r11,r9 @ r2 = x[0] = s5 + s3 + SUB r4, r2, r9, LSL #1 @ r4 = x[2] = s5 - s3 + SUB r3, r14,r7 @ r3 = x[1] = s7 - s1 + ADD r5, r3, r7, LSL #1 @ r5 = x[3] = s7 + s1 + SUB r10,r10,r6 @ r10= x[4] = s4 - s0 + SUB r11,r12,r8 @ r11= x[5] = s6 - s2 + ADD r12,r10,r6, LSL #1 @ r12= x[6] = s4 + s0 + ADD r14,r11,r8, LSL #1 @ r14= x[7] = s6 + s2 + STMDB r1,{r2,r3,r4,r5,r10,r11,r12,r14} + + @ mdct_butterfly_8 + LDMIA r1,{r6,r7,r8,r9,r10,r11,r12,r14} + @ r6 = x[0] + @ r7 = x[1] + @ r8 = x[2] + @ r9 = x[3] + @ r10= x[4] + @ r11= x[5] + @ r12= x[6] + @ r14= x[7] + ADD r6, r6, r7 @ r6 = s0 = x[0] + x[1] + SUB r7, r6, r7, LSL #1 @ r7 = s1 = x[0] - x[1] + ADD r8, r8, r9 @ r8 = s2 = x[2] + x[3] + SUB r9, r8, r9, LSL #1 @ r9 = s3 = x[2] - x[3] + ADD r10,r10,r11 @ r10= s4 = x[4] + x[5] + SUB r11,r10,r11,LSL #1 @ r11= s5 = x[4] - x[5] + ADD r12,r12,r14 @ r12= s6 = x[6] + x[7] + SUB r14,r12,r14,LSL #1 @ r14= s7 = x[6] - x[7] + + ADD r2, r11,r9 @ r2 = x[0] = s5 + s3 + SUB r4, r2, r9, LSL #1 @ r4 = x[2] = s5 - s3 + SUB r3, r14,r7 @ r3 = x[1] = s7 - s1 + ADD r5, r3, r7, LSL #1 @ r5 = x[3] = s7 + s1 + SUB r10,r10,r6 @ r10= x[4] = s4 - s0 + SUB r11,r12,r8 @ r11= x[5] = s6 - s2 + ADD r12,r10,r6, LSL #1 @ r12= x[6] = s4 + s0 + ADD r14,r11,r8, LSL #1 @ r14= x[7] = s6 + s2 + STMIA r1,{r2,r3,r4,r5,r10,r11,r12,r14} + + ADD r1,r1,#8*4 + SUBS r0,r0,#64 + BGT mdct_bufferflies_loop3 + + LDMFD r13,{r0-r3} + +mdct_bitreverseARM: + @ r0 = points = n + @ r1 = in + @ r2 = step + @ r3 = shift + + MOV r4, #0 @ r4 = bit = 0 + ADD r5, r1, r0, LSL #1 @ r5 = w = x + (n>>1) + ADR r6, bitrev + SUB r5, r5, #8 +brev_lp: + LDRB r7, [r6, r4, LSR #6] + AND r8, r4, #0x3f + LDRB r8, [r6, r8] + ADD r4, r4, #1 @ bit++ + @ stall XScale + ORR r7, r7, r8, LSL #6 @ r7 = bitrev[bit] + MOV r7, r7, LSR r3 + ADD r9, r1, r7, LSL #2 @ r9 = xx = x + (b>>shift) + CMP r5, r9 @ if (w > xx) + LDR r10,[r5],#-8 @ r10 = w[0] w -= 2 + LDRGT r11,[r5,#12] @ r11 = w[1] + LDRGT r12,[r9] @ r12 = xx[0] + LDRGT r14,[r9,#4] @ r14 = xx[1] + STRGT r10,[r9] @ xx[0]= w[0] + STRGT r11,[r9,#4] @ xx[1]= w[1] + STRGT r12,[r5,#8] @ w[0] = xx[0] + STRGT r14,[r5,#12] @ w[1] = xx[1] + CMP r5,r1 + BGT brev_lp + + @ mdct_step7 + @ r0 = points + @ r1 = in + @ r2 = step + @ r3 = shift + + CMP r2, #4 @ r5 = T = (step>=4) ? + ADR r7, .Lsincos_lookup @ sincos_lookup0 + + ADDLT r7, #4 @ sincos_lookup1 + LDR r5, [r7] + ADD r5, r7 + ADD r7, r1, r0, LSL #1 @ r7 = w1 = x + (n>>1) + ADDGE r5, r5, r2, LSL #1 @ (step>>1) + ADD r8, r5, #1024*4 @ r8 = Ttop +step7_loop1: + LDR r6, [r1] @ r6 = w0[0] + LDR r9, [r1,#4] @ r9 = w0[1] + LDR r10,[r7,#-8]! @ r10= w1[0] w1 -= 2 + LDR r11,[r7,#4] @ r11= w1[1] + LDR r14,[r5,#4] @ r14= T[1] + LDR r12,[r5],r2,LSL #2 @ r12= T[0] T += step + + ADD r6, r6, r10 @ r6 = s0 = w0[0] + w1[0] + SUB r10,r6, r10,LSL #1 @ r10= s1b= w0[0] - w1[0] + SUB r11,r11,r9 @ r11= s1 = w1[1] - w0[1] + ADD r9, r11,r9, LSL #1 @ r9 = s0b= w1[1] + w0[1] + + @ Can save 1 cycle by using SMULL SMLAL - at the cost of being + @ 1 off. + SMULL r0, r3, r6, r14 @ (r0,r3) = s0*T[1] + SMULL r0, r4, r11,r12 @ (r0,r4) += s1*T[0] = s2 + ADD r3, r3, r4 + SMULL r0, r14,r11,r14 @ (r0,r14) = s1*T[1] + SMULL r0, r12,r6, r12 @ (r0,r12) += s0*T[0] = s3 + SUB r14,r14,r12 + + @ r9 = s0b<<1 + @ r10= s1b<<1 + ADD r9, r3, r9, ASR #1 @ r9 = s0b + s2 + SUB r3, r9, r3, LSL #1 @ r3 = s0b - s2 + + SUB r12,r14,r10,ASR #1 @ r12= s3 - s1b + ADD r10,r14,r10,ASR #1 @ r10= s3 + s1b + STR r9, [r1],#4 + STR r10,[r1],#4 @ w0 += 2 + STR r3, [r7] + STR r12,[r7,#4] + + CMP r5,r8 + BLT step7_loop1 + +step7_loop2: + LDR r6, [r1] @ r6 = w0[0] + LDR r9, [r1,#4] @ r9 = w0[1] + LDR r10,[r7,#-8]! @ r10= w1[0] w1 -= 2 + LDR r11,[r7,#4] @ r11= w1[1] + LDR r14,[r5,-r2,LSL #2]! @ r12= T[1] T -= step + LDR r12,[r5,#4] @ r14= T[0] + + ADD r6, r6, r10 @ r6 = s0 = w0[0] + w1[0] + SUB r10,r6, r10,LSL #1 @ r10= s1b= w0[0] - w1[0] + SUB r11,r11,r9 @ r11= s1 = w1[1] - w0[1] + ADD r9, r11,r9, LSL #1 @ r9 = s0b= w1[1] + w0[1] + + @ Can save 1 cycle by using SMULL SMLAL - at the cost of being + @ 1 off. + SMULL r0, r3, r6, r14 @ (r0,r3) = s0*T[0] + SMULL r0, r4, r11,r12 @ (r0,r4) += s1*T[1] = s2 + ADD r3, r3, r4 + SMULL r0, r14,r11,r14 @ (r0,r14) = s1*T[0] + SMULL r0, r12,r6, r12 @ (r0,r12) += s0*T[1] = s3 + SUB r14,r14,r12 + + @ r9 = s0b<<1 + @ r10= s1b<<1 + ADD r9, r3, r9, ASR #1 @ r9 = s0b + s2 + SUB r3, r9, r3, LSL #1 @ r3 = s0b - s2 + + SUB r12,r14,r10,ASR #1 @ r12= s3 - s1b + ADD r10,r14,r10,ASR #1 @ r10= s3 + s1b + STR r9, [r1],#4 + STR r10,[r1],#4 @ w0 += 2 + STR r3, [r7] + STR r12,[r7,#4] + + CMP r1,r7 + BLT step7_loop2 + + LDMFD r13!,{r0-r3} + + @ r0 = points + @ r1 = in + @ r2 = step + @ r3 = shift + MOV r2, r2, ASR #2 @ r2 = step >>= 2 + CMP r2, #0 + CMPNE r2, #1 + BEQ mdct_end + + @ step > 1 (default case) + CMP r2, #4 @ r5 = T = (step>=4) ? + ADR r7, .Lsincos_lookup @ sincos_lookup0 + + ADDLT r7, #4 @ sincos_lookup1 + LDR r5, [r7] + ADD r5, r7 + ADD r7, r1, r0, LSL #1 @ r7 = iX = x + (n>>1) + ADDGE r5, r5, r2, LSL #1 @ (step>>1) +mdct_step8_default: + LDR r6, [r1],#4 @ r6 = s0 = x[0] + LDR r8, [r1],#4 @ r8 = -s1 = x[1] + LDR r12,[r5,#4] @ r12= T[1] + LDR r14,[r5],r2,LSL #2 @ r14= T[0] T += step + RSB r8, r8, #0 @ r8 = s1 + + @ XPROD31(s0, s1, T[0], T[1], x, x+1) + @ x[0] = s0 * T[0] + s1 * T[1] x[1] = s1 * T[0] - s0 * T[1] + SMULL r9, r10, r8, r12 @ (r9,r10) = s1 * T[1] + CMP r1, r7 + SMLAL r9, r10, r6, r14 @ (r9,r10) += s0 * T[0] + RSB r6, r6, #0 @ r6 = -s0 + SMULL r9, r11, r8, r14 @ (r9,r11) = s1 * T[0] + MOV r10,r10,LSL #1 + SMLAL r9, r11, r6, r12 @ (r9,r11) -= s0 * T[1] + STR r10,[r1,#-8] + MOV r11,r11,LSL #1 + STR r11,[r1,#-4] + BLT mdct_step8_default + +mdct_end: + MOV r0, r2 + LDMFD r13!,{r4-r11,PC} + +cPI1_8: + .word 0x7641af3d +cPI2_8: + .word 0x5a82799a +cPI3_8: + .word 0x30fbc54d +bitrev: + .byte 0 + .byte 32 + .byte 16 + .byte 48 + .byte 8 + .byte 40 + .byte 24 + .byte 56 + .byte 4 + .byte 36 + .byte 20 + .byte 52 + .byte 12 + .byte 44 + .byte 28 + .byte 60 + .byte 2 + .byte 34 + .byte 18 + .byte 50 + .byte 10 + .byte 42 + .byte 26 + .byte 58 + .byte 6 + .byte 38 + .byte 22 + .byte 54 + .byte 14 + .byte 46 + .byte 30 + .byte 62 + .byte 1 + .byte 33 + .byte 17 + .byte 49 + .byte 9 + .byte 41 + .byte 25 + .byte 57 + .byte 5 + .byte 37 + .byte 21 + .byte 53 + .byte 13 + .byte 45 + .byte 29 + .byte 61 + .byte 3 + .byte 35 + .byte 19 + .byte 51 + .byte 11 + .byte 43 + .byte 27 + .byte 59 + .byte 7 + .byte 39 + .byte 23 + .byte 55 + .byte 15 + .byte 47 + .byte 31 + .byte 63 + +.Lsincos_lookup: + .word sincos_lookup0-.Lsincos_lookup + .word sincos_lookup1-(.Lsincos_lookup+4) + + @ END diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct_lookup.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct_lookup.h new file mode 100644 index 0000000..a25ea3e --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/mdct_lookup.h @@ -0,0 +1,559 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: sin,cos lookup tables + + ************************************************************************/ + +#include "os_types.h" + +/* {sin(2*i*PI/4096), cos(2*i*PI/4096)}, with i = 0 to 512 */ +LOOKUP_T sincos_lookup0[1026] = { + X(0x00000000), X(0x7fffffff), X(0x003243f5), X(0x7ffff621), + X(0x006487e3), X(0x7fffd886), X(0x0096cbc1), X(0x7fffa72c), + X(0x00c90f88), X(0x7fff6216), X(0x00fb5330), X(0x7fff0943), + X(0x012d96b1), X(0x7ffe9cb2), X(0x015fda03), X(0x7ffe1c65), + X(0x01921d20), X(0x7ffd885a), X(0x01c45ffe), X(0x7ffce093), + X(0x01f6a297), X(0x7ffc250f), X(0x0228e4e2), X(0x7ffb55ce), + X(0x025b26d7), X(0x7ffa72d1), X(0x028d6870), X(0x7ff97c18), + X(0x02bfa9a4), X(0x7ff871a2), X(0x02f1ea6c), X(0x7ff75370), + X(0x03242abf), X(0x7ff62182), X(0x03566a96), X(0x7ff4dbd9), + X(0x0388a9ea), X(0x7ff38274), X(0x03bae8b2), X(0x7ff21553), + X(0x03ed26e6), X(0x7ff09478), X(0x041f6480), X(0x7feeffe1), + X(0x0451a177), X(0x7fed5791), X(0x0483ddc3), X(0x7feb9b85), + X(0x04b6195d), X(0x7fe9cbc0), X(0x04e8543e), X(0x7fe7e841), + X(0x051a8e5c), X(0x7fe5f108), X(0x054cc7b1), X(0x7fe3e616), + X(0x057f0035), X(0x7fe1c76b), X(0x05b137df), X(0x7fdf9508), + X(0x05e36ea9), X(0x7fdd4eec), X(0x0615a48b), X(0x7fdaf519), + X(0x0647d97c), X(0x7fd8878e), X(0x067a0d76), X(0x7fd6064c), + X(0x06ac406f), X(0x7fd37153), X(0x06de7262), X(0x7fd0c8a3), + X(0x0710a345), X(0x7fce0c3e), X(0x0742d311), X(0x7fcb3c23), + X(0x077501be), X(0x7fc85854), X(0x07a72f45), X(0x7fc560cf), + X(0x07d95b9e), X(0x7fc25596), X(0x080b86c2), X(0x7fbf36aa), + X(0x083db0a7), X(0x7fbc040a), X(0x086fd947), X(0x7fb8bdb8), + X(0x08a2009a), X(0x7fb563b3), X(0x08d42699), X(0x7fb1f5fc), + X(0x09064b3a), X(0x7fae7495), X(0x09386e78), X(0x7faadf7c), + X(0x096a9049), X(0x7fa736b4), X(0x099cb0a7), X(0x7fa37a3c), + X(0x09cecf89), X(0x7f9faa15), X(0x0a00ece8), X(0x7f9bc640), + X(0x0a3308bd), X(0x7f97cebd), X(0x0a6522fe), X(0x7f93c38c), + X(0x0a973ba5), X(0x7f8fa4b0), X(0x0ac952aa), X(0x7f8b7227), + X(0x0afb6805), X(0x7f872bf3), X(0x0b2d7baf), X(0x7f82d214), + X(0x0b5f8d9f), X(0x7f7e648c), X(0x0b919dcf), X(0x7f79e35a), + X(0x0bc3ac35), X(0x7f754e80), X(0x0bf5b8cb), X(0x7f70a5fe), + X(0x0c27c389), X(0x7f6be9d4), X(0x0c59cc68), X(0x7f671a05), + X(0x0c8bd35e), X(0x7f62368f), X(0x0cbdd865), X(0x7f5d3f75), + X(0x0cefdb76), X(0x7f5834b7), X(0x0d21dc87), X(0x7f531655), + X(0x0d53db92), X(0x7f4de451), X(0x0d85d88f), X(0x7f489eaa), + X(0x0db7d376), X(0x7f434563), X(0x0de9cc40), X(0x7f3dd87c), + X(0x0e1bc2e4), X(0x7f3857f6), X(0x0e4db75b), X(0x7f32c3d1), + X(0x0e7fa99e), X(0x7f2d1c0e), X(0x0eb199a4), X(0x7f2760af), + X(0x0ee38766), X(0x7f2191b4), X(0x0f1572dc), X(0x7f1baf1e), + X(0x0f475bff), X(0x7f15b8ee), X(0x0f7942c7), X(0x7f0faf25), + X(0x0fab272b), X(0x7f0991c4), X(0x0fdd0926), X(0x7f0360cb), + X(0x100ee8ad), X(0x7efd1c3c), X(0x1040c5bb), X(0x7ef6c418), + X(0x1072a048), X(0x7ef05860), X(0x10a4784b), X(0x7ee9d914), + X(0x10d64dbd), X(0x7ee34636), X(0x11082096), X(0x7edc9fc6), + X(0x1139f0cf), X(0x7ed5e5c6), X(0x116bbe60), X(0x7ecf1837), + X(0x119d8941), X(0x7ec8371a), X(0x11cf516a), X(0x7ec14270), + X(0x120116d5), X(0x7eba3a39), X(0x1232d979), X(0x7eb31e78), + X(0x1264994e), X(0x7eabef2c), X(0x1296564d), X(0x7ea4ac58), + X(0x12c8106f), X(0x7e9d55fc), X(0x12f9c7aa), X(0x7e95ec1a), + X(0x132b7bf9), X(0x7e8e6eb2), X(0x135d2d53), X(0x7e86ddc6), + X(0x138edbb1), X(0x7e7f3957), X(0x13c0870a), X(0x7e778166), + X(0x13f22f58), X(0x7e6fb5f4), X(0x1423d492), X(0x7e67d703), + X(0x145576b1), X(0x7e5fe493), X(0x148715ae), X(0x7e57dea7), + X(0x14b8b17f), X(0x7e4fc53e), X(0x14ea4a1f), X(0x7e47985b), + X(0x151bdf86), X(0x7e3f57ff), X(0x154d71aa), X(0x7e37042a), + X(0x157f0086), X(0x7e2e9cdf), X(0x15b08c12), X(0x7e26221f), + X(0x15e21445), X(0x7e1d93ea), X(0x16139918), X(0x7e14f242), + X(0x16451a83), X(0x7e0c3d29), X(0x1676987f), X(0x7e0374a0), + X(0x16a81305), X(0x7dfa98a8), X(0x16d98a0c), X(0x7df1a942), + X(0x170afd8d), X(0x7de8a670), X(0x173c6d80), X(0x7ddf9034), + X(0x176dd9de), X(0x7dd6668f), X(0x179f429f), X(0x7dcd2981), + X(0x17d0a7bc), X(0x7dc3d90d), X(0x1802092c), X(0x7dba7534), + X(0x183366e9), X(0x7db0fdf8), X(0x1864c0ea), X(0x7da77359), + X(0x18961728), X(0x7d9dd55a), X(0x18c7699b), X(0x7d9423fc), + X(0x18f8b83c), X(0x7d8a5f40), X(0x192a0304), X(0x7d808728), + X(0x195b49ea), X(0x7d769bb5), X(0x198c8ce7), X(0x7d6c9ce9), + X(0x19bdcbf3), X(0x7d628ac6), X(0x19ef0707), X(0x7d58654d), + X(0x1a203e1b), X(0x7d4e2c7f), X(0x1a517128), X(0x7d43e05e), + X(0x1a82a026), X(0x7d3980ec), X(0x1ab3cb0d), X(0x7d2f0e2b), + X(0x1ae4f1d6), X(0x7d24881b), X(0x1b161479), X(0x7d19eebf), + X(0x1b4732ef), X(0x7d0f4218), X(0x1b784d30), X(0x7d048228), + X(0x1ba96335), X(0x7cf9aef0), X(0x1bda74f6), X(0x7ceec873), + X(0x1c0b826a), X(0x7ce3ceb2), X(0x1c3c8b8c), X(0x7cd8c1ae), + X(0x1c6d9053), X(0x7ccda169), X(0x1c9e90b8), X(0x7cc26de5), + X(0x1ccf8cb3), X(0x7cb72724), X(0x1d00843d), X(0x7cabcd28), + X(0x1d31774d), X(0x7ca05ff1), X(0x1d6265dd), X(0x7c94df83), + X(0x1d934fe5), X(0x7c894bde), X(0x1dc4355e), X(0x7c7da505), + X(0x1df5163f), X(0x7c71eaf9), X(0x1e25f282), X(0x7c661dbc), + X(0x1e56ca1e), X(0x7c5a3d50), X(0x1e879d0d), X(0x7c4e49b7), + X(0x1eb86b46), X(0x7c4242f2), X(0x1ee934c3), X(0x7c362904), + X(0x1f19f97b), X(0x7c29fbee), X(0x1f4ab968), X(0x7c1dbbb3), + X(0x1f7b7481), X(0x7c116853), X(0x1fac2abf), X(0x7c0501d2), + X(0x1fdcdc1b), X(0x7bf88830), X(0x200d888d), X(0x7bebfb70), + X(0x203e300d), X(0x7bdf5b94), X(0x206ed295), X(0x7bd2a89e), + X(0x209f701c), X(0x7bc5e290), X(0x20d0089c), X(0x7bb9096b), + X(0x21009c0c), X(0x7bac1d31), X(0x21312a65), X(0x7b9f1de6), + X(0x2161b3a0), X(0x7b920b89), X(0x219237b5), X(0x7b84e61f), + X(0x21c2b69c), X(0x7b77ada8), X(0x21f3304f), X(0x7b6a6227), + X(0x2223a4c5), X(0x7b5d039e), X(0x225413f8), X(0x7b4f920e), + X(0x22847de0), X(0x7b420d7a), X(0x22b4e274), X(0x7b3475e5), + X(0x22e541af), X(0x7b26cb4f), X(0x23159b88), X(0x7b190dbc), + X(0x2345eff8), X(0x7b0b3d2c), X(0x23763ef7), X(0x7afd59a4), + X(0x23a6887f), X(0x7aef6323), X(0x23d6cc87), X(0x7ae159ae), + X(0x24070b08), X(0x7ad33d45), X(0x243743fa), X(0x7ac50dec), + X(0x24677758), X(0x7ab6cba4), X(0x2497a517), X(0x7aa8766f), + X(0x24c7cd33), X(0x7a9a0e50), X(0x24f7efa2), X(0x7a8b9348), + X(0x25280c5e), X(0x7a7d055b), X(0x2558235f), X(0x7a6e648a), + X(0x2588349d), X(0x7a5fb0d8), X(0x25b84012), X(0x7a50ea47), + X(0x25e845b6), X(0x7a4210d8), X(0x26184581), X(0x7a332490), + X(0x26483f6c), X(0x7a24256f), X(0x26783370), X(0x7a151378), + X(0x26a82186), X(0x7a05eead), X(0x26d809a5), X(0x79f6b711), + X(0x2707ebc7), X(0x79e76ca7), X(0x2737c7e3), X(0x79d80f6f), + X(0x27679df4), X(0x79c89f6e), X(0x27976df1), X(0x79b91ca4), + X(0x27c737d3), X(0x79a98715), X(0x27f6fb92), X(0x7999dec4), + X(0x2826b928), X(0x798a23b1), X(0x2856708d), X(0x797a55e0), + X(0x288621b9), X(0x796a7554), X(0x28b5cca5), X(0x795a820e), + X(0x28e5714b), X(0x794a7c12), X(0x29150fa1), X(0x793a6361), + X(0x2944a7a2), X(0x792a37fe), X(0x29743946), X(0x7919f9ec), + X(0x29a3c485), X(0x7909a92d), X(0x29d34958), X(0x78f945c3), + X(0x2a02c7b8), X(0x78e8cfb2), X(0x2a323f9e), X(0x78d846fb), + X(0x2a61b101), X(0x78c7aba2), X(0x2a911bdc), X(0x78b6fda8), + X(0x2ac08026), X(0x78a63d11), X(0x2aefddd8), X(0x789569df), + X(0x2b1f34eb), X(0x78848414), X(0x2b4e8558), X(0x78738bb3), + X(0x2b7dcf17), X(0x786280bf), X(0x2bad1221), X(0x7851633b), + X(0x2bdc4e6f), X(0x78403329), X(0x2c0b83fa), X(0x782ef08b), + X(0x2c3ab2b9), X(0x781d9b65), X(0x2c69daa6), X(0x780c33b8), + X(0x2c98fbba), X(0x77fab989), X(0x2cc815ee), X(0x77e92cd9), + X(0x2cf72939), X(0x77d78daa), X(0x2d263596), X(0x77c5dc01), + X(0x2d553afc), X(0x77b417df), X(0x2d843964), X(0x77a24148), + X(0x2db330c7), X(0x7790583e), X(0x2de2211e), X(0x777e5cc3), + X(0x2e110a62), X(0x776c4edb), X(0x2e3fec8b), X(0x775a2e89), + X(0x2e6ec792), X(0x7747fbce), X(0x2e9d9b70), X(0x7735b6af), + X(0x2ecc681e), X(0x77235f2d), X(0x2efb2d95), X(0x7710f54c), + X(0x2f29ebcc), X(0x76fe790e), X(0x2f58a2be), X(0x76ebea77), + X(0x2f875262), X(0x76d94989), X(0x2fb5fab2), X(0x76c69647), + X(0x2fe49ba7), X(0x76b3d0b4), X(0x30133539), X(0x76a0f8d2), + X(0x3041c761), X(0x768e0ea6), X(0x30705217), X(0x767b1231), + X(0x309ed556), X(0x76680376), X(0x30cd5115), X(0x7654e279), + X(0x30fbc54d), X(0x7641af3d), X(0x312a31f8), X(0x762e69c4), + X(0x3158970e), X(0x761b1211), X(0x3186f487), X(0x7607a828), + X(0x31b54a5e), X(0x75f42c0b), X(0x31e39889), X(0x75e09dbd), + X(0x3211df04), X(0x75ccfd42), X(0x32401dc6), X(0x75b94a9c), + X(0x326e54c7), X(0x75a585cf), X(0x329c8402), X(0x7591aedd), + X(0x32caab6f), X(0x757dc5ca), X(0x32f8cb07), X(0x7569ca99), + X(0x3326e2c3), X(0x7555bd4c), X(0x3354f29b), X(0x75419de7), + X(0x3382fa88), X(0x752d6c6c), X(0x33b0fa84), X(0x751928e0), + X(0x33def287), X(0x7504d345), X(0x340ce28b), X(0x74f06b9e), + X(0x343aca87), X(0x74dbf1ef), X(0x3468aa76), X(0x74c7663a), + X(0x34968250), X(0x74b2c884), X(0x34c4520d), X(0x749e18cd), + X(0x34f219a8), X(0x7489571c), X(0x351fd918), X(0x74748371), + X(0x354d9057), X(0x745f9dd1), X(0x357b3f5d), X(0x744aa63f), + X(0x35a8e625), X(0x74359cbd), X(0x35d684a6), X(0x74208150), + X(0x36041ad9), X(0x740b53fb), X(0x3631a8b8), X(0x73f614c0), + X(0x365f2e3b), X(0x73e0c3a3), X(0x368cab5c), X(0x73cb60a8), + X(0x36ba2014), X(0x73b5ebd1), X(0x36e78c5b), X(0x73a06522), + X(0x3714f02a), X(0x738acc9e), X(0x37424b7b), X(0x73752249), + X(0x376f9e46), X(0x735f6626), X(0x379ce885), X(0x73499838), + X(0x37ca2a30), X(0x7333b883), X(0x37f76341), X(0x731dc70a), + X(0x382493b0), X(0x7307c3d0), X(0x3851bb77), X(0x72f1aed9), + X(0x387eda8e), X(0x72db8828), X(0x38abf0ef), X(0x72c54fc1), + X(0x38d8fe93), X(0x72af05a7), X(0x39060373), X(0x7298a9dd), + X(0x3932ff87), X(0x72823c67), X(0x395ff2c9), X(0x726bbd48), + X(0x398cdd32), X(0x72552c85), X(0x39b9bebc), X(0x723e8a20), + X(0x39e6975e), X(0x7227d61c), X(0x3a136712), X(0x7211107e), + X(0x3a402dd2), X(0x71fa3949), X(0x3a6ceb96), X(0x71e35080), + X(0x3a99a057), X(0x71cc5626), X(0x3ac64c0f), X(0x71b54a41), + X(0x3af2eeb7), X(0x719e2cd2), X(0x3b1f8848), X(0x7186fdde), + X(0x3b4c18ba), X(0x716fbd68), X(0x3b78a007), X(0x71586b74), + X(0x3ba51e29), X(0x71410805), X(0x3bd19318), X(0x7129931f), + X(0x3bfdfecd), X(0x71120cc5), X(0x3c2a6142), X(0x70fa74fc), + X(0x3c56ba70), X(0x70e2cbc6), X(0x3c830a50), X(0x70cb1128), + X(0x3caf50da), X(0x70b34525), X(0x3cdb8e09), X(0x709b67c0), + X(0x3d07c1d6), X(0x708378ff), X(0x3d33ec39), X(0x706b78e3), + X(0x3d600d2c), X(0x70536771), X(0x3d8c24a8), X(0x703b44ad), + X(0x3db832a6), X(0x7023109a), X(0x3de4371f), X(0x700acb3c), + X(0x3e10320d), X(0x6ff27497), X(0x3e3c2369), X(0x6fda0cae), + X(0x3e680b2c), X(0x6fc19385), X(0x3e93e950), X(0x6fa90921), + X(0x3ebfbdcd), X(0x6f906d84), X(0x3eeb889c), X(0x6f77c0b3), + X(0x3f1749b8), X(0x6f5f02b2), X(0x3f430119), X(0x6f463383), + X(0x3f6eaeb8), X(0x6f2d532c), X(0x3f9a5290), X(0x6f1461b0), + X(0x3fc5ec98), X(0x6efb5f12), X(0x3ff17cca), X(0x6ee24b57), + X(0x401d0321), X(0x6ec92683), X(0x40487f94), X(0x6eaff099), + X(0x4073f21d), X(0x6e96a99d), X(0x409f5ab6), X(0x6e7d5193), + X(0x40cab958), X(0x6e63e87f), X(0x40f60dfb), X(0x6e4a6e66), + X(0x4121589b), X(0x6e30e34a), X(0x414c992f), X(0x6e174730), + X(0x4177cfb1), X(0x6dfd9a1c), X(0x41a2fc1a), X(0x6de3dc11), + X(0x41ce1e65), X(0x6dca0d14), X(0x41f93689), X(0x6db02d29), + X(0x42244481), X(0x6d963c54), X(0x424f4845), X(0x6d7c3a98), + X(0x427a41d0), X(0x6d6227fa), X(0x42a5311b), X(0x6d48047e), + X(0x42d0161e), X(0x6d2dd027), X(0x42faf0d4), X(0x6d138afb), + X(0x4325c135), X(0x6cf934fc), X(0x4350873c), X(0x6cdece2f), + X(0x437b42e1), X(0x6cc45698), X(0x43a5f41e), X(0x6ca9ce3b), + X(0x43d09aed), X(0x6c8f351c), X(0x43fb3746), X(0x6c748b3f), + X(0x4425c923), X(0x6c59d0a9), X(0x4450507e), X(0x6c3f055d), + X(0x447acd50), X(0x6c242960), X(0x44a53f93), X(0x6c093cb6), + X(0x44cfa740), X(0x6bee3f62), X(0x44fa0450), X(0x6bd3316a), + X(0x452456bd), X(0x6bb812d1), X(0x454e9e80), X(0x6b9ce39b), + X(0x4578db93), X(0x6b81a3cd), X(0x45a30df0), X(0x6b66536b), + X(0x45cd358f), X(0x6b4af279), X(0x45f7526b), X(0x6b2f80fb), + X(0x4621647d), X(0x6b13fef5), X(0x464b6bbe), X(0x6af86c6c), + X(0x46756828), X(0x6adcc964), X(0x469f59b4), X(0x6ac115e2), + X(0x46c9405c), X(0x6aa551e9), X(0x46f31c1a), X(0x6a897d7d), + X(0x471cece7), X(0x6a6d98a4), X(0x4746b2bc), X(0x6a51a361), + X(0x47706d93), X(0x6a359db9), X(0x479a1d67), X(0x6a1987b0), + X(0x47c3c22f), X(0x69fd614a), X(0x47ed5be6), X(0x69e12a8c), + X(0x4816ea86), X(0x69c4e37a), X(0x48406e08), X(0x69a88c19), + X(0x4869e665), X(0x698c246c), X(0x48935397), X(0x696fac78), + X(0x48bcb599), X(0x69532442), X(0x48e60c62), X(0x69368bce), + X(0x490f57ee), X(0x6919e320), X(0x49389836), X(0x68fd2a3d), + X(0x4961cd33), X(0x68e06129), X(0x498af6df), X(0x68c387e9), + X(0x49b41533), X(0x68a69e81), X(0x49dd282a), X(0x6889a4f6), + X(0x4a062fbd), X(0x686c9b4b), X(0x4a2f2be6), X(0x684f8186), + X(0x4a581c9e), X(0x683257ab), X(0x4a8101de), X(0x68151dbe), + X(0x4aa9dba2), X(0x67f7d3c5), X(0x4ad2a9e2), X(0x67da79c3), + X(0x4afb6c98), X(0x67bd0fbd), X(0x4b2423be), X(0x679f95b7), + X(0x4b4ccf4d), X(0x67820bb7), X(0x4b756f40), X(0x676471c0), + X(0x4b9e0390), X(0x6746c7d8), X(0x4bc68c36), X(0x67290e02), + X(0x4bef092d), X(0x670b4444), X(0x4c177a6e), X(0x66ed6aa1), + X(0x4c3fdff4), X(0x66cf8120), X(0x4c6839b7), X(0x66b187c3), + X(0x4c9087b1), X(0x66937e91), X(0x4cb8c9dd), X(0x6675658c), + X(0x4ce10034), X(0x66573cbb), X(0x4d092ab0), X(0x66390422), + X(0x4d31494b), X(0x661abbc5), X(0x4d595bfe), X(0x65fc63a9), + X(0x4d8162c4), X(0x65ddfbd3), X(0x4da95d96), X(0x65bf8447), + X(0x4dd14c6e), X(0x65a0fd0b), X(0x4df92f46), X(0x65826622), + X(0x4e210617), X(0x6563bf92), X(0x4e48d0dd), X(0x6545095f), + X(0x4e708f8f), X(0x6526438f), X(0x4e984229), X(0x65076e25), + X(0x4ebfe8a5), X(0x64e88926), X(0x4ee782fb), X(0x64c99498), + X(0x4f0f1126), X(0x64aa907f), X(0x4f369320), X(0x648b7ce0), + X(0x4f5e08e3), X(0x646c59bf), X(0x4f857269), X(0x644d2722), + X(0x4faccfab), X(0x642de50d), X(0x4fd420a4), X(0x640e9386), + X(0x4ffb654d), X(0x63ef3290), X(0x50229da1), X(0x63cfc231), + X(0x5049c999), X(0x63b0426d), X(0x5070e92f), X(0x6390b34a), + X(0x5097fc5e), X(0x637114cc), X(0x50bf031f), X(0x635166f9), + X(0x50e5fd6d), X(0x6331a9d4), X(0x510ceb40), X(0x6311dd64), + X(0x5133cc94), X(0x62f201ac), X(0x515aa162), X(0x62d216b3), + X(0x518169a5), X(0x62b21c7b), X(0x51a82555), X(0x6292130c), + X(0x51ced46e), X(0x6271fa69), X(0x51f576ea), X(0x6251d298), + X(0x521c0cc2), X(0x62319b9d), X(0x524295f0), X(0x6211557e), + X(0x5269126e), X(0x61f1003f), X(0x528f8238), X(0x61d09be5), + X(0x52b5e546), X(0x61b02876), X(0x52dc3b92), X(0x618fa5f7), + X(0x53028518), X(0x616f146c), X(0x5328c1d0), X(0x614e73da), + X(0x534ef1b5), X(0x612dc447), X(0x537514c2), X(0x610d05b7), + X(0x539b2af0), X(0x60ec3830), X(0x53c13439), X(0x60cb5bb7), + X(0x53e73097), X(0x60aa7050), X(0x540d2005), X(0x60897601), + X(0x5433027d), X(0x60686ccf), X(0x5458d7f9), X(0x604754bf), + X(0x547ea073), X(0x60262dd6), X(0x54a45be6), X(0x6004f819), + X(0x54ca0a4b), X(0x5fe3b38d), X(0x54efab9c), X(0x5fc26038), + X(0x55153fd4), X(0x5fa0fe1f), X(0x553ac6ee), X(0x5f7f8d46), + X(0x556040e2), X(0x5f5e0db3), X(0x5585adad), X(0x5f3c7f6b), + X(0x55ab0d46), X(0x5f1ae274), X(0x55d05faa), X(0x5ef936d1), + X(0x55f5a4d2), X(0x5ed77c8a), X(0x561adcb9), X(0x5eb5b3a2), + X(0x56400758), X(0x5e93dc1f), X(0x566524aa), X(0x5e71f606), + X(0x568a34a9), X(0x5e50015d), X(0x56af3750), X(0x5e2dfe29), + X(0x56d42c99), X(0x5e0bec6e), X(0x56f9147e), X(0x5de9cc33), + X(0x571deefa), X(0x5dc79d7c), X(0x5742bc06), X(0x5da5604f), + X(0x57677b9d), X(0x5d8314b1), X(0x578c2dba), X(0x5d60baa7), + X(0x57b0d256), X(0x5d3e5237), X(0x57d5696d), X(0x5d1bdb65), + X(0x57f9f2f8), X(0x5cf95638), X(0x581e6ef1), X(0x5cd6c2b5), + X(0x5842dd54), X(0x5cb420e0), X(0x58673e1b), X(0x5c9170bf), + X(0x588b9140), X(0x5c6eb258), X(0x58afd6bd), X(0x5c4be5b0), + X(0x58d40e8c), X(0x5c290acc), X(0x58f838a9), X(0x5c0621b2), + X(0x591c550e), X(0x5be32a67), X(0x594063b5), X(0x5bc024f0), + X(0x59646498), X(0x5b9d1154), X(0x598857b2), X(0x5b79ef96), + X(0x59ac3cfd), X(0x5b56bfbd), X(0x59d01475), X(0x5b3381ce), + X(0x59f3de12), X(0x5b1035cf), X(0x5a1799d1), X(0x5aecdbc5), + X(0x5a3b47ab), X(0x5ac973b5), X(0x5a5ee79a), X(0x5aa5fda5), + X(0x5a82799a), X(0x5a82799a) + }; + + /* {sin((2*i+1)*PI/4096), cos((2*i+1)*PI/4096)}, with i = 0 to 511 */ +LOOKUP_T sincos_lookup1[1024] = { + X(0x001921fb), X(0x7ffffd88), X(0x004b65ee), X(0x7fffe9cb), + X(0x007da9d4), X(0x7fffc251), X(0x00afeda8), X(0x7fff8719), + X(0x00e23160), X(0x7fff3824), X(0x011474f6), X(0x7ffed572), + X(0x0146b860), X(0x7ffe5f03), X(0x0178fb99), X(0x7ffdd4d7), + X(0x01ab3e97), X(0x7ffd36ee), X(0x01dd8154), X(0x7ffc8549), + X(0x020fc3c6), X(0x7ffbbfe6), X(0x024205e8), X(0x7ffae6c7), + X(0x027447b0), X(0x7ff9f9ec), X(0x02a68917), X(0x7ff8f954), + X(0x02d8ca16), X(0x7ff7e500), X(0x030b0aa4), X(0x7ff6bcf0), + X(0x033d4abb), X(0x7ff58125), X(0x036f8a51), X(0x7ff4319d), + X(0x03a1c960), X(0x7ff2ce5b), X(0x03d407df), X(0x7ff1575d), + X(0x040645c7), X(0x7fefcca4), X(0x04388310), X(0x7fee2e30), + X(0x046abfb3), X(0x7fec7c02), X(0x049cfba7), X(0x7feab61a), + X(0x04cf36e5), X(0x7fe8dc78), X(0x05017165), X(0x7fe6ef1c), + X(0x0533ab20), X(0x7fe4ee06), X(0x0565e40d), X(0x7fe2d938), + X(0x05981c26), X(0x7fe0b0b1), X(0x05ca5361), X(0x7fde7471), + X(0x05fc89b8), X(0x7fdc247a), X(0x062ebf22), X(0x7fd9c0ca), + X(0x0660f398), X(0x7fd74964), X(0x06932713), X(0x7fd4be46), + X(0x06c5598a), X(0x7fd21f72), X(0x06f78af6), X(0x7fcf6ce8), + X(0x0729bb4e), X(0x7fcca6a7), X(0x075bea8c), X(0x7fc9ccb2), + X(0x078e18a7), X(0x7fc6df08), X(0x07c04598), X(0x7fc3dda9), + X(0x07f27157), X(0x7fc0c896), X(0x08249bdd), X(0x7fbd9fd0), + X(0x0856c520), X(0x7fba6357), X(0x0888ed1b), X(0x7fb7132b), + X(0x08bb13c5), X(0x7fb3af4e), X(0x08ed3916), X(0x7fb037bf), + X(0x091f5d06), X(0x7facac7f), X(0x09517f8f), X(0x7fa90d8e), + X(0x0983a0a7), X(0x7fa55aee), X(0x09b5c048), X(0x7fa1949e), + X(0x09e7de6a), X(0x7f9dbaa0), X(0x0a19fb04), X(0x7f99ccf4), + X(0x0a4c1610), X(0x7f95cb9a), X(0x0a7e2f85), X(0x7f91b694), + X(0x0ab0475c), X(0x7f8d8de1), X(0x0ae25d8d), X(0x7f895182), + X(0x0b147211), X(0x7f850179), X(0x0b4684df), X(0x7f809dc5), + X(0x0b7895f0), X(0x7f7c2668), X(0x0baaa53b), X(0x7f779b62), + X(0x0bdcb2bb), X(0x7f72fcb4), X(0x0c0ebe66), X(0x7f6e4a5e), + X(0x0c40c835), X(0x7f698461), X(0x0c72d020), X(0x7f64aabf), + X(0x0ca4d620), X(0x7f5fbd77), X(0x0cd6da2d), X(0x7f5abc8a), + X(0x0d08dc3f), X(0x7f55a7fa), X(0x0d3adc4e), X(0x7f507fc7), + X(0x0d6cda53), X(0x7f4b43f2), X(0x0d9ed646), X(0x7f45f47b), + X(0x0dd0d01f), X(0x7f409164), X(0x0e02c7d7), X(0x7f3b1aad), + X(0x0e34bd66), X(0x7f359057), X(0x0e66b0c3), X(0x7f2ff263), + X(0x0e98a1e9), X(0x7f2a40d2), X(0x0eca90ce), X(0x7f247ba5), + X(0x0efc7d6b), X(0x7f1ea2dc), X(0x0f2e67b8), X(0x7f18b679), + X(0x0f604faf), X(0x7f12b67c), X(0x0f923546), X(0x7f0ca2e7), + X(0x0fc41876), X(0x7f067bba), X(0x0ff5f938), X(0x7f0040f6), + X(0x1027d784), X(0x7ef9f29d), X(0x1059b352), X(0x7ef390ae), + X(0x108b8c9b), X(0x7eed1b2c), X(0x10bd6356), X(0x7ee69217), + X(0x10ef377d), X(0x7edff570), X(0x11210907), X(0x7ed94538), + X(0x1152d7ed), X(0x7ed28171), X(0x1184a427), X(0x7ecbaa1a), + X(0x11b66dad), X(0x7ec4bf36), X(0x11e83478), X(0x7ebdc0c6), + X(0x1219f880), X(0x7eb6aeca), X(0x124bb9be), X(0x7eaf8943), + X(0x127d7829), X(0x7ea85033), X(0x12af33ba), X(0x7ea1039b), + X(0x12e0ec6a), X(0x7e99a37c), X(0x1312a230), X(0x7e922fd6), + X(0x13445505), X(0x7e8aa8ac), X(0x137604e2), X(0x7e830dff), + X(0x13a7b1bf), X(0x7e7b5fce), X(0x13d95b93), X(0x7e739e1d), + X(0x140b0258), X(0x7e6bc8eb), X(0x143ca605), X(0x7e63e03b), + X(0x146e4694), X(0x7e5be40c), X(0x149fe3fc), X(0x7e53d462), + X(0x14d17e36), X(0x7e4bb13c), X(0x1503153a), X(0x7e437a9c), + X(0x1534a901), X(0x7e3b3083), X(0x15663982), X(0x7e32d2f4), + X(0x1597c6b7), X(0x7e2a61ed), X(0x15c95097), X(0x7e21dd73), + X(0x15fad71b), X(0x7e194584), X(0x162c5a3b), X(0x7e109a24), + X(0x165dd9f0), X(0x7e07db52), X(0x168f5632), X(0x7dff0911), + X(0x16c0cef9), X(0x7df62362), X(0x16f2443e), X(0x7ded2a47), + X(0x1723b5f9), X(0x7de41dc0), X(0x17552422), X(0x7ddafdce), + X(0x17868eb3), X(0x7dd1ca75), X(0x17b7f5a3), X(0x7dc883b4), + X(0x17e958ea), X(0x7dbf298d), X(0x181ab881), X(0x7db5bc02), + X(0x184c1461), X(0x7dac3b15), X(0x187d6c82), X(0x7da2a6c6), + X(0x18aec0db), X(0x7d98ff17), X(0x18e01167), X(0x7d8f4409), + X(0x19115e1c), X(0x7d85759f), X(0x1942a6f3), X(0x7d7b93da), + X(0x1973ebe6), X(0x7d719eba), X(0x19a52ceb), X(0x7d679642), + X(0x19d669fc), X(0x7d5d7a74), X(0x1a07a311), X(0x7d534b50), + X(0x1a38d823), X(0x7d4908d9), X(0x1a6a0929), X(0x7d3eb30f), + X(0x1a9b361d), X(0x7d3449f5), X(0x1acc5ef6), X(0x7d29cd8c), + X(0x1afd83ad), X(0x7d1f3dd6), X(0x1b2ea43a), X(0x7d149ad5), + X(0x1b5fc097), X(0x7d09e489), X(0x1b90d8bb), X(0x7cff1af5), + X(0x1bc1ec9e), X(0x7cf43e1a), X(0x1bf2fc3a), X(0x7ce94dfb), + X(0x1c240786), X(0x7cde4a98), X(0x1c550e7c), X(0x7cd333f3), + X(0x1c861113), X(0x7cc80a0f), X(0x1cb70f43), X(0x7cbcccec), + X(0x1ce80906), X(0x7cb17c8d), X(0x1d18fe54), X(0x7ca618f3), + X(0x1d49ef26), X(0x7c9aa221), X(0x1d7adb73), X(0x7c8f1817), + X(0x1dabc334), X(0x7c837ad8), X(0x1ddca662), X(0x7c77ca65), + X(0x1e0d84f5), X(0x7c6c06c0), X(0x1e3e5ee5), X(0x7c602fec), + X(0x1e6f342c), X(0x7c5445e9), X(0x1ea004c1), X(0x7c4848ba), + X(0x1ed0d09d), X(0x7c3c3860), X(0x1f0197b8), X(0x7c3014de), + X(0x1f325a0b), X(0x7c23de35), X(0x1f63178f), X(0x7c179467), + X(0x1f93d03c), X(0x7c0b3777), X(0x1fc4840a), X(0x7bfec765), + X(0x1ff532f2), X(0x7bf24434), X(0x2025dcec), X(0x7be5ade6), + X(0x205681f1), X(0x7bd9047c), X(0x208721f9), X(0x7bcc47fa), + X(0x20b7bcfe), X(0x7bbf7860), X(0x20e852f6), X(0x7bb295b0), + X(0x2118e3dc), X(0x7ba59fee), X(0x21496fa7), X(0x7b989719), + X(0x2179f64f), X(0x7b8b7b36), X(0x21aa77cf), X(0x7b7e4c45), + X(0x21daf41d), X(0x7b710a49), X(0x220b6b32), X(0x7b63b543), + X(0x223bdd08), X(0x7b564d36), X(0x226c4996), X(0x7b48d225), + X(0x229cb0d5), X(0x7b3b4410), X(0x22cd12bd), X(0x7b2da2fa), + X(0x22fd6f48), X(0x7b1feee5), X(0x232dc66d), X(0x7b1227d3), + X(0x235e1826), X(0x7b044dc7), X(0x238e646a), X(0x7af660c2), + X(0x23beab33), X(0x7ae860c7), X(0x23eeec78), X(0x7ada4dd8), + X(0x241f2833), X(0x7acc27f7), X(0x244f5e5c), X(0x7abdef25), + X(0x247f8eec), X(0x7aafa367), X(0x24afb9da), X(0x7aa144bc), + X(0x24dfdf20), X(0x7a92d329), X(0x250ffeb7), X(0x7a844eae), + X(0x25401896), X(0x7a75b74f), X(0x25702cb7), X(0x7a670d0d), + X(0x25a03b11), X(0x7a584feb), X(0x25d0439f), X(0x7a497feb), + X(0x26004657), X(0x7a3a9d0f), X(0x26304333), X(0x7a2ba75a), + X(0x26603a2c), X(0x7a1c9ece), X(0x26902b39), X(0x7a0d836d), + X(0x26c01655), X(0x79fe5539), X(0x26effb76), X(0x79ef1436), + X(0x271fda96), X(0x79dfc064), X(0x274fb3ae), X(0x79d059c8), + X(0x277f86b5), X(0x79c0e062), X(0x27af53a6), X(0x79b15435), + X(0x27df1a77), X(0x79a1b545), X(0x280edb23), X(0x79920392), + X(0x283e95a1), X(0x79823f20), X(0x286e49ea), X(0x797267f2), + X(0x289df7f8), X(0x79627e08), X(0x28cd9fc1), X(0x79528167), + X(0x28fd4140), X(0x79427210), X(0x292cdc6d), X(0x79325006), + X(0x295c7140), X(0x79221b4b), X(0x298bffb2), X(0x7911d3e2), + X(0x29bb87bc), X(0x790179cd), X(0x29eb0957), X(0x78f10d0f), + X(0x2a1a847b), X(0x78e08dab), X(0x2a49f920), X(0x78cffba3), + X(0x2a796740), X(0x78bf56f9), X(0x2aa8ced3), X(0x78ae9fb0), + X(0x2ad82fd2), X(0x789dd5cb), X(0x2b078a36), X(0x788cf94c), + X(0x2b36ddf7), X(0x787c0a36), X(0x2b662b0e), X(0x786b088c), + X(0x2b957173), X(0x7859f44f), X(0x2bc4b120), X(0x7848cd83), + X(0x2bf3ea0d), X(0x7837942b), X(0x2c231c33), X(0x78264849), + X(0x2c52478a), X(0x7814e9df), X(0x2c816c0c), X(0x780378f1), + X(0x2cb089b1), X(0x77f1f581), X(0x2cdfa071), X(0x77e05f91), + X(0x2d0eb046), X(0x77ceb725), X(0x2d3db928), X(0x77bcfc3f), + X(0x2d6cbb10), X(0x77ab2ee2), X(0x2d9bb5f6), X(0x77994f11), + X(0x2dcaa9d5), X(0x77875cce), X(0x2df996a3), X(0x7775581d), + X(0x2e287c5a), X(0x776340ff), X(0x2e575af3), X(0x77511778), + X(0x2e863267), X(0x773edb8b), X(0x2eb502ae), X(0x772c8d3a), + X(0x2ee3cbc1), X(0x771a2c88), X(0x2f128d99), X(0x7707b979), + X(0x2f41482e), X(0x76f5340e), X(0x2f6ffb7a), X(0x76e29c4b), + X(0x2f9ea775), X(0x76cff232), X(0x2fcd4c19), X(0x76bd35c7), + X(0x2ffbe95d), X(0x76aa670d), X(0x302a7f3a), X(0x76978605), + X(0x30590dab), X(0x768492b4), X(0x308794a6), X(0x76718d1c), + X(0x30b61426), X(0x765e7540), X(0x30e48c22), X(0x764b4b23), + X(0x3112fc95), X(0x76380ec8), X(0x31416576), X(0x7624c031), + X(0x316fc6be), X(0x76115f63), X(0x319e2067), X(0x75fdec60), + X(0x31cc7269), X(0x75ea672a), X(0x31fabcbd), X(0x75d6cfc5), + X(0x3228ff5c), X(0x75c32634), X(0x32573a3f), X(0x75af6a7b), + X(0x32856d5e), X(0x759b9c9b), X(0x32b398b3), X(0x7587bc98), + X(0x32e1bc36), X(0x7573ca75), X(0x330fd7e1), X(0x755fc635), + X(0x333debab), X(0x754bafdc), X(0x336bf78f), X(0x7537876c), + X(0x3399fb85), X(0x75234ce8), X(0x33c7f785), X(0x750f0054), + X(0x33f5eb89), X(0x74faa1b3), X(0x3423d78a), X(0x74e63108), + X(0x3451bb81), X(0x74d1ae55), X(0x347f9766), X(0x74bd199f), + X(0x34ad6b32), X(0x74a872e8), X(0x34db36df), X(0x7493ba34), + X(0x3508fa66), X(0x747eef85), X(0x3536b5be), X(0x746a12df), + X(0x356468e2), X(0x74552446), X(0x359213c9), X(0x744023bc), + X(0x35bfb66e), X(0x742b1144), X(0x35ed50c9), X(0x7415ece2), + X(0x361ae2d3), X(0x7400b69a), X(0x36486c86), X(0x73eb6e6e), + X(0x3675edd9), X(0x73d61461), X(0x36a366c6), X(0x73c0a878), + X(0x36d0d746), X(0x73ab2ab4), X(0x36fe3f52), X(0x73959b1b), + X(0x372b9ee3), X(0x737ff9ae), X(0x3758f5f2), X(0x736a4671), + X(0x37864477), X(0x73548168), X(0x37b38a6d), X(0x733eaa96), + X(0x37e0c7cc), X(0x7328c1ff), X(0x380dfc8d), X(0x7312c7a5), + X(0x383b28a9), X(0x72fcbb8c), X(0x38684c19), X(0x72e69db7), + X(0x389566d6), X(0x72d06e2b), X(0x38c278d9), X(0x72ba2cea), + X(0x38ef821c), X(0x72a3d9f7), X(0x391c8297), X(0x728d7557), + X(0x39497a43), X(0x7276ff0d), X(0x39766919), X(0x7260771b), + X(0x39a34f13), X(0x7249dd86), X(0x39d02c2a), X(0x72333251), + X(0x39fd0056), X(0x721c7580), X(0x3a29cb91), X(0x7205a716), + X(0x3a568dd4), X(0x71eec716), X(0x3a834717), X(0x71d7d585), + X(0x3aaff755), X(0x71c0d265), X(0x3adc9e86), X(0x71a9bdba), + X(0x3b093ca3), X(0x71929789), X(0x3b35d1a5), X(0x717b5fd3), + X(0x3b625d86), X(0x7164169d), X(0x3b8ee03e), X(0x714cbbeb), + X(0x3bbb59c7), X(0x71354fc0), X(0x3be7ca1a), X(0x711dd220), + X(0x3c143130), X(0x7106430e), X(0x3c408f03), X(0x70eea28e), + X(0x3c6ce38a), X(0x70d6f0a4), X(0x3c992ec0), X(0x70bf2d53), + X(0x3cc5709e), X(0x70a7589f), X(0x3cf1a91c), X(0x708f728b), + X(0x3d1dd835), X(0x70777b1c), X(0x3d49fde1), X(0x705f7255), + X(0x3d761a19), X(0x70475839), X(0x3da22cd7), X(0x702f2ccd), + X(0x3dce3614), X(0x7016f014), X(0x3dfa35c8), X(0x6ffea212), + X(0x3e262bee), X(0x6fe642ca), X(0x3e52187f), X(0x6fcdd241), + X(0x3e7dfb73), X(0x6fb5507a), X(0x3ea9d4c3), X(0x6f9cbd79), + X(0x3ed5a46b), X(0x6f841942), X(0x3f016a61), X(0x6f6b63d8), + X(0x3f2d26a0), X(0x6f529d40), X(0x3f58d921), X(0x6f39c57d), + X(0x3f8481dd), X(0x6f20dc92), X(0x3fb020ce), X(0x6f07e285), + X(0x3fdbb5ec), X(0x6eeed758), X(0x40074132), X(0x6ed5bb10), + X(0x4032c297), X(0x6ebc8db0), X(0x405e3a16), X(0x6ea34f3d), + X(0x4089a7a8), X(0x6e89ffb9), X(0x40b50b46), X(0x6e709f2a), + X(0x40e064ea), X(0x6e572d93), X(0x410bb48c), X(0x6e3daaf8), + X(0x4136fa27), X(0x6e24175c), X(0x416235b2), X(0x6e0a72c5), + X(0x418d6729), X(0x6df0bd35), X(0x41b88e84), X(0x6dd6f6b1), + X(0x41e3abbc), X(0x6dbd1f3c), X(0x420ebecb), X(0x6da336dc), + X(0x4239c7aa), X(0x6d893d93), X(0x4264c653), X(0x6d6f3365), + X(0x428fbabe), X(0x6d551858), X(0x42baa4e6), X(0x6d3aec6e), + X(0x42e584c3), X(0x6d20afac), X(0x43105a50), X(0x6d066215), + X(0x433b2585), X(0x6cec03af), X(0x4365e65b), X(0x6cd1947c), + X(0x43909ccd), X(0x6cb71482), X(0x43bb48d4), X(0x6c9c83c3), + X(0x43e5ea68), X(0x6c81e245), X(0x44108184), X(0x6c67300b), + X(0x443b0e21), X(0x6c4c6d1a), X(0x44659039), X(0x6c319975), + X(0x449007c4), X(0x6c16b521), X(0x44ba74bd), X(0x6bfbc021), + X(0x44e4d71c), X(0x6be0ba7b), X(0x450f2edb), X(0x6bc5a431), + X(0x45397bf4), X(0x6baa7d49), X(0x4563be60), X(0x6b8f45c7), + X(0x458df619), X(0x6b73fdae), X(0x45b82318), X(0x6b58a503), + X(0x45e24556), X(0x6b3d3bcb), X(0x460c5cce), X(0x6b21c208), + X(0x46366978), X(0x6b0637c1), X(0x46606b4e), X(0x6aea9cf8), + X(0x468a624a), X(0x6acef1b2), X(0x46b44e65), X(0x6ab335f4), + X(0x46de2f99), X(0x6a9769c1), X(0x470805df), X(0x6a7b8d1e), + X(0x4731d131), X(0x6a5fa010), X(0x475b9188), X(0x6a43a29a), + X(0x478546de), X(0x6a2794c1), X(0x47aef12c), X(0x6a0b7689), + X(0x47d8906d), X(0x69ef47f6), X(0x48022499), X(0x69d3090e), + X(0x482badab), X(0x69b6b9d3), X(0x48552b9b), X(0x699a5a4c), + X(0x487e9e64), X(0x697dea7b), X(0x48a805ff), X(0x69616a65), + X(0x48d16265), X(0x6944da10), X(0x48fab391), X(0x6928397e), + X(0x4923f97b), X(0x690b88b5), X(0x494d341e), X(0x68eec7b9), + X(0x49766373), X(0x68d1f68f), X(0x499f8774), X(0x68b5153a), + X(0x49c8a01b), X(0x689823bf), X(0x49f1ad61), X(0x687b2224), + X(0x4a1aaf3f), X(0x685e106c), X(0x4a43a5b0), X(0x6840ee9b), + X(0x4a6c90ad), X(0x6823bcb7), X(0x4a957030), X(0x68067ac3), + X(0x4abe4433), X(0x67e928c5), X(0x4ae70caf), X(0x67cbc6c0), + X(0x4b0fc99d), X(0x67ae54ba), X(0x4b387af9), X(0x6790d2b6), + X(0x4b6120bb), X(0x677340ba), X(0x4b89badd), X(0x67559eca), + X(0x4bb24958), X(0x6737ecea), X(0x4bdacc28), X(0x671a2b20), + X(0x4c034345), X(0x66fc596f), X(0x4c2baea9), X(0x66de77dc), + X(0x4c540e4e), X(0x66c0866d), X(0x4c7c622d), X(0x66a28524), + X(0x4ca4aa41), X(0x66847408), X(0x4ccce684), X(0x6666531d), + X(0x4cf516ee), X(0x66482267), X(0x4d1d3b7a), X(0x6629e1ec), + X(0x4d455422), X(0x660b91af), X(0x4d6d60df), X(0x65ed31b5), + X(0x4d9561ac), X(0x65cec204), X(0x4dbd5682), X(0x65b0429f), + X(0x4de53f5a), X(0x6591b38c), X(0x4e0d1c30), X(0x657314cf), + X(0x4e34ecfc), X(0x6554666d), X(0x4e5cb1b9), X(0x6535a86b), + X(0x4e846a60), X(0x6516dacd), X(0x4eac16eb), X(0x64f7fd98), + X(0x4ed3b755), X(0x64d910d1), X(0x4efb4b96), X(0x64ba147d), + X(0x4f22d3aa), X(0x649b08a0), X(0x4f4a4f89), X(0x647bed3f), + X(0x4f71bf2e), X(0x645cc260), X(0x4f992293), X(0x643d8806), + X(0x4fc079b1), X(0x641e3e38), X(0x4fe7c483), X(0x63fee4f8), + X(0x500f0302), X(0x63df7c4d), X(0x50363529), X(0x63c0043b), + X(0x505d5af1), X(0x63a07cc7), X(0x50847454), X(0x6380e5f6), + X(0x50ab814d), X(0x63613fcd), X(0x50d281d5), X(0x63418a50), + X(0x50f975e6), X(0x6321c585), X(0x51205d7b), X(0x6301f171), + X(0x5147388c), X(0x62e20e17), X(0x516e0715), X(0x62c21b7e), + X(0x5194c910), X(0x62a219aa), X(0x51bb7e75), X(0x628208a1), + X(0x51e22740), X(0x6261e866), X(0x5208c36a), X(0x6241b8ff), + X(0x522f52ee), X(0x62217a72), X(0x5255d5c5), X(0x62012cc2), + X(0x527c4bea), X(0x61e0cff5), X(0x52a2b556), X(0x61c06410), + X(0x52c91204), X(0x619fe918), X(0x52ef61ee), X(0x617f5f12), + X(0x5315a50e), X(0x615ec603), X(0x533bdb5d), X(0x613e1df0), + X(0x536204d7), X(0x611d66de), X(0x53882175), X(0x60fca0d2), + X(0x53ae3131), X(0x60dbcbd1), X(0x53d43406), X(0x60bae7e1), + X(0x53fa29ed), X(0x6099f505), X(0x542012e1), X(0x6078f344), + X(0x5445eedb), X(0x6057e2a2), X(0x546bbdd7), X(0x6036c325), + X(0x54917fce), X(0x601594d1), X(0x54b734ba), X(0x5ff457ad), + X(0x54dcdc96), X(0x5fd30bbc), X(0x5502775c), X(0x5fb1b104), + X(0x55280505), X(0x5f90478a), X(0x554d858d), X(0x5f6ecf53), + X(0x5572f8ed), X(0x5f4d4865), X(0x55985f20), X(0x5f2bb2c5), + X(0x55bdb81f), X(0x5f0a0e77), X(0x55e303e6), X(0x5ee85b82), + X(0x5608426e), X(0x5ec699e9), X(0x562d73b2), X(0x5ea4c9b3), + X(0x565297ab), X(0x5e82eae5), X(0x5677ae54), X(0x5e60fd84), + X(0x569cb7a8), X(0x5e3f0194), X(0x56c1b3a1), X(0x5e1cf71c), + X(0x56e6a239), X(0x5dfade20), X(0x570b8369), X(0x5dd8b6a7), + X(0x5730572e), X(0x5db680b4), X(0x57551d80), X(0x5d943c4e), + X(0x5779d65b), X(0x5d71e979), X(0x579e81b8), X(0x5d4f883b), + X(0x57c31f92), X(0x5d2d189a), X(0x57e7afe4), X(0x5d0a9a9a), + X(0x580c32a7), X(0x5ce80e41), X(0x5830a7d6), X(0x5cc57394), + X(0x58550f6c), X(0x5ca2ca99), X(0x58796962), X(0x5c801354), + X(0x589db5b3), X(0x5c5d4dcc), X(0x58c1f45b), X(0x5c3a7a05), + X(0x58e62552), X(0x5c179806), X(0x590a4893), X(0x5bf4a7d2), + X(0x592e5e19), X(0x5bd1a971), X(0x595265df), X(0x5bae9ce7), + X(0x59765fde), X(0x5b8b8239), X(0x599a4c12), X(0x5b68596d), + X(0x59be2a74), X(0x5b452288), X(0x59e1faff), X(0x5b21dd90), + X(0x5a05bdae), X(0x5afe8a8b), X(0x5a29727b), X(0x5adb297d), + X(0x5a4d1960), X(0x5ab7ba6c), X(0x5a70b258), X(0x5a943d5e), +}; diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/misc.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/misc.c new file mode 100644 index 0000000..164250b --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/misc.c @@ -0,0 +1,229 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************/ + +#define HEAD_ALIGN 64 +#include +#include +#include +#define MISC_C +#include "misc.h" +//#include + +static void **pointers=NULL; +static long *insertlist=NULL; /* We can't embed this in the pointer list; + a pointer can have any value... */ + +static char **files=NULL; +static long *file_bytes=NULL; +static int filecount=0; + +static int ptop=0; +static int palloced=0; +static int pinsert=0; + +typedef struct { + char *file; + long line; + long ptr; + long bytes; +} head; + +long global_bytes=0; +long start_time=-1; + +static void *_insert(void *ptr,long bytes,char *file,long line){ + ((head *)ptr)->file=file; + ((head *)ptr)->line=line; + ((head *)ptr)->ptr=pinsert; + ((head *)ptr)->bytes=bytes-HEAD_ALIGN; + + if(pinsert>=palloced){ + palloced+=64; + if(pointers){ + pointers=(void **)realloc(pointers,sizeof(void **)*palloced); + insertlist=(long *)realloc(insertlist,sizeof(long *)*palloced); + }else{ + pointers=(void **)malloc(sizeof(void **)*palloced); + insertlist=(long *)malloc(sizeof(long *)*palloced); + } + } + + pointers[pinsert]=ptr; + + if(pinsert==ptop) + pinsert=++ptop; + else + pinsert=insertlist[pinsert]; + +#ifdef _VDBG_GRAPHFILE + { + FILE *out; + struct timeval tv; + static struct timezone tz; + int i; + char buffer[80]; + gettimeofday(&tv,&tz); + + for(i=0;ifile; + long bytes =((head *)ptr)->bytes; + int i; + + gettimeofday(&tv,&tz); + fprintf(out,"%ld, %ld\n",-start_time+(tv.tv_sec*1000)+(tv.tv_usec/1000), + global_bytes); + fprintf(out,"%ld, %ld\n",-start_time+(tv.tv_sec*1000)+(tv.tv_usec/1000), + global_bytes-((head *)ptr)->bytes); + fclose(out); + + for(i=0;ibytes; + + insert=((head *)ptr)->ptr; + insertlist[insert]=pinsert; + pinsert=insert; + + if(pointers[insert]==NULL){ + fprintf(stderr,"DEBUGGING MALLOC ERROR: freeing previously freed memory\n"); + fprintf(stderr,"\t%s %ld\n",((head *)ptr)->file,((head *)ptr)->line); + } + + if(global_bytes<0){ + fprintf(stderr,"DEBUGGING MALLOC ERROR: freeing unmalloced memory\n"); + } + + pointers[insert]=NULL; +} + +void _VDBG_dump(void){ + int i; + for(i=0;ifile,ptr->line); + } + +} + +extern void *_VDBG_malloc(void *ptr,long bytes,char *file,long line){ + bytes+=HEAD_ALIGN; + if(ptr){ + ptr=(void *)(((char *)ptr)-HEAD_ALIGN); + _ripremove(ptr); + ptr=realloc(ptr,bytes); + }else{ + ptr=malloc(bytes); + memset(ptr,0,bytes); + } + return _insert(ptr,bytes,file,line); +} + +extern void _VDBG_free(void *ptr){ + if(ptr){ + ptr=(void *)(((char *)ptr)-HEAD_ALIGN); + _ripremove(ptr); + free(ptr); + } +} + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/misc.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/misc.h new file mode 100644 index 0000000..b75a6d8 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/misc.h @@ -0,0 +1,213 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: miscellaneous math and prototypes + + ************************************************************************/ + +#ifndef _V_RANDOM_H_ +#define _V_RANDOM_H_ +#include "ivorbiscodec.h" +#include "os_types.h" + +/*#define _VDBG_GRAPHFILE "_0.m"*/ + + +#ifdef _VDBG_GRAPHFILE +extern void *_VDBG_malloc(void *ptr,long bytes,char *file,long line); +extern void _VDBG_free(void *ptr); + +#undef _ogg_malloc +#undef _ogg_calloc +#undef _ogg_realloc +#undef _ogg_free + +#define _ogg_malloc(x) _VDBG_malloc(NULL,(x),__FILE__,__LINE__) +#define _ogg_calloc(x,y) _VDBG_malloc(NULL,(x)*(y),__FILE__,__LINE__) +#define _ogg_realloc(x,y) _VDBG_malloc((x),(y),__FILE__,__LINE__) +#define _ogg_free(x) _VDBG_free((x)) +#endif + +#include "asm_arm.h" + +#ifndef _V_WIDE_MATH +#define _V_WIDE_MATH + +#ifndef _LOW_ACCURACY_ +/* 64 bit multiply */ + +#include +#include + +#if BYTE_ORDER==LITTLE_ENDIAN +union magic { + struct { + ogg_int32_t lo; + ogg_int32_t hi; + } halves; + ogg_int64_t whole; +}; +#endif + +#if BYTE_ORDER==BIG_ENDIAN +union magic { + struct { + ogg_int32_t hi; + ogg_int32_t lo; + } halves; + ogg_int64_t whole; +}; +#endif + +static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { + union magic magic; + magic.whole = (ogg_int64_t)x * y; + return magic.halves.hi; +} + +static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { + return MULT32(x,y)<<1; +} + +static inline ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { + union magic magic; + magic.whole = (ogg_int64_t)x * y; + return ((ogg_uint32_t)(magic.halves.lo)>>15) | ((magic.halves.hi)<<17); +} + +#else +/* 32 bit multiply, more portable but less accurate */ + +/* + * Note: Precision is biased towards the first argument therefore ordering + * is important. Shift values were chosen for the best sound quality after + * many listening tests. + */ + +/* + * For MULT32 and MULT31: The second argument is always a lookup table + * value already preshifted from 31 to 8 bits. We therefore take the + * opportunity to save on text space and use unsigned char for those + * tables in this case. + */ + +static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { + return (x >> 9) * y; /* y preshifted >>23 */ +} + +static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { + return (x >> 8) * y; /* y preshifted >>23 */ +} + +static inline ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { + return (x >> 6) * y; /* y preshifted >>9 */ +} + +#endif + +/* + * This should be used as a memory barrier, forcing all cached values in + * registers to wr writen back to memory. Might or might not be beneficial + * depending on the architecture and compiler. + */ +#define MB() + +/* + * The XPROD functions are meant to optimize the cross products found all + * over the place in mdct.c by forcing memory operation ordering to avoid + * unnecessary register reloads as soon as memory is being written to. + * However this is only beneficial on CPUs with a sane number of general + * purpose registers which exclude the Intel x86. On Intel, better let the + * compiler actually reload registers directly from original memory by using + * macros. + */ + +#ifdef __i386__ + +#define XPROD32(_a, _b, _t, _v, _x, _y) \ + { *(_x)=MULT32(_a,_t)+MULT32(_b,_v); \ + *(_y)=MULT32(_b,_t)-MULT32(_a,_v); } +#define XPROD31(_a, _b, _t, _v, _x, _y) \ + { *(_x)=MULT31(_a,_t)+MULT31(_b,_v); \ + *(_y)=MULT31(_b,_t)-MULT31(_a,_v); } +#define XNPROD31(_a, _b, _t, _v, _x, _y) \ + { *(_x)=MULT31(_a,_t)-MULT31(_b,_v); \ + *(_y)=MULT31(_b,_t)+MULT31(_a,_v); } + +#else + +static inline void XPROD32(ogg_int32_t a, ogg_int32_t b, + ogg_int32_t t, ogg_int32_t v, + ogg_int32_t *x, ogg_int32_t *y) +{ + *x = MULT32(a, t) + MULT32(b, v); + *y = MULT32(b, t) - MULT32(a, v); +} + +static inline void XPROD31(ogg_int32_t a, ogg_int32_t b, + ogg_int32_t t, ogg_int32_t v, + ogg_int32_t *x, ogg_int32_t *y) +{ + *x = MULT31(a, t) + MULT31(b, v); + *y = MULT31(b, t) - MULT31(a, v); +} + +static inline void XNPROD31(ogg_int32_t a, ogg_int32_t b, + ogg_int32_t t, ogg_int32_t v, + ogg_int32_t *x, ogg_int32_t *y) +{ + *x = MULT31(a, t) - MULT31(b, v); + *y = MULT31(b, t) + MULT31(a, v); +} + +#endif + +#endif + +#ifndef _V_CLIP_MATH +#define _V_CLIP_MATH + +static inline ogg_int32_t CLIP_TO_15(ogg_int32_t x) { + int ret=x; + ret-= ((x<=32767)-1)&(x-32767); + ret-= ((x>=-32768)-1)&(x+32768); + return(ret); +} + +#endif + +#endif + + + + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ogg.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ogg.h new file mode 100644 index 0000000..7f35bd4 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/ogg.h @@ -0,0 +1,242 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: subsumed libogg includes + + ************************************************************************/ +#ifndef _OGG_H +#define _OGG_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "os_types.h" + +#ifndef ONLY_C +#define ARM_LITTLE_ENDIAN +#endif + +typedef struct ogg_buffer_state{ + struct ogg_buffer *unused_buffers; + struct ogg_reference *unused_references; + int outstanding; + int shutdown; +} ogg_buffer_state; + +typedef struct ogg_buffer { + unsigned char *data; + long size; + int refcount; + + union { + ogg_buffer_state *owner; + struct ogg_buffer *next; + } ptr; +} ogg_buffer; + +typedef struct ogg_reference { + ogg_buffer *buffer; + long begin; + long length; + + struct ogg_reference *next; +} ogg_reference; + +typedef struct oggpack_buffer { +#ifdef ARM_LITTLE_ENDIAN + int bitsLeftInSegment; + ogg_uint32_t *ptr; + long bitsLeftInWord; +#else + int headbit; + unsigned char *headptr; + long headend; +#endif /* ARM_LITTLE_ENDIAN */ + /* memory management */ + ogg_reference *head; + ogg_reference *tail; + + /* render the byte/bit counter API constant time */ + long count; /* doesn't count the tail */ +} oggpack_buffer; + +typedef struct oggbyte_buffer { + ogg_reference *baseref; + + ogg_reference *ref; + unsigned char *ptr; + long pos; + long end; +} oggbyte_buffer; + +typedef struct ogg_sync_state { + /* decode memory management pool */ + ogg_buffer_state *bufferpool; + + /* stream buffers */ + ogg_reference *fifo_head; + ogg_reference *fifo_tail; + long fifo_fill; + + /* stream sync management */ + int unsynced; + int headerbytes; + int bodybytes; + +} ogg_sync_state; + +typedef struct ogg_stream_state { + ogg_reference *header_head; + ogg_reference *header_tail; + ogg_reference *body_head; + ogg_reference *body_tail; + + int e_o_s; /* set when we have buffered the last + packet in the logical bitstream */ + int b_o_s; /* set after we've written the initial page + of a logical bitstream */ + long serialno; + long pageno; + ogg_int64_t packetno; /* sequence number for decode; the framing + knows where there's a hole in the data, + but we need coupling so that the codec + (which is in a seperate abstraction + layer) also knows about the gap */ + ogg_int64_t granulepos; + + int lacing_fill; + ogg_uint32_t body_fill; + + /* decode-side state data */ + int holeflag; + int spanflag; + int clearflag; + int laceptr; + ogg_uint32_t body_fill_next; + +} ogg_stream_state; + +typedef struct { + ogg_reference *packet; + long bytes; + long b_o_s; + long e_o_s; + ogg_int64_t granulepos; + ogg_int64_t packetno; /* sequence number for decode; the framing + knows where there's a hole in the data, + but we need coupling so that the codec + (which is in a seperate abstraction + layer) also knows about the gap */ +} ogg_packet; + +typedef struct { + ogg_reference *header; + int header_len; + ogg_reference *body; + long body_len; +} ogg_page; + +/* Ogg BITSTREAM PRIMITIVES: bitstream ************************/ + +extern void oggpack_readinit(oggpack_buffer *b,ogg_reference *r); +extern long oggpack_look(oggpack_buffer *b,int bits); +extern void oggpack_adv(oggpack_buffer *b,int bits); +extern long oggpack_read(oggpack_buffer *b,int bits); +extern long oggpack_bytes(oggpack_buffer *b); +extern long oggpack_bits(oggpack_buffer *b); +extern int oggpack_eop(oggpack_buffer *b); + +// Quick hack +#define oggpack_bytesleft(B) (((B)->bitsLeftInSegment+7)/8) + +/* Ogg BITSTREAM PRIMITIVES: decoding **************************/ + +extern void ogg_sync_init(ogg_sync_state *oy); +extern ogg_sync_state *ogg_sync_create(void); +extern int ogg_sync_clear(ogg_sync_state *oy); +extern int ogg_sync_destroy(ogg_sync_state *oy); +extern int ogg_sync_reset(ogg_sync_state *oy); + +extern unsigned char *ogg_sync_bufferin(ogg_sync_state *oy, long size); +extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes); +extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og); +extern int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og); +extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og); +extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op); +extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op); + +/* Ogg BITSTREAM PRIMITIVES: general ***************************/ + +extern void ogg_stream_init(ogg_stream_state *os, int serialno); +extern ogg_stream_state *ogg_stream_create(int serialno); +extern int ogg_stream_destroy(ogg_stream_state *os); +extern int ogg_stream_clear(ogg_stream_state *os); +extern int ogg_stream_reset(ogg_stream_state *os); +extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno); +extern int ogg_stream_eos(ogg_stream_state *os); + +extern int ogg_page_checksum_set(ogg_page *og); + +extern int ogg_page_version(ogg_page *og); +extern int ogg_page_continued(ogg_page *og); +extern int ogg_page_bos(ogg_page *og); +extern int ogg_page_eos(ogg_page *og); +extern ogg_int64_t ogg_page_granulepos(ogg_page *og); +extern ogg_uint32_t ogg_page_serialno(ogg_page *og); +extern ogg_uint32_t ogg_page_pageno(ogg_page *og); +extern int ogg_page_packets(ogg_page *og); +extern int ogg_page_getbuffer(ogg_page *og, unsigned char **buffer); + +extern int ogg_packet_release(ogg_packet *op); +extern int ogg_page_release(ogg_page *og); + +extern void ogg_page_dup(ogg_page *d, ogg_page *s); + +/* Ogg BITSTREAM PRIMITIVES: return codes ***************************/ + +#define OGG_SUCCESS 0 + +#define OGG_HOLE -10 +#define OGG_SPAN -11 +#define OGG_EVERSION -12 +#define OGG_ESERIAL -13 +#define OGG_EINVAL -14 +#define OGG_EEOS -15 + + +#ifdef __cplusplus +} +#endif + +#endif /* _OGG_H */ diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/os.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/os.h new file mode 100644 index 0000000..ae9edd2 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/os.h @@ -0,0 +1,82 @@ +#ifndef _OS_H +#define _OS_H +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: #ifdef jail to whip a few platforms into the UNIX ideal. + + ************************************************************************/ + +#include +#include "os_types.h" + +#ifndef _V_IFDEFJAIL_H_ +# define _V_IFDEFJAIL_H_ + +# ifdef __GNUC__ +# define STIN static __inline__ +# elif _WIN32 +# define STIN static __inline +# endif +#else +# define STIN static +#endif + +#ifndef M_PI +# define M_PI (3.1415926536f) +#endif + +#ifdef _WIN32 +# include +# define rint(x) (floor((x)+0.5f)) +# define NO_FLOAT_MATH_LIB +# define FAST_HYPOT(a, b) sqrt((a)*(a) + (b)*(b)) +#endif + +#ifdef HAVE_ALLOCA_H +# include +#endif + +#ifdef USE_MEMORY_H +# include +#endif + +#ifndef min +# define min(x,y) ((x)>(y)?(y):(x)) +#endif + +#ifndef max +# define max(x,y) ((x)<(y)?(y):(x)) +#endif + +#endif /* _OS_H */ diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/os_types.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/os_types.h new file mode 100644 index 0000000..315227c --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/os_types.h @@ -0,0 +1,124 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: #ifdef jail to whip a few platforms into the UNIX ideal. + + ************************************************************************/ +#ifndef _OS_TYPES_H +#define _OS_TYPES_H + +#ifdef _LOW_ACCURACY_ +# define X(n) (((((n)>>22)+1)>>1) - ((((n)>>22)+1)>>9)) +# define LOOKUP_T const unsigned char +#else +# define X(n) (n) +# define LOOKUP_T const ogg_int32_t +#endif + +/* make it easy on the folks that want to compile the libs with a + different malloc than stdlib */ +#define _ogg_malloc malloc +#define _ogg_calloc calloc +#define _ogg_realloc realloc +#define _ogg_free free + +#if defined (_WIN32_WCE) + + typedef unsigned short ogg_uint16_t; + typedef short ogg_int16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef __int64 ogg_int64_t; + + #define inline + +#elif defined(_WIN32) + +# ifndef __GNUC__ + /* MSVC/Borland */ + typedef __int64 ogg_int64_t; + typedef __int32 ogg_int32_t; + typedef unsigned __int32 ogg_uint32_t; + typedef __int16 ogg_int16_t; + typedef unsigned __int16 ogg_uint16_t; +# else + /* Cygwin */ + #include <_G_config.h> + typedef _G_int64_t ogg_int64_t; + typedef _G_int32_t ogg_int32_t; + typedef _G_uint32_t ogg_uint32_t; + typedef _G_int16_t ogg_int16_t; + typedef _G_uint16_t ogg_uint16_t; +# endif + +#elif defined(__MACOS__) + +# include + typedef SInt16 ogg_int16_t; + typedef UInt16 ogg_uint16_t; + typedef SInt32 ogg_int32_t; + typedef UInt32 ogg_uint32_t; + typedef SInt64 ogg_int64_t; + +#elif defined(__MACOSX__) /* MacOS X Framework build */ + +# include + typedef int16_t ogg_int16_t; + typedef u_int16_t ogg_uint16_t; + typedef int32_t ogg_int32_t; + typedef u_int32_t ogg_uint32_t; + typedef int64_t ogg_int64_t; + +#elif defined(__BEOS__) + + /* Be */ +# include + +#elif defined (__EMX__) + + /* OS/2 GCC */ + typedef short ogg_int16_t; + typedef unsigned short ogg_uint16_t; + typedef int ogg_int32_t; + typedef unsigned int ogg_uint32_t; + typedef long long ogg_int64_t; + +#else + +# include +# include "config_types.h" +# include + +#endif + +#endif /* _OS_TYPES_H */ diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/res012.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/res012.c new file mode 100644 index 0000000..ac09671 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/res012.c @@ -0,0 +1,268 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: residue backend 0, 1 and 2 implementation + + ************************************************************************/ + +#include +#include +#include +#include "ogg.h" +#include "ivorbiscodec.h" +#include "codec_internal.h" +#include "codebook.h" +#include "misc.h" +#include "os.h" + +void res_clear_info(vorbis_info_residue *info){ + if(info){ + if(info->stagemasks)_ogg_free(info->stagemasks); + if(info->stagebooks)_ogg_free(info->stagebooks); + memset(info,0,sizeof(*info)); + } +} + + +/* vorbis_info is for range checking */ +int res_unpack(vorbis_info_residue *info, + vorbis_info *vi,oggpack_buffer *opb){ + int j,k; + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + memset(info,0,sizeof(*info)); + + info->type=oggpack_read(opb,16); + if(info->type>2 || info->type<0)goto errout; + info->begin=oggpack_read(opb,24); + info->end=oggpack_read(opb,24); + info->grouping=oggpack_read(opb,24)+1; // "partition size" in spec + info->partitions=(char)(oggpack_read(opb,6)+1); // "classification" in spec + info->groupbook=(unsigned char)oggpack_read(opb,8); // "classbook" in spec + if(info->groupbook>=ci->books)goto errout; + + info->stagemasks=_ogg_malloc(info->partitions*sizeof(*info->stagemasks)); + info->stagebooks=_ogg_malloc(info->partitions*8*sizeof(*info->stagebooks)); + + for(j=0;jpartitions;j++){ + int cascade=oggpack_read(opb,3); + if(oggpack_read(opb,1)) + cascade|=(oggpack_read(opb,5)<<3); + info->stagemasks[j]=cascade; + } + + for(j=0;jpartitions;j++){ + for(k=0;k<8;k++){ + if((info->stagemasks[j]>>k)&1){ + unsigned char book=(unsigned char)oggpack_read(opb,8); + if(book>=ci->books)goto errout; + info->stagebooks[j*8+k]=book; + if(k+1>info->stages)info->stages=k+1; + }else + info->stagebooks[j*8+k]=0xff; + } + } + + if(oggpack_eop(opb))goto errout; + + // According to the Vorbis spec (paragraph 8.6.2 "packet decode"), residue + // begin and end should be limited to the maximum possible vector size in + // case they exceed it. However doing that makes the decoder crash further + // down, so we return an error instead. + int limit = (info->type == 2 ? vi->channels : 1) * ci->blocksizes[1] / 2; + if (info->begin > info->end || + info->end > limit) { + goto errout; + } + return 0; + errout: + res_clear_info(info); + return 1; +} + +int res_inverse(vorbis_dsp_state *vd,vorbis_info_residue *info, + ogg_int32_t **in,int *nonzero,int ch){ + + int i,j,k,s,used=0; + codec_setup_info *ci=(codec_setup_info *)vd->vi->codec_setup; + codebook *phrasebook=ci->book_param+info->groupbook; + int samples_per_partition=info->grouping; + int partitions_per_word=phrasebook->dim; + int pcmend=ci->blocksizes[vd->W]; + + if(info->type<2){ + int max=pcmend>>1; + int end=(info->endend:max); + int n=end-info->begin; + + if(n>0){ + int partvals=n/samples_per_partition; + int partwords=(partvals+partitions_per_word-1)/partitions_per_word; + + for(i=0;istages;s++){ + + for(i=0;i=0;k--) + partword[0][i+k]=partword[0][i+k+1]*info->partitions; + + for(j=1;j=0;k--) + partword[j][i+k]=partword[j-1][i+k]; + + for(j=0;jopb); + if(temp==-1)goto cleanup1; + + /* this can be done quickly in assembly due to the quotient + always being at most six bits */ + for(k=0;kbegin+i*samples_per_partition; + int idx = (int)partword[j][i]; + if(idx < info->partitions && info->stagemasks[idx]&(1<book_param+ + info->stagebooks[(partword[j][i]<<3)+s]; + if(info->type){ + if(vorbis_book_decodev_add(stagebook,in[j]+offset,&vd->opb, + samples_per_partition,-8)==-1) + goto cleanup1; + }else{ + if(vorbis_book_decodevs_add(stagebook,in[j]+offset,&vd->opb, + samples_per_partition,-8)==-1) + goto cleanup1; + } + } + } + } + } + cleanup1: + if(partword){ + for(j=0;j>1; + int end=(info->endend:max); + int n=end-info->begin; + + if(n>0){ + int partvals=n/samples_per_partition; + int partwords=(partvals+partitions_per_word-1)/partitions_per_word; + + char *partword= + (char *)_ogg_malloc(partwords*partitions_per_word*sizeof(*partword)); + if(partword==NULL)goto cleanup2; + int beginoff=info->begin/ch; + + for(i=0;istages;s++){ + for(i=0;i=0;k--) + partword[i+k]=partword[i+k+1]*info->partitions; + + /* fetch the partition word */ + temp=vorbis_book_decode(phrasebook,&vd->opb); + if(temp==-1)goto cleanup2; + + /* this can be done quickly in assembly due to the quotient + always being at most six bits */ + for(k=0;k= 0 && partword[i] < info->partitions && + (info->stagemasks[(int)partword[i]] & (1 << s))){ + codebook *stagebook=ci->book_param+ + info->stagebooks[(partword[i]<<3)+s]; + if(vorbis_book_decodevv_add(stagebook,in, + i*samples_per_partition+beginoff,ch, + &vd->opb, + samples_per_partition,-8)==-1) + goto cleanup2; + } + } + } + } + cleanup2: + if(partword)_ogg_free(partword); + } + } + + return 0; +} + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/treminfo.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/treminfo.c new file mode 100644 index 0000000..4f72728 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/treminfo.c @@ -0,0 +1,395 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: maintain the info structure, info <-> header packets + + ************************************************************************/ + +/* general handling of the header and the vorbis_info structure (and + substructures) */ + +#include +#include +#include +#include "ogg.h" +#include "ivorbiscodec.h" +#include "codec_internal.h" +#include "codebook.h" +#include "misc.h" +#include "os.h" + +/* helpers */ +static void _v_readstring(oggpack_buffer *o,char *buf,int bytes){ + while(bytes--){ + *buf++=(char)oggpack_read(o,8); + } +} + +void vorbis_comment_init(vorbis_comment *vc){ + memset(vc,0,sizeof(*vc)); +} + +/* This is more or less the same as strncasecmp - but that doesn't exist + * everywhere, and this is a fairly trivial function, so we include it */ +static int tagcompare(const char *s1, const char *s2, int n){ + int c=0; + while(c < n){ + if(toupper(s1[c]) != toupper(s2[c])) + return !0; + c++; + } + return 0; +} + +char *vorbis_comment_query(vorbis_comment *vc, char *tag, int count){ + long i; + int found = 0; + int taglen = strlen(tag)+1; /* +1 for the = we append */ + char *fulltag = (char *)alloca(taglen+ 1); + + strcpy(fulltag, tag); + strcat(fulltag, "="); + + for(i=0;icomments;i++){ + if(!tagcompare(vc->user_comments[i], fulltag, taglen)){ + if(count == found) + /* We return a pointer to the data, not a copy */ + return vc->user_comments[i] + taglen; + else + found++; + } + } + return NULL; /* didn't find anything */ +} + +int vorbis_comment_query_count(vorbis_comment *vc, char *tag){ + int i,count=0; + int taglen = strlen(tag)+1; /* +1 for the = we append */ + char *fulltag = (char *)alloca(taglen+1); + strcpy(fulltag,tag); + strcat(fulltag, "="); + + for(i=0;icomments;i++){ + if(!tagcompare(vc->user_comments[i], fulltag, taglen)) + count++; + } + + return count; +} + +void vorbis_comment_clear(vorbis_comment *vc){ + if(vc){ + long i; + for(i=0;icomments;i++) + if(vc->user_comments[i])_ogg_free(vc->user_comments[i]); + if(vc->user_comments)_ogg_free(vc->user_comments); + if(vc->comment_lengths)_ogg_free(vc->comment_lengths); + if(vc->vendor)_ogg_free(vc->vendor); + } + memset(vc,0,sizeof(*vc)); +} + +/* blocksize 0 is guaranteed to be short, 1 is guarantted to be long. + They may be equal, but short will never ge greater than long */ +int vorbis_info_blocksize(vorbis_info *vi,int zo){ + codec_setup_info *ci = (codec_setup_info *)vi->codec_setup; + return ci ? ci->blocksizes[zo] : -1; +} + +/* used by synthesis, which has a full, alloced vi */ +void vorbis_info_init(vorbis_info *vi){ + memset(vi,0,sizeof(*vi)); + vi->codec_setup=(codec_setup_info *)_ogg_calloc(1,sizeof(codec_setup_info)); +} + +void vorbis_info_clear(vorbis_info *vi){ + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + int i; + + if(ci){ + + if(ci->mode_param)_ogg_free(ci->mode_param); + + if(ci->map_param){ + for(i=0;imaps;i++) /* unpack does the range checking */ + mapping_clear_info(ci->map_param+i); + _ogg_free(ci->map_param); + } + + if(ci->floor_param){ + for(i=0;ifloors;i++) /* unpack does the range checking */ + if(ci->floor_type[i]) + floor1_free_info(ci->floor_param[i]); + else + floor0_free_info(ci->floor_param[i]); + _ogg_free(ci->floor_param); + _ogg_free(ci->floor_type); + } + + if(ci->residue_param){ + for(i=0;iresidues;i++) /* unpack does the range checking */ + res_clear_info(ci->residue_param+i); + _ogg_free(ci->residue_param); + } + + if(ci->book_param){ + for(i=0;ibooks;i++) + vorbis_book_clear(ci->book_param+i); + _ogg_free(ci->book_param); + } + + _ogg_free(ci); + } + + memset(vi,0,sizeof(*vi)); +} + +/* Header packing/unpacking ********************************************/ + +int _vorbis_unpack_info(vorbis_info *vi,oggpack_buffer *opb){ + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + if(!ci)return(OV_EFAULT); + + vi->version=oggpack_read(opb,32); + if(vi->version!=0)return(OV_EVERSION); + + vi->channels=oggpack_read(opb,8); + vi->rate=oggpack_read(opb,32); + + vi->bitrate_upper=oggpack_read(opb,32); + vi->bitrate_nominal=oggpack_read(opb,32); + vi->bitrate_lower=oggpack_read(opb,32); + + ci->blocksizes[0]=1<blocksizes[1]=1<rate>=64000 || ci->blocksizes[1]>4096)goto err_out; +#else + if(vi->rate<64000 && ci->blocksizes[1]>4096)goto err_out; +#endif + + if(vi->rate<1)goto err_out; + if(vi->channels<1)goto err_out; + if(ci->blocksizes[0]<64)goto err_out; + if(ci->blocksizes[1]blocksizes[0])goto err_out; + if(ci->blocksizes[1]>8192)goto err_out; + + if(oggpack_read(opb,1)!=1)goto err_out; /* EOP check */ + + return(0); + err_out: + vorbis_info_clear(vi); + return(OV_EBADHEADER); +} + +int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb){ + int i; + int vendorlen=oggpack_read(opb,32); + if(vendorlen<0)goto err_out; + vc->vendor=(char *)_ogg_calloc(vendorlen+1,1); + if(!vc->vendor)goto err_out; + _v_readstring(opb,vc->vendor,vendorlen); + vc->comments=oggpack_read(opb,32); + if(vc->comments<0)goto err_out; + vc->user_comments=(char **)_ogg_calloc(vc->comments+1,sizeof(*vc->user_comments)); + if (!vc->user_comments){ + vc->comments=0; + goto err_out; + } + vc->comment_lengths=(int *)_ogg_calloc(vc->comments+1, sizeof(*vc->comment_lengths)); + if (!vc->comment_lengths)goto err_out; + + for(i=0;icomments;i++){ + int len=oggpack_read(opb,32); + if(len<0)goto err_out; + vc->comment_lengths[i]=len; + vc->user_comments[i]=(char *)_ogg_calloc(len+1,1); + if(!vc->user_comments[i])goto err_out; + _v_readstring(opb,vc->user_comments[i],len); + } + if(oggpack_read(opb,1)!=1)goto err_out; /* EOP check */ + + return(0); + err_out: + vorbis_comment_clear(vc); + return(OV_EBADHEADER); +} + +/* all of the real encoding details are here. The modes, books, + everything */ +int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb){ + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + int i; + if(!ci)return(OV_EFAULT); + + /* codebooks */ + ci->books=oggpack_read(opb,8)+1; + ci->book_param=(codebook *)_ogg_calloc(ci->books,sizeof(*ci->book_param)); + if(!ci->book_param){ + ci->books=0; + goto err_out; + } + for(i=0;ibooks;i++) + if(vorbis_book_unpack(opb,ci->book_param+i))goto err_out; + + /* time backend settings, not actually used */ + i=oggpack_read(opb,6); + for(;i>=0;i--) + if(oggpack_read(opb,16)!=0)goto err_out; + + /* floor backend settings */ + ci->floors=oggpack_read(opb,6)+1; + ci->floor_param=_ogg_calloc(ci->floors, sizeof(*ci->floor_param)); + ci->floor_type=_ogg_calloc(ci->floors, sizeof(*ci->floor_type)); + if(!ci->floor_param || !ci->floor_type){ + ci->floors=0; + goto err_out; + } + for(i=0;ifloors;i++){ + ci->floor_type[i]=(char)oggpack_read(opb,16); + if(ci->floor_type[i]<0 || ci->floor_type[i]>=VI_FLOORB)goto err_out; + if(ci->floor_type[i]) + ci->floor_param[i]=floor1_info_unpack(vi,opb); + else + ci->floor_param[i]=floor0_info_unpack(vi,opb); + if(!ci->floor_param[i])goto err_out; + } + + /* residue backend settings */ + ci->residues=oggpack_read(opb,6)+1; + ci->residue_param=_ogg_calloc(ci->residues, sizeof(*ci->residue_param)); + if (!ci->residue_param){ + ci->residues=0; + goto err_out; + } + for(i=0;iresidues;i++) + if(res_unpack(ci->residue_param+i,vi,opb))goto err_out; + + /* map backend settings */ + ci->maps=oggpack_read(opb,6)+1; + ci->map_param=_ogg_calloc(ci->maps, sizeof(*ci->map_param)); + if (!ci->map_param){ + ci->maps=0; + goto err_out; + } + for(i=0;imaps;i++){ + if(oggpack_read(opb,16)!=0)goto err_out; + if(mapping_info_unpack(ci->map_param+i,vi,opb))goto err_out; + } + + /* mode settings */ + ci->modes=oggpack_read(opb,6)+1; + ci->mode_param= + (vorbis_info_mode *)_ogg_calloc(ci->modes, sizeof(*ci->mode_param)); + if (!ci->mode_param){ + ci->modes=0; + goto err_out; + } + for(i=0;imodes;i++){ + ci->mode_param[i].blockflag=(unsigned char)oggpack_read(opb,1); + if(oggpack_read(opb,16))goto err_out; + if(oggpack_read(opb,16))goto err_out; + ci->mode_param[i].mapping=(unsigned char)oggpack_read(opb,8); + if(ci->mode_param[i].mapping>=ci->maps)goto err_out; + } + + if(oggpack_read(opb,1)!=1)goto err_out; /* top level EOP check */ + + return(0); + err_out: + vorbis_info_clear(vi); + return(OV_EBADHEADER); +} + +/* The Vorbis header is in three packets; the initial small packet in + the first page that identifies basic parameters, a second packet + with bitstream comments and a third packet that holds the + codebook. */ + +int vorbis_dsp_headerin(vorbis_info *vi,vorbis_comment *vc,ogg_packet *op){ + oggpack_buffer opb; + + if(op){ + oggpack_readinit(&opb,op->packet); + + /* Which of the three types of header is this? */ + /* Also verify header-ness, vorbis */ + { + char buffer[6]; + int packtype=oggpack_read(&opb,8); + memset(buffer,0,6); + _v_readstring(&opb,buffer,6); + if(memcmp(buffer,"vorbis",6)){ + /* not a vorbis header */ + return(OV_ENOTVORBIS); + } + switch(packtype){ + case 0x01: /* least significant *bit* is read first */ + if(!op->b_o_s){ + /* Not the initial packet */ + return(OV_EBADHEADER); + } + if(vi->rate!=0){ + /* previously initialized info header */ + return(OV_EBADHEADER); + } + + return(_vorbis_unpack_info(vi,&opb)); + + case 0x03: /* least significant *bit* is read first */ + if(vi->rate==0){ + /* um... we didn't get the initial header */ + return(OV_EBADHEADER); + } + + return(_vorbis_unpack_comment(vc,&opb)); + + case 0x05: /* least significant *bit* is read first */ + if(vi->rate==0 || vc->vendor==NULL){ + /* um... we didn;t get the initial header or comments yet */ + return(OV_EBADHEADER); + } + + return(_vorbis_unpack_books(vi,&opb)); + + default: + /* Not a valid vorbis header type */ + return(OV_EBADHEADER); + break; + } + } + } + return(OV_EBADHEADER); +} + diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c new file mode 100644 index 0000000..8ec9aa5 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c @@ -0,0 +1,173 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ivorbiscodec.h" +#include "ivorbisfile.h" + +struct JniParams { + JNIEnv *env; + jobject obj; + void *jniBuffer; + jmethodID writeOgg; + jmethodID seekOgg; + jmethodID tellOgg; + int current_section; +}; + +static size_t oggRead(void *ptr, size_t size, size_t nmemb, void *datasource){ + struct JniParams *params = datasource; + int written = (*params->env)->CallIntMethod(params->env, params->obj, params->writeOgg, 1 * nmemb); + if(written > 0){ + memcpy(ptr, params->jniBuffer, written); + } + + return written; +} + +static int oggSeek(void *datasource, ogg_int64_t offset, int whence) +{ + struct JniParams *params = datasource; + + int result = (*params->env)->CallIntMethod(params->env, params->obj, params->seekOgg, offset, whence); + + return result; +} + +static long oggTell(void *datasource) +{ + struct JniParams *params = datasource; + int position = (*params->env)->CallIntMethod(params->env, params->obj, params->tellOgg); + return position; +} + +JNIEXPORT jlong JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_initDecoder(JNIEnv *env, jobject obj, jobject jJjniBuffer) +{ + void *jniBuffer = (*env)->GetDirectBufferAddress(env, jJjniBuffer); + + jclass cls = (*env)->GetObjectClass(env, obj); + + jmethodID writeOgg = (*env)->GetMethodID(env, cls, "writeOgg", "(I)I"); + jmethodID seekOgg = (*env)->GetMethodID(env, cls, "seekOgg", "(JI)I"); + jmethodID tellOgg = (*env)->GetMethodID(env, cls, "tellOgg", "()I"); + + struct JniParams *params; + params = (struct JniParams *)malloc(sizeof(struct JniParams)); + params->env = env; + params->jniBuffer = jniBuffer; + params->writeOgg = writeOgg; + params->seekOgg = seekOgg; + params->tellOgg = tellOgg; + params->obj = obj; + + struct OggVorbis_File *vf; + vf = (struct OggVorbis_File *)malloc(sizeof(struct OggVorbis_File)); + + ov_callbacks callbacks = { + (size_t (*)(void *, size_t, size_t, void *)) oggRead, + (int (*)(void *, ogg_int64_t, int)) oggSeek, //noseek + (int (*)(void *)) fclose, + (long (*)(void *)) oggTell // notell + }; + + if(ov_open_callbacks(params, vf, NULL, 0, callbacks) < 0) { + // Input does not appear to be an Ogg bitstream + return 0; + } + + jlong pointer = (jlong) vf; + return pointer; +} + +static unsigned int samplesWritten = 0; + +static unsigned int pcm_bytes_to_frames(unsigned int bytes) { + return bytes / (2 * (16 >> 3)); +} + +JNIEXPORT jlong JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_read(JNIEnv *env, jobject obj, jlong jHandle, jint jLen) +{ + struct OggVorbis_File *vf; + vf = (struct OggVorbis_File *)jHandle; + + struct JniParams *params = vf->datasource; + params->env = env; + params->obj = obj; + + return ov_read(vf,params->jniBuffer,jLen,¶ms->current_section); +} + +JNIEXPORT jint JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_seekMs(JNIEnv *env, jobject obj, jlong jHandle, jint jMilliseconds) +{ + struct OggVorbis_File *vf; + vf = (struct OggVorbis_File *)jHandle; + + struct JniParams *params = vf->datasource; + params->env = env; + params->obj = obj; + return ov_time_seek(vf, jMilliseconds); +} + +JNIEXPORT jint JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_seekSamples(JNIEnv *env, jobject obj, jlong jHandle, jint jSamples) +{ + struct OggVorbis_File *vf; + vf = (struct OggVorbis_File *)jHandle; + + struct JniParams *params = vf->datasource; + params->env = env; + params->obj = obj; + return ov_pcm_seek(vf, jSamples); +} + + + +JNIEXPORT jlong JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_tellMs(JNIEnv *env, jobject obj, jlong jHandle) +{ + struct OggVorbis_File *vf; + vf = (struct OggVorbis_File *)jHandle; + + struct JniParams *params = vf->datasource; + params->env = env; + params->obj = obj; + return ov_time_tell(vf); +} + +JNIEXPORT jlong JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_tellSamples(JNIEnv *env, jobject obj, jlong jHandle) +{ + struct OggVorbis_File *vf; + vf = (struct OggVorbis_File *)jHandle; + + struct JniParams *params = vf->datasource; + params->env = env; + params->obj = obj; + return ov_pcm_tell(vf); +} + +JNIEXPORT jlong JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_totalSamples(JNIEnv *env, jobject obj, jlong jHandle) +{ + struct OggVorbis_File *vf; + vf = (struct OggVorbis_File *)jHandle; + + struct JniParams *params = vf->datasource; + params->env = env; + params->obj = obj; + return ov_pcm_total(vf,-1); +} + +JNIEXPORT void JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_close(JNIEnv *env, jobject obj, jlong jHandle) +{ + struct OggVorbis_File *vf; + vf = (struct OggVorbis_File *)jHandle; + struct JniParams *params = vf->datasource; + + free(params); + vf->datasource = NULL; + ov_clear(vf); + free(vf); + vf = NULL; +} \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/vorbisfile.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/vorbisfile.c new file mode 100644 index 0000000..f896b43 --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/vorbisfile.c @@ -0,0 +1,1612 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: stdio-based convenience library for opening/seeking/decoding + last mod: $Id: vorbisfile.c,v 1.6.2.5 2003/11/20 06:16:17 xiphmont Exp $ + + ************************************************************************/ + +#include +#include +//#include +#include +#include + +#include "codec_internal.h" +#include "ivorbisfile.h" + +#include "os.h" +#include "misc.h" + +int gerrno; + +#define NOTOPEN 0 +#define PARTOPEN 1 +#define OPENED 2 +#define STREAMSET 3 /* serialno and link set, but not to current link */ +#define LINKSET 4 /* serialno and link set to current link */ +#define INITSET 5 + +/* A 'chained bitstream' is a Vorbis bitstream that contains more than + one logical bitstream arranged end to end (the only form of Ogg + multiplexing allowed in a Vorbis bitstream; grouping [parallel + multiplexing] is not allowed in Vorbis) */ + +/* A Vorbis file can be played beginning to end (streamed) without + worrying ahead of time about chaining (see decoder_example.c). If + we have the whole file, however, and want random access + (seeking/scrubbing) or desire to know the total length/time of a + file, we need to account for the possibility of chaining. */ + +/* We can handle things a number of ways; we can determine the entire + bitstream structure right off the bat, or find pieces on demand. + This example determines and caches structure for the entire + bitstream, but builds a virtual decoder on the fly when moving + between links in the chain. */ + +/* There are also different ways to implement seeking. Enough + information exists in an Ogg bitstream to seek to + sample-granularity positions in the output. Or, one can seek by + picking some portion of the stream roughly in the desired area if + we only want coarse navigation through the stream. */ + +/************************************************************************* + * Many, many internal helpers. The intention is not to be confusing; + * rampant duplication and monolithic function implementation would be + * harder to understand anyway. The high level functions are last. Begin + * grokking near the end of the file */ + + +/* read a little more data from the file/pipe into the ogg_sync framer */ +static long _get_data(OggVorbis_File *vf){ + gerrno=0; + if(vf->datasource){ + unsigned char *buffer=ogg_sync_bufferin(vf->oy,CHUNKSIZE); + long bytes=(vf->callbacks.read_func)(buffer,1,CHUNKSIZE,vf->datasource); + if(bytes>0)ogg_sync_wrote(vf->oy,bytes); + if(bytes==0 && gerrno)return -1; + return bytes; + }else + return 0; +} + +/* save a tiny smidge of verbosity to make the code more readable */ +static void _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){ + if(vf->datasource){ + (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET); + vf->offset=offset; + ogg_sync_reset(vf->oy); + }else{ + /* shouldn't happen unless someone writes a broken callback */ + return; + } +} + +/* The read/seek functions track absolute position within the stream */ + +/* from the head of the stream, get the next page. boundary specifies + if the function is allowed to fetch more data from the stream (and + how much) or only use internally buffered data. + + boundary: -1) unbounded search + 0) read no additional data; use cached only + n) search for a new page beginning for n bytes + + return: <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD) + n) found a page at absolute offset n + + produces a refcounted page */ + +static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og, + ogg_int64_t boundary){ + if(boundary>0)boundary+=vf->offset; + while(1){ + long more; + + if(boundary>0 && vf->offset>=boundary)return OV_FALSE; + more=ogg_sync_pageseek(vf->oy,og); + + if(more<0){ + /* skipped n bytes */ + vf->offset-=more; + }else{ + if(more==0){ + /* send more paramedics */ + if(!boundary)return OV_FALSE; + { + long ret=_get_data(vf); + if(ret==0)return OV_EOF; + if(ret<0)return OV_EREAD; + } + }else{ + /* got a page. Return the offset at the page beginning, + advance the internal offset past the page end */ + ogg_int64_t ret=vf->offset; + vf->offset+=more; + return ret; + + } + } + } +} + +/* find the latest page beginning before the current stream cursor + position. Much dirtier than the above as Ogg doesn't have any + backward search linkage. no 'readp' as it will certainly have to + read. */ +/* returns offset or OV_EREAD, OV_FAULT and produces a refcounted page */ + +static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_page *og){ + ogg_int64_t begin=vf->offset; + ogg_int64_t end=begin; + ogg_int64_t ret; + ogg_int64_t offset=-1; + + while(offset==-1){ + begin-=CHUNKSIZE; + if(begin<0) + begin=0; + _seek_helper(vf,begin); + while(vf->offsetoffset); + if(ret==OV_EREAD)return OV_EREAD; + if(ret<0){ + break; + }else{ + offset=ret; + } + } + } + + /* we have the offset. Actually snork and hold the page now */ + _seek_helper(vf,offset); + ret=_get_next_page(vf,og,CHUNKSIZE); + if(ret<0) + /* this shouldn't be possible */ + return OV_EFAULT; + + return offset; +} + +/* finds each bitstream link one at a time using a bisection search + (has to begin by knowing the offset of the lb's initial page). + Recurses for each link so it can alloc the link storage after + finding them all, then unroll and fill the cache at the same time */ +static int _bisect_forward_serialno(OggVorbis_File *vf, + ogg_int64_t begin, + ogg_int64_t searched, + ogg_int64_t end, + ogg_uint32_t currentno, + long m){ + ogg_int64_t endsearched=end; + ogg_int64_t next=end; + ogg_page og={0,0,0,0}; + ogg_int64_t ret; + + /* the below guards against garbage seperating the last and + first pages of two links. */ + while(searched=0)next=ret; + }else{ + searched=ret+og.header_len+og.body_len; + } + ogg_page_release(&og); + } + + _seek_helper(vf,next); + ret=_get_next_page(vf,&og,-1); + if(ret==OV_EREAD)return OV_EREAD; + + if(searched>=end || ret<0){ + ogg_page_release(&og); + vf->links=m+1; + vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets)); + vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos)); + vf->offsets[m+1]=searched; + }else{ + ret=_bisect_forward_serialno(vf,next,vf->offset, + end,ogg_page_serialno(&og),m+1); + ogg_page_release(&og); + if(ret==OV_EREAD)return OV_EREAD; + } + + vf->offsets[m]=begin; + vf->serialnos[m]=currentno; + return 0; +} + +static int _decode_clear(OggVorbis_File *vf){ + if(vf->ready_state==INITSET){ + vorbis_dsp_destroy(vf->vd); + vf->vd=0; + vf->ready_state=STREAMSET; + } + + if(vf->ready_state>=STREAMSET){ + vorbis_info_clear(&vf->vi); + vorbis_comment_clear(&vf->vc); + vf->ready_state=OPENED; + } + return 0; +} + +/* uses the local ogg_stream storage in vf; this is important for + non-streaming input sources */ +/* consumes the page that's passed in (if any) */ +/* state is LINKSET upon successful return */ + +static int _fetch_headers(OggVorbis_File *vf, + vorbis_info *vi, + vorbis_comment *vc, + ogg_uint32_t *serialno, + ogg_page *og_ptr){ + ogg_page og={0,0,0,0}; + ogg_packet op={0,0,0,0,0,0}; + int i,ret; + + if(vf->ready_state>OPENED)_decode_clear(vf); + + if(!og_ptr){ + ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE); + if(llret==OV_EREAD)return OV_EREAD; + if(llret<0)return OV_ENOTVORBIS; + og_ptr=&og; + } + + ogg_stream_reset_serialno(vf->os,ogg_page_serialno(og_ptr)); + if(serialno)*serialno=vf->os->serialno; + + /* extract the initial header from the first page and verify that the + Ogg bitstream is in fact Vorbis data */ + + vorbis_info_init(vi); + vorbis_comment_init(vc); + + i=0; + while(i<3){ + ogg_stream_pagein(vf->os,og_ptr); + while(i<3){ + int result=ogg_stream_packetout(vf->os,&op); + if(result==0)break; + if(result==-1){ + ret=OV_EBADHEADER; + goto bail_header; + } + if((ret=vorbis_dsp_headerin(vi,vc,&op))){ + goto bail_header; + } + i++; + } + if(i<3) + if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){ + ret=OV_EBADHEADER; + goto bail_header; + } + } + + ogg_packet_release(&op); + ogg_page_release(&og); + vf->ready_state=LINKSET; + return 0; + + bail_header: + ogg_packet_release(&op); + ogg_page_release(&og); + vorbis_info_clear(vi); + vorbis_comment_clear(vc); + vf->ready_state=OPENED; + + return ret; +} + +/* we no longer preload all vorbis_info (and the associated + codec_setup) structs. Call this to seek and fetch the info from + the bitstream, if needed */ +static int _set_link_number(OggVorbis_File *vf,int link){ + if(link != vf->current_link) _decode_clear(vf); + if(vf->ready_stateoffsets[link]); + ogg_stream_reset_serialno(vf->os,vf->serialnos[link]); + vf->current_serialno=vf->serialnos[link]; + vf->current_link=link; + return _fetch_headers(vf,&vf->vi,&vf->vc,&vf->current_serialno,NULL); + } + return 0; +} + +static int _set_link_number_preserve_pos(OggVorbis_File *vf,int link){ + ogg_int64_t pos=vf->offset; + int ret=_set_link_number(vf,link); + if(ret)return ret; + _seek_helper(vf,pos); + if(posoffsets[link] || pos>=vf->offsets[link+1]) + vf->ready_state=STREAMSET; + return 0; +} + +/* last step of the OggVorbis_File initialization; get all the offset + positions. Only called by the seekable initialization (local + stream storage is hacked slightly; pay attention to how that's + done) */ + +/* this is void and does not propogate errors up because we want to be + able to open and use damaged bitstreams as well as we can. Just + watch out for missing information for links in the OggVorbis_File + struct */ +static void _prefetch_all_offsets(OggVorbis_File *vf, ogg_int64_t dataoffset){ + ogg_page og={0,0,0,0}; + int i; + ogg_int64_t ret; + + vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets)); + vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths)); + + for(i=0;ilinks;i++){ + if(i==0){ + /* we already grabbed the initial header earlier. Just set the offset */ + vf->dataoffsets[i]=dataoffset; + _seek_helper(vf,dataoffset); + + }else{ + + /* seek to the location of the initial header */ + + _seek_helper(vf,vf->offsets[i]); + if(_fetch_headers(vf,&vf->vi,&vf->vc,NULL,NULL)<0){ + vf->dataoffsets[i]=-1; + }else{ + vf->dataoffsets[i]=vf->offset; + } + } + + /* fetch beginning PCM offset */ + + if(vf->dataoffsets[i]!=-1){ + ogg_int64_t accumulated=0,pos; + long lastblock=-1; + int result; + + ogg_stream_reset_serialno(vf->os,vf->serialnos[i]); + + while(1){ + ogg_packet op={0,0,0,0,0,0}; + + ret=_get_next_page(vf,&og,-1); + if(ret<0) + /* this should not be possible unless the file is + truncated/mangled */ + break; + + if(ogg_page_serialno(&og)!=vf->serialnos[i]) + break; + + pos=ogg_page_granulepos(&og); + + /* count blocksizes of all frames in the page */ + ogg_stream_pagein(vf->os,&og); + while((result=ogg_stream_packetout(vf->os,&op))){ + if(result>0){ /* ignore holes */ + long thisblock=vorbis_packet_blocksize(&vf->vi,&op); + if(lastblock!=-1) + accumulated+=(lastblock+thisblock)>>2; + lastblock=thisblock; + } + } + ogg_packet_release(&op); + + if(pos!=-1){ + /* pcm offset of last packet on the first audio page */ + accumulated= pos-accumulated; + break; + } + } + + /* less than zero? This is a stream with samples trimmed off + the beginning, a normal occurrence; set the offset to zero */ + if(accumulated<0)accumulated=0; + + vf->pcmlengths[i*2]=accumulated; + } + + /* get the PCM length of this link. To do this, + get the last page of the stream */ + { + ogg_int64_t end=vf->offsets[i+1]; + _seek_helper(vf,end); + + while(1){ + ret=_get_prev_page(vf,&og); + if(ret<0){ + /* this should not be possible */ + vorbis_info_clear(&vf->vi); + vorbis_comment_clear(&vf->vc); + break; + } + if(ogg_page_granulepos(&og)!=-1){ + vf->pcmlengths[i*2+1]=ogg_page_granulepos(&og)-vf->pcmlengths[i*2]; + break; + } + vf->offset=ret; + } + } + } + ogg_page_release(&og); +} + +static int _make_decode_ready(OggVorbis_File *vf){ + int i; + switch(vf->ready_state){ + case OPENED: + case STREAMSET: + for(i=0;ilinks;i++) + if(vf->offsets[i+1]>=vf->offset)break; + if(i==vf->links)return -1; + i=_set_link_number_preserve_pos(vf,i); + if(i)return i; + /* fall through */ + case LINKSET: + vf->vd=vorbis_dsp_create(&vf->vi); + vf->ready_state=INITSET; + vf->bittrack=0; + vf->samptrack=0; + case INITSET: + return 0; + default: + return -1; + } + +} + +static int _open_seekable2(OggVorbis_File *vf){ + ogg_uint32_t serialno=vf->current_serialno; + ogg_uint32_t tempserialno; + ogg_int64_t dataoffset=vf->offset, end; + ogg_page og={0,0,0,0}; + + /* we're partially open and have a first link header state in + storage in vf */ + /* we can seek, so set out learning all about this file */ + (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END); + vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource); + + /* We get the offset for the last page of the physical bitstream. + Most OggVorbis files will contain a single logical bitstream */ + end=_get_prev_page(vf,&og); + if(end<0)return (int)end; + + /* more than one logical bitstream? */ + tempserialno=ogg_page_serialno(&og); + ogg_page_release(&og); + + if(tempserialno!=serialno){ + + /* Chained bitstream. Bisect-search each logical bitstream + section. Do so based on serial number only */ + if(_bisect_forward_serialno(vf,0,0,end+1,serialno,0)<0)return OV_EREAD; + + }else{ + + /* Only one logical bitstream */ + if(_bisect_forward_serialno(vf,0,end,end+1,serialno,0))return OV_EREAD; + + } + + /* the initial header memory is referenced by vf after; don't free it */ + _prefetch_all_offsets(vf,dataoffset); + return ov_raw_seek(vf,0); +} + +/* fetch and process a packet. Handles the case where we're at a + bitstream boundary and dumps the decoding machine. If the decoding + machine is unloaded, it loads it. It also keeps pcm_offset up to + date (seek and read both use this. seek uses a special hack with + readp). + + return: <0) error, OV_HOLE (lost packet) or OV_EOF + 0) need more data (only if readp==0) + 1) got a packet +*/ + +static int _fetch_and_process_packet(OggVorbis_File *vf, + int readp, + int spanp){ + ogg_page og={0,0,0,0}; + ogg_packet op={0,0,0,0,0,0}; + int ret=0; + + /* handle one packet. Try to fetch it from current stream state */ + /* extract packets from page */ + while(1){ + + /* process a packet if we can. If the machine isn't loaded, + neither is a page */ + if(vf->ready_state==INITSET){ + while(1) { + int result=ogg_stream_packetout(vf->os,&op); + ogg_int64_t granulepos; + + if(result<0){ + ret=OV_HOLE; /* hole in the data. */ + goto cleanup; + } + if(result>0){ + /* got a packet. process it */ + granulepos=op.granulepos; + if(!vorbis_dsp_synthesis(vf->vd,&op,1)){ /* lazy check for lazy + header handling. The + header packets aren't + audio, so if/when we + submit them, + vorbis_synthesis will + reject them */ + + vf->samptrack+=vorbis_dsp_pcmout(vf->vd,NULL,0); + vf->bittrack+=op.bytes*8; + + /* update the pcm offset. */ + if(granulepos!=-1 && !op.e_o_s){ + int link=(vf->seekable?vf->current_link:0); + int i,samples; + + /* this packet has a pcm_offset on it (the last packet + completed on a page carries the offset) After processing + (above), we know the pcm position of the *last* sample + ready to be returned. Find the offset of the *first* + + As an aside, this trick is inaccurate if we begin + reading anew right at the last page; the end-of-stream + granulepos declares the last frame in the stream, and the + last packet of the last page may be a partial frame. + So, we need a previous granulepos from an in-sequence page + to have a reference point. Thus the !op.e_o_s clause + above */ + + if(vf->seekable && link>0) + granulepos-=vf->pcmlengths[link*2]; + if(granulepos<0)granulepos=0; /* actually, this + shouldn't be possible + here unless the stream + is very broken */ + + samples=vorbis_dsp_pcmout(vf->vd,NULL,0); + + granulepos-=samples; + for(i=0;ipcmlengths[i*2+1]; + vf->pcm_offset=granulepos; + } + ret=1; + goto cleanup; + } + } + else + break; + } + } + + if(vf->ready_state>=OPENED){ + int ret; + if(!readp){ + ret=0; + goto cleanup; + } + ret=(int)_get_next_page(vf,&og,-1); + if(ret<0){ + ret=OV_EOF; /* eof. leave unitialized */ + goto cleanup; + } + + /* bitrate tracking; add the header's bytes here, the body bytes + are done by packet above */ + vf->bittrack+=og.header_len*8; + + /* has our decoding just traversed a bitstream boundary? */ + if(vf->ready_state==INITSET){ + if(vf->current_serialno!=ogg_page_serialno(&og)){ + if(!spanp){ + ret=OV_EOF; + goto cleanup; + } + + _decode_clear(vf); + } + } + } + + /* Do we need to load a new machine before submitting the page? */ + /* This is different in the seekable and non-seekable cases. + + In the seekable case, we already have all the header + information loaded and cached; we just initialize the machine + with it and continue on our merry way. + + In the non-seekable (streaming) case, we'll only be at a + boundary if we just left the previous logical bitstream and + we're now nominally at the header of the next bitstream + */ + + if(vf->ready_state!=INITSET){ + int link,ret; + + if(vf->ready_stateseekable){ + vf->current_serialno=ogg_page_serialno(&og); + + /* match the serialno to bitstream section. We use this rather than + offset positions to avoid problems near logical bitstream + boundaries */ + for(link=0;linklinks;link++) + if(vf->serialnos[link]==vf->current_serialno)break; + if(link==vf->links){ + ret=OV_EBADLINK; /* sign of a bogus stream. error out, + leave machine uninitialized */ + goto cleanup; + } + + vf->current_link=link; + ret=_fetch_headers(vf,&vf->vi,&vf->vc,&vf->current_serialno,&og); + if(ret) goto cleanup; + + }else{ + /* we're streaming */ + /* fetch the three header packets, build the info struct */ + + int ret=_fetch_headers(vf,&vf->vi,&vf->vc,&vf->current_serialno,&og); + if(ret) goto cleanup; + vf->current_link++; + } + } + + if(_make_decode_ready(vf)) return OV_EBADLINK; + } + ogg_stream_pagein(vf->os,&og); + } + cleanup: + ogg_packet_release(&op); + ogg_page_release(&og); + return ret; +} + +/* if, eg, 64 bit stdio is configured by default, this will build with + fseek64 */ +static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){ + if(f==NULL)return -1; + return fseek(f,(long)off,whence); +} + +static int _ov_open1(void *f,OggVorbis_File *vf,char *initial, + long ibytes, ov_callbacks callbacks){ + int offsettest=(f?callbacks.seek_func(f,0,SEEK_CUR):-1); + int ret; + + memset(vf,0,sizeof(*vf)); + + /* Tremor assumes in multiple places that right shift of a signed + integer is an arithmetic shift */ + if( (-1>>1) != -1) return OV_EIMPL; + + vf->datasource=f; + vf->callbacks = callbacks; + + /* init the framing state */ + vf->oy=ogg_sync_create(); + + /* perhaps some data was previously read into a buffer for testing + against other stream types. Allow initialization from this + previously read data (as we may be reading from a non-seekable + stream) */ + if(initial){ + unsigned char *buffer=ogg_sync_bufferin(vf->oy,ibytes); + memcpy(buffer,initial,ibytes); + ogg_sync_wrote(vf->oy,ibytes); + } + + /* can we seek? Stevens suggests the seek test was portable */ + if(offsettest!=-1)vf->seekable=1; + + /* No seeking yet; Set up a 'single' (current) logical bitstream + entry for partial open */ + vf->links=1; + vf->os=ogg_stream_create(-1); /* fill in the serialno later */ + + /* Try to fetch the headers, maintaining all the storage */ + if((ret=_fetch_headers(vf,&vf->vi,&vf->vc,&vf->current_serialno,NULL))<0){ + vf->datasource=NULL; + ov_clear(vf); + }else if(vf->ready_state < PARTOPEN) + vf->ready_state=PARTOPEN; + return ret; +} + +static int _ov_open2(OggVorbis_File *vf){ + if(vf->ready_state < OPENED) + vf->ready_state=OPENED; + if(vf->seekable){ + int ret=_open_seekable2(vf); + if(ret){ + vf->datasource=NULL; + ov_clear(vf); + } + return ret; + } + return 0; +} + + +/* clear out the OggVorbis_File struct */ +int ov_clear(OggVorbis_File *vf){ + if(vf){ + vorbis_dsp_destroy(vf->vd); + vf->vd=0; + ogg_stream_destroy(vf->os); + vorbis_info_clear(&vf->vi); + vorbis_comment_clear(&vf->vc); + if(vf->dataoffsets)_ogg_free(vf->dataoffsets); + if(vf->pcmlengths)_ogg_free(vf->pcmlengths); + if(vf->serialnos)_ogg_free(vf->serialnos); + if(vf->offsets)_ogg_free(vf->offsets); + ogg_sync_destroy(vf->oy); + + if(vf->datasource)(vf->callbacks.close_func)(vf->datasource); + memset(vf,0,sizeof(*vf)); + } +#ifdef DEBUG_LEAKS + _VDBG_dump(); +#endif + return 0; +} + +/* inspects the OggVorbis file and finds/documents all the logical + bitstreams contained in it. Tries to be tolerant of logical + bitstream sections that are truncated/woogie. + + return: -1) error + 0) OK +*/ + +int ov_open_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes, + ov_callbacks callbacks){ + int ret=_ov_open1(f,vf,initial,ibytes,callbacks); + if(ret)return ret; + return _ov_open2(vf); +} + +int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){ + ov_callbacks callbacks = { + (size_t (*)(void *, size_t, size_t, void *)) fread, + (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap, + (int (*)(void *)) fclose, + (long (*)(void *)) ftell + }; + + return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks); +} + +/* Only partially open the vorbis file; test for Vorbisness, and load + the headers for the first chain. Do not seek (although test for + seekability). Use ov_test_open to finish opening the file, else + ov_clear to close/free it. Same return codes as open. */ + +int ov_test_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes, + ov_callbacks callbacks) +{ + return _ov_open1(f,vf,initial,ibytes,callbacks); +} + +int ov_test(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){ + ov_callbacks callbacks = { + (size_t (*)(void *, size_t, size_t, void *)) fread, + (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap, + (int (*)(void *)) fclose, + (long (*)(void *)) ftell + }; + + return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks); +} + +int ov_test_open(OggVorbis_File *vf){ + if(vf->ready_state!=PARTOPEN)return OV_EINVAL; + return _ov_open2(vf); +} + +/* How many logical bitstreams in this physical bitstream? */ +long ov_streams(OggVorbis_File *vf){ + return vf->links; +} + +/* Is the FILE * associated with vf seekable? */ +long ov_seekable(OggVorbis_File *vf){ + return vf->seekable; +} + +/* returns the bitrate for a given logical bitstream or the entire + physical bitstream. If the file is open for random access, it will + find the *actual* average bitrate. If the file is streaming, it + returns the nominal bitrate (if set) else the average of the + upper/lower bounds (if set) else -1 (unset). + + If you want the actual bitrate field settings, get them from the + vorbis_info structs */ + +long ov_bitrate(OggVorbis_File *vf,int i){ + if(vf->ready_state=vf->links)return OV_EINVAL; + if(!vf->seekable && i!=0)return ov_bitrate(vf,0); + if(i<0){ + ogg_int64_t bits=0; + int i; + for(i=0;ilinks;i++) + bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8; + /* This once read: return(rint(bits/ov_time_total(vf,-1))); + * gcc 3.x on x86 miscompiled this at optimisation level 2 and above, + * so this is slightly transformed to make it work. + */ + return (long)(bits*1000/ov_time_total(vf,-1)); + }else{ + if(vf->seekable){ + /* return the actual bitrate */ + return (long)((vf->offsets[i+1]-vf->dataoffsets[i])*8000/ov_time_total(vf,i)); + }else{ + /* return nominal if set */ + if(vf->vi.bitrate_nominal>0){ + return vf->vi.bitrate_nominal; + }else{ + if(vf->vi.bitrate_upper>0){ + if(vf->vi.bitrate_lower>0){ + return (vf->vi.bitrate_upper+vf->vi.bitrate_lower)/2; + }else{ + return vf->vi.bitrate_upper; + } + } + return OV_FALSE; + } + } + } +} + +/* returns the actual bitrate since last call. returns -1 if no + additional data to offer since last call (or at beginning of stream), + EINVAL if stream is only partially open +*/ +long ov_bitrate_instant(OggVorbis_File *vf){ + long ret; + if(vf->ready_statesamptrack==0)return OV_FALSE; + ret=(long)(vf->bittrack/vf->samptrack*vf->vi.rate); + vf->bittrack=0; + vf->samptrack=0; + return ret; +} + +/* Guess */ +long ov_serialnumber(OggVorbis_File *vf,int i){ + if(i>=vf->links)return ov_serialnumber(vf,vf->links-1); + if(!vf->seekable && i>=0)return ov_serialnumber(vf,-1); + if(i<0){ + return vf->current_serialno; + }else{ + return vf->serialnos[i]; + } +} + +/* returns: total raw (compressed) length of content if i==-1 + raw (compressed) length of that logical bitstream for i==0 to n + OV_EINVAL if the stream is not seekable (we can't know the length) + or if stream is only partially open +*/ +ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){ + if(vf->ready_stateseekable || i>=vf->links)return OV_EINVAL; + if(i<0){ + ogg_int64_t acc=0; + int i; + for(i=0;ilinks;i++) + acc+=ov_raw_total(vf,i); + return acc; + }else{ + return vf->offsets[i+1]-vf->offsets[i]; + } +} + +/* returns: total PCM length (samples) of content if i==-1 PCM length + (samples) of that logical bitstream for i==0 to n + OV_EINVAL if the stream is not seekable (we can't know the + length) or only partially open +*/ +ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){ + if(vf->ready_stateseekable || i>=vf->links)return OV_EINVAL; + if(i<0){ + ogg_int64_t acc=0; + int i; + for(i=0;ilinks;i++) + acc+=ov_pcm_total(vf,i); + return acc; + }else{ + return vf->pcmlengths[i*2+1]; + } +} + +/* returns: total milliseconds of content if i==-1 + milliseconds in that logical bitstream for i==0 to n + OV_EINVAL if the stream is not seekable (we can't know the + length) or only partially open +*/ +ogg_int64_t ov_time_total(OggVorbis_File *vf,int i){ + if(vf->ready_stateseekable || i>=vf->links)return OV_EINVAL; + if(i<0){ + ogg_int64_t acc=0; + int i; + for(i=0;ilinks;i++) + acc+=ov_time_total(vf,i); + return acc; + }else{ + return ((ogg_int64_t)vf->pcmlengths[i*2+1])*1000/vf->vi.rate; + } +} + +/* seek to an offset relative to the *compressed* data. This also + scans packets to update the PCM cursor. It will cross a logical + bitstream boundary, but only if it can't get any packets out of the + tail of the bitstream we seek to (so no surprises). + + returns zero on success, nonzero on failure */ + +int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){ + ogg_stream_state *work_os=NULL; + ogg_page og={0,0,0,0}; + ogg_packet op={0,0,0,0,0,0}; + + if(vf->ready_stateseekable) + return OV_ENOSEEK; /* don't dump machine if we can't seek */ + + if(pos<0 || pos>vf->end)return OV_EINVAL; + + /* don't yet clear out decoding machine (if it's initialized), in + the case we're in the same link. Restart the decode lapping, and + let _fetch_and_process_packet deal with a potential bitstream + boundary */ + vf->pcm_offset=-1; + ogg_stream_reset_serialno(vf->os, + vf->current_serialno); /* must set serialno */ + vorbis_dsp_restart(vf->vd); + + _seek_helper(vf,pos); + + /* we need to make sure the pcm_offset is set, but we don't want to + advance the raw cursor past good packets just to get to the first + with a granulepos. That's not equivalent behavior to beginning + decoding as immediately after the seek position as possible. + + So, a hack. We use two stream states; a local scratch state and + the shared vf->os stream state. We use the local state to + scan, and the shared state as a buffer for later decode. + + Unfortuantely, on the last page we still advance to last packet + because the granulepos on the last page is not necessarily on a + packet boundary, and we need to make sure the granpos is + correct. + */ + + { + int lastblock=0; + int accblock=0; + int thisblock; + int eosflag; + + work_os=ogg_stream_create(vf->current_serialno); /* get the memory ready */ + while(1){ + if(vf->ready_state>=STREAMSET){ + /* snarf/scan a packet if we can */ + int result=ogg_stream_packetout(work_os,&op); + + if(result>0){ + + if(vf->vi.codec_setup){ + thisblock=vorbis_packet_blocksize(&vf->vi,&op); + if(thisblock<0){ + ogg_stream_packetout(vf->os,NULL); + thisblock=0; + }else{ + + if(eosflag) + ogg_stream_packetout(vf->os,NULL); + else + if(lastblock)accblock+=(lastblock+thisblock)>>2; + } + + if(op.granulepos!=-1){ + int i,link=vf->current_link; + ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2]; + if(granulepos<0)granulepos=0; + + for(i=0;ipcmlengths[i*2+1]; + vf->pcm_offset=granulepos-accblock; + break; + } + lastblock=thisblock; + continue; + }else + ogg_stream_packetout(vf->os,NULL); + } + } + + if(!lastblock){ + if(_get_next_page(vf,&og,-1)<0){ + vf->pcm_offset=ov_pcm_total(vf,-1); + break; + } + }else{ + /* huh? Bogus stream with packets but no granulepos */ + vf->pcm_offset=-1; + break; + } + + /* did we just grab a page from other than current link? */ + if(vf->ready_state>=STREAMSET) + if(vf->current_serialno!=ogg_page_serialno(&og)){ + _decode_clear(vf); /* clear out stream state */ + ogg_stream_destroy(work_os); + } + + if(vf->ready_statecurrent_serialno=ogg_page_serialno(&og); + for(link=0;linklinks;link++) + if(vf->serialnos[link]==vf->current_serialno)break; + if(link==vf->links) + goto seek_error; /* sign of a bogus stream. error out, + leave machine uninitialized */ + + /* need to initialize machine to this link */ + { + int ret=_set_link_number_preserve_pos(vf,link); + if(ret) goto seek_error; + } + ogg_stream_reset_serialno(vf->os,vf->current_serialno); + ogg_stream_reset_serialno(work_os,vf->current_serialno); + + + } + + { + ogg_page dup; + ogg_page_dup(&dup,&og); + eosflag=ogg_page_eos(&og); + ogg_stream_pagein(vf->os,&og); + ogg_stream_pagein(work_os,&dup); + } + } + } + + ogg_packet_release(&op); + ogg_page_release(&og); + ogg_stream_destroy(work_os); + vf->bittrack=0; + vf->samptrack=0; + return 0; + + seek_error: + ogg_packet_release(&op); + ogg_page_release(&og); + + /* dump the machine so we're in a known state */ + vf->pcm_offset=-1; + ogg_stream_destroy(work_os); + _decode_clear(vf); + return OV_EBADLINK; +} + +/* Page granularity seek (faster than sample granularity because we + don't do the last bit of decode to find a specific sample). + + Seek to the last [granule marked] page preceeding the specified pos + location, such that decoding past the returned point will quickly + arrive at the requested position. */ +int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){ + int link=-1; + ogg_int64_t result=0; + ogg_int64_t total=ov_pcm_total(vf,-1); + ogg_page og={0,0,0,0}; + ogg_packet op={0,0,0,0,0,0}; + + if(vf->ready_stateseekable)return OV_ENOSEEK; + if(pos<0 || pos>total)return OV_EINVAL; + + /* which bitstream section does this pcm offset occur in? */ + for(link=vf->links-1;link>=0;link--){ + total-=vf->pcmlengths[link*2+1]; + if(pos>=total)break; + } + + + if(link!=vf->current_link){ + int ret=_set_link_number(vf,link); + if(ret) goto seek_error; + }else{ + vorbis_dsp_restart(vf->vd); + } + + ogg_stream_reset_serialno(vf->os,vf->serialnos[link]); + + /* search within the logical bitstream for the page with the highest + pcm_pos preceeding (or equal to) pos. There is a danger here; + missing pages or incorrect frame number information in the + bitstream could make our task impossible. Account for that (it + would be an error condition) */ + + /* new search algorithm by HB (Nicholas Vinen) */ + { + ogg_int64_t end=vf->offsets[link+1]; + ogg_int64_t begin=vf->offsets[link]; + ogg_int64_t begintime = vf->pcmlengths[link*2]; + ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime; + ogg_int64_t target=pos-total+begintime; + ogg_int64_t best=begin; + + while(beginoffset); + if(result==OV_EREAD) goto seek_error; + if(result<0){ + if(bisect<=begin+1) + end=begin; /* found it */ + else{ + if(bisect==0) goto seek_error; + bisect-=CHUNKSIZE; + if(bisect<=begin)bisect=begin+1; + _seek_helper(vf,bisect); + } + }else{ + ogg_int64_t granulepos=ogg_page_granulepos(&og); + if(granulepos==-1)continue; + if(granuleposoffset; /* raw offset of next page */ + begintime=granulepos; + + if(target-begintime>44100)break; + bisect=begin; /* *not* begin + 1 */ + }else{ + if(bisect<=begin+1) + end=begin; /* found it */ + else{ + if(end==vf->offset){ /* we're pretty close - we'd be stuck in */ + end=result; + bisect-=CHUNKSIZE; /* an endless loop otherwise. */ + if(bisect<=begin)bisect=begin+1; + _seek_helper(vf,bisect); + }else{ + end=result; + endtime=granulepos; + break; + } + } + } + } + } + } + + /* found our page. seek to it, update pcm offset. Easier case than + raw_seek, don't keep packets preceeding granulepos. */ + { + + /* seek */ + _seek_helper(vf,best); + vf->pcm_offset=-1; + + if(_get_next_page(vf,&og,-1)<0){ + ogg_page_release(&og); + return OV_EOF; /* shouldn't happen */ + } + + ogg_stream_pagein(vf->os,&og); + + /* pull out all but last packet; the one with granulepos */ + while(1){ + result=ogg_stream_packetpeek(vf->os,&op); + if(result==0){ + /* !!! the packet finishing this page originated on a + preceeding page. Keep fetching previous pages until we + get one with a granulepos or without the 'continued' flag + set. Then just use raw_seek for simplicity. */ + + _seek_helper(vf,best); + + while(1){ + result=_get_prev_page(vf,&og); + if(result<0) goto seek_error; + if(ogg_page_granulepos(&og)>-1 || + !ogg_page_continued(&og)){ + return ov_raw_seek(vf,result); + } + vf->offset=result; + } + } + if(result<0){ + result = OV_EBADPACKET; + goto seek_error; + } + if(op.granulepos!=-1){ + vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2]; + if(vf->pcm_offset<0)vf->pcm_offset=0; + vf->pcm_offset+=total; + break; + }else + result=ogg_stream_packetout(vf->os,NULL); + } + } + } + + /* verify result */ + if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){ + result=OV_EFAULT; + goto seek_error; + } + vf->bittrack=0; + vf->samptrack=0; + + ogg_page_release(&og); + ogg_packet_release(&op); + return 0; + + seek_error: + + ogg_page_release(&og); + ogg_packet_release(&op); + + /* dump machine so we're in a known state */ + vf->pcm_offset=-1; + _decode_clear(vf); + return (int)result; +} + +/* seek to a sample offset relative to the decompressed pcm stream + returns zero on success, nonzero on failure */ + +int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){ + ogg_packet op={0,0,0,0,0,0}; + ogg_page og={0,0,0,0}; + int thisblock,lastblock=0; + int ret=ov_pcm_seek_page(vf,pos); + if(ret<0)return ret; + if(_make_decode_ready(vf))return OV_EBADLINK; + + /* discard leading packets we don't need for the lapping of the + position we want; don't decode them */ + + while(1){ + + int ret=ogg_stream_packetpeek(vf->os,&op); + if(ret>0){ + thisblock=vorbis_packet_blocksize(&vf->vi,&op); + if(thisblock<0){ + ogg_stream_packetout(vf->os,NULL); + continue; /* non audio packet */ + } + if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2; + + if(vf->pcm_offset+((thisblock+ + vorbis_info_blocksize(&vf->vi,1))>>2)>=pos)break; + + /* remove the packet from packet queue and track its granulepos */ + ogg_stream_packetout(vf->os,NULL); + vorbis_dsp_synthesis(vf->vd,&op,0); /* set up a vb with + only tracking, no + pcm_decode */ + + /* end of logical stream case is hard, especially with exact + length positioning. */ + + if(op.granulepos>-1){ + int i; + /* always believe the stream markers */ + vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2]; + if(vf->pcm_offset<0)vf->pcm_offset=0; + for(i=0;icurrent_link;i++) + vf->pcm_offset+=vf->pcmlengths[i*2+1]; + } + + lastblock=thisblock; + + }else{ + if(ret<0 && ret!=OV_HOLE)break; + + /* suck in a new page */ + if(_get_next_page(vf,&og,-1)<0)break; + if(vf->current_serialno!=ogg_page_serialno(&og))_decode_clear(vf); + + if(vf->ready_statecurrent_serialno=ogg_page_serialno(&og); + for(link=0;linklinks;link++) + if(vf->serialnos[link]==vf->current_serialno)break; + if(link==vf->links){ + ogg_page_release(&og); + ogg_packet_release(&op); + return OV_EBADLINK; + } + + + vf->current_link=link; + ret=_fetch_headers(vf,&vf->vi,&vf->vc,&vf->current_serialno,&og); + if(ret) return ret; + if(_make_decode_ready(vf))return OV_EBADLINK; + lastblock=0; + } + + ogg_stream_pagein(vf->os,&og); + } + } + + vf->bittrack=0; + vf->samptrack=0; + /* discard samples until we reach the desired position. Crossing a + logical bitstream boundary with abandon is OK. */ + while(vf->pcm_offsetpcm_offset; + long samples=vorbis_dsp_pcmout(vf->vd,NULL,0); + + if(samples>target)samples=(long)target; + vorbis_dsp_read(vf->vd,samples); + vf->pcm_offset+=samples; + + if(samplespcm_offset=ov_pcm_total(vf,-1); /* eof */ + } + + ogg_page_release(&og); + ogg_packet_release(&op); + return 0; +} + +/* seek to a playback time relative to the decompressed pcm stream + returns zero on success, nonzero on failure */ +int ov_time_seek(OggVorbis_File *vf,ogg_int64_t milliseconds){ + /* translate time to PCM position and call ov_pcm_seek */ + + int link=-1; + ogg_int64_t pcm_total=ov_pcm_total(vf,-1); + ogg_int64_t time_total=ov_time_total(vf,-1); + + if(vf->ready_stateseekable)return OV_ENOSEEK; + if(milliseconds<0 || milliseconds>time_total)return OV_EINVAL; + + /* which bitstream section does this time offset occur in? */ + for(link=vf->links-1;link>=0;link--){ + pcm_total-=vf->pcmlengths[link*2+1]; + time_total-=ov_time_total(vf,link); + if(milliseconds>=time_total)break; + } + + /* enough information to convert time offset to pcm offset */ + { + int ret=_set_link_number(vf,link); + if(ret)return ret; + return + ov_pcm_seek(vf,pcm_total+(milliseconds-time_total)* + vf->vi.rate/1000); + } +} + +/* page-granularity version of ov_time_seek + returns zero on success, nonzero on failure */ +int ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t milliseconds){ + /* translate time to PCM position and call ov_pcm_seek */ + + int link=-1; + ogg_int64_t pcm_total=ov_pcm_total(vf,-1); + ogg_int64_t time_total=ov_time_total(vf,-1); + + if(vf->ready_stateseekable)return OV_ENOSEEK; + if(milliseconds<0 || milliseconds>time_total)return OV_EINVAL; + + /* which bitstream section does this time offset occur in? */ + for(link=vf->links-1;link>=0;link--){ + pcm_total-=vf->pcmlengths[link*2+1]; + time_total-=ov_time_total(vf,link); + if(milliseconds>=time_total)break; + } + + /* enough information to convert time offset to pcm offset */ + { + int ret=_set_link_number(vf,link); + if(ret)return ret; + return + ov_pcm_seek_page(vf,pcm_total+(milliseconds-time_total)* + vf->vi.rate/1000); + } +} + +/* tell the current stream offset cursor. Note that seek followed by + tell will likely not give the set offset due to caching */ +ogg_int64_t ov_raw_tell(OggVorbis_File *vf){ + if(vf->ready_stateoffset; +} + +/* return PCM offset (sample) of next PCM sample to be read */ +ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){ + if(vf->ready_statepcm_offset; +} + +/* return time offset (milliseconds) of next PCM sample to be read */ +ogg_int64_t ov_time_tell(OggVorbis_File *vf){ + int link=0; + ogg_int64_t pcm_total=0; + ogg_int64_t time_total=0; + + if(vf->ready_stateseekable){ + pcm_total=ov_pcm_total(vf,-1); + time_total=ov_time_total(vf,-1); + + /* which bitstream section does this time offset occur in? */ + for(link=vf->links-1;link>=0;link--){ + pcm_total-=vf->pcmlengths[link*2+1]; + time_total-=ov_time_total(vf,link); + if(vf->pcm_offset>=pcm_total)break; + } + } + + return time_total+(1000*vf->pcm_offset-pcm_total)/vf->vi.rate; +} + +/* link: -1) return the vorbis_info struct for the bitstream section + currently being decoded + 0-n) to request information for a specific bitstream section + + In the case of a non-seekable bitstream, any call returns the + current bitstream. NULL in the case that the machine is not + initialized */ + +vorbis_info *ov_info(OggVorbis_File *vf,int link){ + if(vf->seekable){ + if(link>=vf->links)return NULL; + if(link>=0){ + int ret=_set_link_number_preserve_pos(vf,link); + if(ret)return NULL; + } + } + return &vf->vi; +} + +/* grr, strong typing, grr, no templates/inheritence, grr */ +vorbis_comment *ov_comment(OggVorbis_File *vf,int link){ + if(vf->seekable){ + if(link>=vf->links)return NULL; + if(link>=0){ + int ret=_set_link_number_preserve_pos(vf,link); + if(ret)return NULL; + } + } + return &vf->vc; +} + +/* up to this point, everything could more or less hide the multiple + logical bitstream nature of chaining from the toplevel application + if the toplevel application didn't particularly care. However, at + the point that we actually read audio back, the multiple-section + nature must surface: Multiple bitstream sections do not necessarily + have to have the same number of channels or sampling rate. + + ov_read returns the sequential logical bitstream number currently + being decoded along with the PCM data in order that the toplevel + application can take action on channel/sample rate changes. This + number will be incremented even for streamed (non-seekable) streams + (for seekable streams, it represents the actual logical bitstream + index within the physical bitstream. Note that the accessor + functions above are aware of this dichotomy). + + input values: buffer) a buffer to hold packed PCM data for return + length) the byte length requested to be placed into buffer + + return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL) + 0) EOF + n) number of bytes of PCM actually returned. The + below works on a packet-by-packet basis, so the + return length is not related to the 'length' passed + in, just guaranteed to fit. + + *section) set to the logical bitstream number */ + +long ov_read(OggVorbis_File *vf,void *buffer,int bytes_req,int *bitstream){ + + long samples; + long channels; + + if(vf->ready_stateready_state==INITSET){ + channels=vf->vi.channels; + samples=vorbis_dsp_pcmout(vf->vd,buffer,(bytes_req>>1)/channels); + if(samples){ + if(samples>0){ + vorbis_dsp_read(vf->vd,samples); + vf->pcm_offset+=samples; + if(bitstream)*bitstream=vf->current_link; + return samples*2*channels; + } + return samples; + } + } + + /* suck in another packet */ + { + int ret=_fetch_and_process_packet(vf,1,1); + if(ret==OV_EOF) + return 0; + if(ret<=0) + return ret; + } + + } +} diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/window_lookup.h b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/window_lookup.h new file mode 100644 index 0000000..db3593d --- /dev/null +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/window_lookup.h @@ -0,0 +1,2107 @@ +/************************************************************************ + * Copyright (C) 2002-2009, Xiph.org Foundation + * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the names of the Xiph.org Foundation nor Pinknoise + * Productions Ltd nor the names of its contributors may be used to + * endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + ************************************************************************ + + function: window lookup tables + + ************************************************************************/ + + +#include "os_types.h" + +static LOOKUP_T vwin64[32] = { + X(0x001f0003), X(0x01168c98), X(0x030333c8), X(0x05dfe3a4), + X(0x09a49562), X(0x0e45df18), X(0x13b47ef2), X(0x19dcf676), + X(0x20a74d83), X(0x27f7137c), X(0x2fabb05a), X(0x37a1105a), + X(0x3fb0ab28), X(0x47b2dcd1), X(0x4f807bc6), X(0x56f48e70), + X(0x5dedfc79), X(0x64511653), X(0x6a08cfff), X(0x6f079328), + X(0x734796f4), X(0x76cab7f2), X(0x7999d6e8), X(0x7bc3cf9f), + X(0x7d5c20c1), X(0x7e7961df), X(0x7f33a567), X(0x7fa2e1d0), + X(0x7fdd78a5), X(0x7ff6ec6d), X(0x7ffed0e9), X(0x7ffffc3f), +}; + +static LOOKUP_T vwin128[64] = { + X(0x0007c04d), X(0x0045bb89), X(0x00c18b87), X(0x017ae294), + X(0x02714a4e), X(0x03a4217a), X(0x05129952), X(0x06bbb24f), + X(0x089e38a1), X(0x0ab8c073), X(0x0d09a228), X(0x0f8ef6bd), + X(0x12469488), X(0x152e0c7a), X(0x1842a81c), X(0x1b81686d), + X(0x1ee705d9), X(0x226ff15d), X(0x26185705), X(0x29dc21cc), + X(0x2db700fe), X(0x31a46f08), X(0x359fb9c1), X(0x39a40c0c), + X(0x3dac78b6), X(0x41b40674), X(0x45b5bcb0), X(0x49acb109), + X(0x4d94152b), X(0x516744bd), X(0x5521d320), X(0x58bf98a5), + X(0x5c3cbef4), X(0x5f95cc5d), X(0x62c7add7), X(0x65cfbf64), + X(0x68abd2ba), X(0x6b5a3405), X(0x6dd9acab), X(0x7029840d), + X(0x72497e38), X(0x7439d8ac), X(0x75fb4532), X(0x778ee30a), + X(0x78f6367e), X(0x7a331f1a), X(0x7b47cccd), X(0x7c36b416), + X(0x7d028192), X(0x7dae0d18), X(0x7e3c4caa), X(0x7eb04763), + X(0x7f0d08a7), X(0x7f5593b7), X(0x7f8cd7d5), X(0x7fb5a513), + X(0x7fd2a1fc), X(0x7fe64212), X(0x7ff2bd4c), X(0x7ffa0890), + X(0x7ffdcf39), X(0x7fff6dac), X(0x7fffed01), X(0x7fffffc4), +}; + +static LOOKUP_T vwin256[128] = { + X(0x0001f018), X(0x00117066), X(0x00306e9e), X(0x005ee5f1), + X(0x009ccf26), X(0x00ea208b), X(0x0146cdea), X(0x01b2c87f), + X(0x022dfedf), X(0x02b85ced), X(0x0351cbbd), X(0x03fa317f), + X(0x04b17167), X(0x05776b90), X(0x064bfcdc), X(0x072efedd), + X(0x082047b4), X(0x091fa9f1), X(0x0a2cf477), X(0x0b47f25d), + X(0x0c706ad2), X(0x0da620ff), X(0x0ee8d3ef), X(0x10383e75), + X(0x11941716), X(0x12fc0ff6), X(0x146fd6c8), X(0x15ef14c2), + X(0x17796e8e), X(0x190e844f), X(0x1aadf196), X(0x1c574d6e), + X(0x1e0a2a62), X(0x1fc61688), X(0x218a9b9c), X(0x23573f12), + X(0x252b823d), X(0x2706e269), X(0x28e8d913), X(0x2ad0dc0e), + X(0x2cbe5dc1), X(0x2eb0cd60), X(0x30a79733), X(0x32a224d5), + X(0x349fdd8b), X(0x36a02690), X(0x38a2636f), X(0x3aa5f65e), + X(0x3caa409e), X(0x3eaea2df), X(0x40b27da6), X(0x42b531b8), + X(0x44b62086), X(0x46b4ac99), X(0x48b03a05), X(0x4aa82ed5), + X(0x4c9bf37d), X(0x4e8af349), X(0x50749ccb), X(0x52586246), + X(0x5435ba1c), X(0x560c1f31), X(0x57db1152), X(0x59a21591), + X(0x5b60b6a3), X(0x5d168535), X(0x5ec31839), X(0x60660d36), + X(0x61ff0886), X(0x638db595), X(0x6511c717), X(0x668af734), + X(0x67f907b0), X(0x695bc207), X(0x6ab2f787), X(0x6bfe815a), + X(0x6d3e4090), X(0x6e721e16), X(0x6f9a0ab5), X(0x70b5fef8), + X(0x71c5fb16), X(0x72ca06cd), X(0x73c2313d), X(0x74ae90b2), + X(0x758f4275), X(0x76646a85), X(0x772e335c), X(0x77eccda0), + X(0x78a06fd7), X(0x79495613), X(0x79e7c19c), X(0x7a7bf894), + X(0x7b064596), X(0x7b86f757), X(0x7bfe6044), X(0x7c6cd615), + X(0x7cd2b16e), X(0x7d304d71), X(0x7d860756), X(0x7dd43e06), + X(0x7e1b51ad), X(0x7e5ba355), X(0x7e95947e), X(0x7ec986bb), + X(0x7ef7db4a), X(0x7f20f2b9), X(0x7f452c7f), X(0x7f64e6a7), + X(0x7f807d71), X(0x7f984aff), X(0x7faca700), X(0x7fbde662), + X(0x7fcc5b04), X(0x7fd85372), X(0x7fe21a99), X(0x7fe9f791), + X(0x7ff02d58), X(0x7ff4fa9e), X(0x7ff89990), X(0x7ffb3faa), + X(0x7ffd1d8b), X(0x7ffe5ecc), X(0x7fff29e0), X(0x7fff9ff3), + X(0x7fffdcd2), X(0x7ffff6d6), X(0x7ffffed0), X(0x7ffffffc), +}; + +static LOOKUP_T vwin512[256] = { + X(0x00007c06), X(0x00045c32), X(0x000c1c62), X(0x0017bc4c), + X(0x00273b7a), X(0x003a9955), X(0x0051d51c), X(0x006cede7), + X(0x008be2a9), X(0x00aeb22a), X(0x00d55b0d), X(0x00ffdbcc), + X(0x012e32b6), X(0x01605df5), X(0x01965b85), X(0x01d02939), + X(0x020dc4ba), X(0x024f2b83), X(0x02945ae6), X(0x02dd5004), + X(0x032a07d3), X(0x037a7f19), X(0x03ceb26e), X(0x04269e37), + X(0x04823eab), X(0x04e18fcc), X(0x05448d6d), X(0x05ab3329), + X(0x06157c68), X(0x0683645e), X(0x06f4e607), X(0x0769fc25), + X(0x07e2a146), X(0x085ecfbc), X(0x08de819f), X(0x0961b0cc), + X(0x09e856e3), X(0x0a726d46), X(0x0affed1d), X(0x0b90cf4c), + X(0x0c250c79), X(0x0cbc9d0b), X(0x0d577926), X(0x0df598aa), + X(0x0e96f337), X(0x0f3b8026), X(0x0fe3368f), X(0x108e0d42), + X(0x113bfaca), X(0x11ecf56b), X(0x12a0f324), X(0x1357e9ac), + X(0x1411ce70), X(0x14ce9698), X(0x158e3702), X(0x1650a444), + X(0x1715d2aa), X(0x17ddb638), X(0x18a842aa), X(0x19756b72), + X(0x1a4523b9), X(0x1b175e62), X(0x1bec0e04), X(0x1cc324f0), + X(0x1d9c9532), X(0x1e78508a), X(0x1f564876), X(0x20366e2e), + X(0x2118b2a2), X(0x21fd0681), X(0x22e35a37), X(0x23cb9dee), + X(0x24b5c18e), X(0x25a1b4c0), X(0x268f66f1), X(0x277ec74e), + X(0x286fc4cc), X(0x29624e23), X(0x2a5651d7), X(0x2b4bbe34), + X(0x2c428150), X(0x2d3a8913), X(0x2e33c332), X(0x2f2e1d35), + X(0x30298478), X(0x3125e62d), X(0x32232f61), X(0x33214cfc), + X(0x34202bc2), X(0x351fb85a), X(0x361fdf4f), X(0x37208d10), + X(0x3821adf7), X(0x39232e49), X(0x3a24fa3c), X(0x3b26fdf6), + X(0x3c292593), X(0x3d2b5d29), X(0x3e2d90c8), X(0x3f2fac7f), + X(0x40319c5f), X(0x41334c81), X(0x4234a905), X(0x43359e16), + X(0x443617f3), X(0x453602eb), X(0x46354b65), X(0x4733dde1), + X(0x4831a6ff), X(0x492e937f), X(0x4a2a9045), X(0x4b258a5f), + X(0x4c1f6f06), X(0x4d182ba2), X(0x4e0fadce), X(0x4f05e35b), + X(0x4ffaba53), X(0x50ee20fd), X(0x51e005e1), X(0x52d057ca), + X(0x53bf05ca), X(0x54abff3b), X(0x559733c7), X(0x56809365), + X(0x57680e62), X(0x584d955d), X(0x59311952), X(0x5a128b96), + X(0x5af1dddd), X(0x5bcf023a), X(0x5ca9eb27), X(0x5d828b81), + X(0x5e58d68d), X(0x5f2cbffc), X(0x5ffe3be9), X(0x60cd3edf), + X(0x6199bdda), X(0x6263ae45), X(0x632b0602), X(0x63efbb66), + X(0x64b1c53f), X(0x65711ad0), X(0x662db3d7), X(0x66e7888d), + X(0x679e91a5), X(0x6852c84e), X(0x69042635), X(0x69b2a582), + X(0x6a5e40dd), X(0x6b06f36c), X(0x6bacb8d2), X(0x6c4f8d30), + X(0x6cef6d26), X(0x6d8c55d4), X(0x6e2644d4), X(0x6ebd3840), + X(0x6f512ead), X(0x6fe2272e), X(0x7070214f), X(0x70fb1d17), + X(0x71831b06), X(0x72081c16), X(0x728a21b5), X(0x73092dc8), + X(0x738542a6), X(0x73fe631b), X(0x74749261), X(0x74e7d421), + X(0x75582c72), X(0x75c59fd5), X(0x76303333), X(0x7697ebdd), + X(0x76fccf85), X(0x775ee443), X(0x77be308a), X(0x781abb2e), + X(0x78748b59), X(0x78cba88e), X(0x79201aa7), X(0x7971e9cd), + X(0x79c11e79), X(0x7a0dc170), X(0x7a57dbc2), X(0x7a9f76c1), + X(0x7ae49c07), X(0x7b27556b), X(0x7b67ad02), X(0x7ba5ad1b), + X(0x7be1603a), X(0x7c1ad118), X(0x7c520a9e), X(0x7c8717e1), + X(0x7cba0421), X(0x7ceadac3), X(0x7d19a74f), X(0x7d46756e), + X(0x7d7150e5), X(0x7d9a4592), X(0x7dc15f69), X(0x7de6aa71), + X(0x7e0a32c0), X(0x7e2c0479), X(0x7e4c2bc7), X(0x7e6ab4db), + X(0x7e87abe9), X(0x7ea31d24), X(0x7ebd14be), X(0x7ed59edd), + X(0x7eecc7a3), X(0x7f029b21), X(0x7f17255a), X(0x7f2a723f), + X(0x7f3c8daa), X(0x7f4d835d), X(0x7f5d5f00), X(0x7f6c2c1b), + X(0x7f79f617), X(0x7f86c83a), X(0x7f92ada2), X(0x7f9db146), + X(0x7fa7ddf3), X(0x7fb13e46), X(0x7fb9dcb0), X(0x7fc1c36c), + X(0x7fc8fc83), X(0x7fcf91c7), X(0x7fd58cd2), X(0x7fdaf702), + X(0x7fdfd979), X(0x7fe43d1c), X(0x7fe82a8b), X(0x7febaa29), + X(0x7feec412), X(0x7ff1801c), X(0x7ff3e5d6), X(0x7ff5fc86), + X(0x7ff7cb29), X(0x7ff9586f), X(0x7ffaaaba), X(0x7ffbc81e), + X(0x7ffcb660), X(0x7ffd7af3), X(0x7ffe1afa), X(0x7ffe9b42), + X(0x7fff0047), X(0x7fff4e2f), X(0x7fff88c9), X(0x7fffb390), + X(0x7fffd1a6), X(0x7fffe5d7), X(0x7ffff296), X(0x7ffff9fd), + X(0x7ffffdcd), X(0x7fffff6d), X(0x7fffffed), X(0x7fffffff), +}; + +static LOOKUP_T vwin1024[512] = { + X(0x00001f02), X(0x0001170e), X(0x00030724), X(0x0005ef40), + X(0x0009cf59), X(0x000ea767), X(0x0014775e), X(0x001b3f2e), + X(0x0022fec8), X(0x002bb618), X(0x00356508), X(0x00400b81), + X(0x004ba968), X(0x00583ea0), X(0x0065cb0a), X(0x00744e84), + X(0x0083c8ea), X(0x00943a14), X(0x00a5a1da), X(0x00b80010), + X(0x00cb5488), X(0x00df9f10), X(0x00f4df76), X(0x010b1584), + X(0x01224101), X(0x013a61b2), X(0x01537759), X(0x016d81b6), + X(0x01888087), X(0x01a47385), X(0x01c15a69), X(0x01df34e6), + X(0x01fe02b1), X(0x021dc377), X(0x023e76e7), X(0x02601ca9), + X(0x0282b466), X(0x02a63dc1), X(0x02cab85d), X(0x02f023d6), + X(0x03167fcb), X(0x033dcbd3), X(0x03660783), X(0x038f3270), + X(0x03b94c29), X(0x03e4543a), X(0x04104a2e), X(0x043d2d8b), + X(0x046afdd5), X(0x0499ba8c), X(0x04c9632d), X(0x04f9f734), + X(0x052b7615), X(0x055ddf46), X(0x05913237), X(0x05c56e53), + X(0x05fa9306), X(0x06309fb6), X(0x066793c5), X(0x069f6e93), + X(0x06d82f7c), X(0x0711d5d9), X(0x074c60fe), X(0x0787d03d), + X(0x07c422e4), X(0x0801583e), X(0x083f6f91), X(0x087e681f), + X(0x08be4129), X(0x08fef9ea), X(0x0940919a), X(0x0983076d), + X(0x09c65a92), X(0x0a0a8a38), X(0x0a4f9585), X(0x0a957b9f), + X(0x0adc3ba7), X(0x0b23d4b9), X(0x0b6c45ee), X(0x0bb58e5a), + X(0x0bffad0f), X(0x0c4aa11a), X(0x0c966982), X(0x0ce3054d), + X(0x0d30737b), X(0x0d7eb308), X(0x0dcdc2eb), X(0x0e1da21a), + X(0x0e6e4f83), X(0x0ebfca11), X(0x0f1210ad), X(0x0f652238), + X(0x0fb8fd91), X(0x100da192), X(0x10630d11), X(0x10b93ee0), + X(0x111035cb), X(0x1167f09a), X(0x11c06e13), X(0x1219acf5), + X(0x1273abfb), X(0x12ce69db), X(0x1329e54a), X(0x13861cf3), + X(0x13e30f80), X(0x1440bb97), X(0x149f1fd8), X(0x14fe3ade), + X(0x155e0b40), X(0x15be8f92), X(0x161fc662), X(0x1681ae38), + X(0x16e4459b), X(0x17478b0b), X(0x17ab7d03), X(0x181019fb), + X(0x18756067), X(0x18db4eb3), X(0x1941e34a), X(0x19a91c92), + X(0x1a10f8ea), X(0x1a7976af), X(0x1ae29439), X(0x1b4c4fda), + X(0x1bb6a7e2), X(0x1c219a9a), X(0x1c8d2649), X(0x1cf9492e), + X(0x1d660188), X(0x1dd34d8e), X(0x1e412b74), X(0x1eaf996a), + X(0x1f1e959b), X(0x1f8e1e2f), X(0x1ffe3146), X(0x206ecd01), + X(0x20dfef78), X(0x215196c2), X(0x21c3c0f0), X(0x22366c10), + X(0x22a9962a), X(0x231d3d45), X(0x23915f60), X(0x2405fa7a), + X(0x247b0c8c), X(0x24f09389), X(0x25668d65), X(0x25dcf80c), + X(0x2653d167), X(0x26cb175e), X(0x2742c7d0), X(0x27bae09e), + X(0x28335fa2), X(0x28ac42b3), X(0x292587a5), X(0x299f2c48), + X(0x2a192e69), X(0x2a938bd1), X(0x2b0e4247), X(0x2b894f8d), + X(0x2c04b164), X(0x2c806588), X(0x2cfc69b2), X(0x2d78bb9a), + X(0x2df558f4), X(0x2e723f6f), X(0x2eef6cbb), X(0x2f6cde83), + X(0x2fea9270), X(0x30688627), X(0x30e6b74e), X(0x31652385), + X(0x31e3c86b), X(0x3262a39e), X(0x32e1b2b8), X(0x3360f352), + X(0x33e06303), X(0x345fff5e), X(0x34dfc5f8), X(0x355fb462), + X(0x35dfc82a), X(0x365ffee0), X(0x36e0560f), X(0x3760cb43), + X(0x37e15c05), X(0x386205df), X(0x38e2c657), X(0x39639af5), + X(0x39e4813e), X(0x3a6576b6), X(0x3ae678e3), X(0x3b678547), + X(0x3be89965), X(0x3c69b2c1), X(0x3ceacedc), X(0x3d6beb37), + X(0x3ded0557), X(0x3e6e1abb), X(0x3eef28e6), X(0x3f702d5a), + X(0x3ff1259a), X(0x40720f29), X(0x40f2e789), X(0x4173ac3f), + X(0x41f45ad0), X(0x4274f0c2), X(0x42f56b9a), X(0x4375c8e0), + X(0x43f6061d), X(0x447620db), X(0x44f616a5), X(0x4575e509), + X(0x45f58994), X(0x467501d6), X(0x46f44b62), X(0x477363cb), + X(0x47f248a6), X(0x4870f78e), X(0x48ef6e1a), X(0x496da9e8), + X(0x49eba897), X(0x4a6967c8), X(0x4ae6e521), X(0x4b641e47), + X(0x4be110e5), X(0x4c5dbaa7), X(0x4cda193f), X(0x4d562a5f), + X(0x4dd1ebbd), X(0x4e4d5b15), X(0x4ec87623), X(0x4f433aa9), + X(0x4fbda66c), X(0x5037b734), X(0x50b16acf), X(0x512abf0e), + X(0x51a3b1c5), X(0x521c40ce), X(0x52946a06), X(0x530c2b50), + X(0x53838292), X(0x53fa6db8), X(0x5470eab3), X(0x54e6f776), + X(0x555c91fc), X(0x55d1b844), X(0x56466851), X(0x56baa02f), + X(0x572e5deb), X(0x57a19f98), X(0x58146352), X(0x5886a737), + X(0x58f8696d), X(0x5969a81c), X(0x59da6177), X(0x5a4a93b4), + X(0x5aba3d0f), X(0x5b295bcb), X(0x5b97ee30), X(0x5c05f28d), + X(0x5c736738), X(0x5ce04a8d), X(0x5d4c9aed), X(0x5db856c1), + X(0x5e237c78), X(0x5e8e0a89), X(0x5ef7ff6f), X(0x5f6159b0), + X(0x5fca17d4), X(0x6032386e), X(0x6099ba15), X(0x61009b69), + X(0x6166db11), X(0x61cc77b9), X(0x62317017), X(0x6295c2e7), + X(0x62f96eec), X(0x635c72f1), X(0x63becdc8), X(0x64207e4b), + X(0x6481835a), X(0x64e1dbde), X(0x654186c8), X(0x65a0830e), + X(0x65fecfb1), X(0x665c6bb7), X(0x66b95630), X(0x67158e30), + X(0x677112d7), X(0x67cbe34b), X(0x6825feb9), X(0x687f6456), + X(0x68d81361), X(0x69300b1e), X(0x69874ada), X(0x69ddd1ea), + X(0x6a339fab), X(0x6a88b382), X(0x6add0cdb), X(0x6b30ab2a), + X(0x6b838dec), X(0x6bd5b4a6), X(0x6c271ee2), X(0x6c77cc36), + X(0x6cc7bc3d), X(0x6d16ee9b), X(0x6d6562fb), X(0x6db31911), + X(0x6e001099), X(0x6e4c4955), X(0x6e97c311), X(0x6ee27d9f), + X(0x6f2c78d9), X(0x6f75b4a2), X(0x6fbe30e4), X(0x7005ed91), + X(0x704ceaa1), X(0x70932816), X(0x70d8a5f8), X(0x711d6457), + X(0x7161634b), X(0x71a4a2f3), X(0x71e72375), X(0x7228e500), + X(0x7269e7c8), X(0x72aa2c0a), X(0x72e9b209), X(0x73287a12), + X(0x73668476), X(0x73a3d18f), X(0x73e061bc), X(0x741c3566), + X(0x74574cfa), X(0x7491a8ee), X(0x74cb49be), X(0x75042fec), + X(0x753c5c03), X(0x7573ce92), X(0x75aa882f), X(0x75e08979), + X(0x7615d313), X(0x764a65a7), X(0x767e41e5), X(0x76b16884), + X(0x76e3da40), X(0x771597dc), X(0x7746a221), X(0x7776f9dd), + X(0x77a69fe6), X(0x77d59514), X(0x7803da49), X(0x7831706a), + X(0x785e5861), X(0x788a9320), X(0x78b6219c), X(0x78e104cf), + X(0x790b3dbb), X(0x7934cd64), X(0x795db4d5), X(0x7985f51d), + X(0x79ad8f50), X(0x79d48486), X(0x79fad5de), X(0x7a208478), + X(0x7a45917b), X(0x7a69fe12), X(0x7a8dcb6c), X(0x7ab0fabb), + X(0x7ad38d36), X(0x7af5841a), X(0x7b16e0a3), X(0x7b37a416), + X(0x7b57cfb8), X(0x7b7764d4), X(0x7b9664b6), X(0x7bb4d0b0), + X(0x7bd2aa14), X(0x7beff23b), X(0x7c0caa7f), X(0x7c28d43c), + X(0x7c4470d2), X(0x7c5f81a5), X(0x7c7a081a), X(0x7c940598), + X(0x7cad7b8b), X(0x7cc66b5e), X(0x7cded680), X(0x7cf6be64), + X(0x7d0e247b), X(0x7d250a3c), X(0x7d3b711c), X(0x7d515a95), + X(0x7d66c822), X(0x7d7bbb3c), X(0x7d903563), X(0x7da43814), + X(0x7db7c4d0), X(0x7dcadd16), X(0x7ddd826a), X(0x7defb64d), + X(0x7e017a44), X(0x7e12cfd3), X(0x7e23b87f), X(0x7e3435cc), + X(0x7e444943), X(0x7e53f467), X(0x7e6338c0), X(0x7e7217d5), + X(0x7e80932b), X(0x7e8eac49), X(0x7e9c64b7), X(0x7ea9bdf8), + X(0x7eb6b994), X(0x7ec35910), X(0x7ecf9def), X(0x7edb89b6), + X(0x7ee71de9), X(0x7ef25c09), X(0x7efd4598), X(0x7f07dc16), + X(0x7f122103), X(0x7f1c15dc), X(0x7f25bc1f), X(0x7f2f1547), + X(0x7f3822cd), X(0x7f40e62b), X(0x7f4960d6), X(0x7f519443), + X(0x7f5981e7), X(0x7f612b31), X(0x7f689191), X(0x7f6fb674), + X(0x7f769b45), X(0x7f7d416c), X(0x7f83aa51), X(0x7f89d757), + X(0x7f8fc9df), X(0x7f958348), X(0x7f9b04ef), X(0x7fa0502e), + X(0x7fa56659), X(0x7faa48c7), X(0x7faef8c7), X(0x7fb377a7), + X(0x7fb7c6b3), X(0x7fbbe732), X(0x7fbfda67), X(0x7fc3a196), + X(0x7fc73dfa), X(0x7fcab0ce), X(0x7fcdfb4a), X(0x7fd11ea0), + X(0x7fd41c00), X(0x7fd6f496), X(0x7fd9a989), X(0x7fdc3bff), + X(0x7fdead17), X(0x7fe0fdee), X(0x7fe32f9d), X(0x7fe54337), + X(0x7fe739ce), X(0x7fe9146c), X(0x7fead41b), X(0x7fec79dd), + X(0x7fee06b2), X(0x7fef7b94), X(0x7ff0d97b), X(0x7ff22158), + X(0x7ff35417), X(0x7ff472a3), X(0x7ff57de0), X(0x7ff676ac), + X(0x7ff75de3), X(0x7ff8345a), X(0x7ff8fae4), X(0x7ff9b24b), + X(0x7ffa5b58), X(0x7ffaf6cd), X(0x7ffb8568), X(0x7ffc07e2), + X(0x7ffc7eed), X(0x7ffceb38), X(0x7ffd4d6d), X(0x7ffda631), + X(0x7ffdf621), X(0x7ffe3dd8), X(0x7ffe7dea), X(0x7ffeb6e7), + X(0x7ffee959), X(0x7fff15c4), X(0x7fff3ca9), X(0x7fff5e80), + X(0x7fff7bc0), X(0x7fff94d6), X(0x7fffaa2d), X(0x7fffbc29), + X(0x7fffcb29), X(0x7fffd786), X(0x7fffe195), X(0x7fffe9a3), + X(0x7fffeffa), X(0x7ffff4dd), X(0x7ffff889), X(0x7ffffb37), + X(0x7ffffd1a), X(0x7ffffe5d), X(0x7fffff29), X(0x7fffffa0), + X(0x7fffffdd), X(0x7ffffff7), X(0x7fffffff), X(0x7fffffff), +}; + +static LOOKUP_T vwin2048[1024] = { + X(0x000007c0), X(0x000045c4), X(0x0000c1ca), X(0x00017bd3), + X(0x000273de), X(0x0003a9eb), X(0x00051df9), X(0x0006d007), + X(0x0008c014), X(0x000aee1e), X(0x000d5a25), X(0x00100428), + X(0x0012ec23), X(0x00161216), X(0x001975fe), X(0x001d17da), + X(0x0020f7a8), X(0x00251564), X(0x0029710c), X(0x002e0a9e), + X(0x0032e217), X(0x0037f773), X(0x003d4ab0), X(0x0042dbca), + X(0x0048aabe), X(0x004eb788), X(0x00550224), X(0x005b8a8f), + X(0x006250c5), X(0x006954c1), X(0x0070967e), X(0x007815f9), + X(0x007fd32c), X(0x0087ce13), X(0x009006a9), X(0x00987ce9), + X(0x00a130cc), X(0x00aa224f), X(0x00b3516b), X(0x00bcbe1a), + X(0x00c66856), X(0x00d0501a), X(0x00da755f), X(0x00e4d81f), + X(0x00ef7853), X(0x00fa55f4), X(0x010570fc), X(0x0110c963), + X(0x011c5f22), X(0x01283232), X(0x0134428c), X(0x01409027), + X(0x014d1afb), X(0x0159e302), X(0x0166e831), X(0x01742a82), + X(0x0181a9ec), X(0x018f6665), X(0x019d5fe5), X(0x01ab9663), + X(0x01ba09d6), X(0x01c8ba34), X(0x01d7a775), X(0x01e6d18d), + X(0x01f63873), X(0x0205dc1e), X(0x0215bc82), X(0x0225d997), + X(0x02363350), X(0x0246c9a3), X(0x02579c86), X(0x0268abed), + X(0x0279f7cc), X(0x028b801a), X(0x029d44c9), X(0x02af45ce), + X(0x02c1831d), X(0x02d3fcaa), X(0x02e6b269), X(0x02f9a44c), + X(0x030cd248), X(0x03203c4f), X(0x0333e255), X(0x0347c44b), + X(0x035be225), X(0x03703bd5), X(0x0384d14d), X(0x0399a280), + X(0x03aeaf5e), X(0x03c3f7d9), X(0x03d97be4), X(0x03ef3b6e), + X(0x0405366a), X(0x041b6cc8), X(0x0431de78), X(0x04488b6c), + X(0x045f7393), X(0x047696dd), X(0x048df53b), X(0x04a58e9b), + X(0x04bd62ee), X(0x04d57223), X(0x04edbc28), X(0x050640ed), + X(0x051f0060), X(0x0537fa70), X(0x05512f0a), X(0x056a9e1e), + X(0x05844798), X(0x059e2b67), X(0x05b84978), X(0x05d2a1b8), + X(0x05ed3414), X(0x06080079), X(0x062306d3), X(0x063e470f), + X(0x0659c119), X(0x067574dd), X(0x06916247), X(0x06ad8941), + X(0x06c9e9b8), X(0x06e68397), X(0x070356c8), X(0x07206336), + X(0x073da8cb), X(0x075b2772), X(0x0778df15), X(0x0796cf9c), + X(0x07b4f8f3), X(0x07d35b01), X(0x07f1f5b1), X(0x0810c8eb), + X(0x082fd497), X(0x084f189e), X(0x086e94e9), X(0x088e495e), + X(0x08ae35e6), X(0x08ce5a68), X(0x08eeb6cc), X(0x090f4af8), + X(0x093016d3), X(0x09511a44), X(0x09725530), X(0x0993c77f), + X(0x09b57115), X(0x09d751d8), X(0x09f969ae), X(0x0a1bb87c), + X(0x0a3e3e26), X(0x0a60fa91), X(0x0a83eda2), X(0x0aa7173c), + X(0x0aca7743), X(0x0aee0d9b), X(0x0b11da28), X(0x0b35dccc), + X(0x0b5a156a), X(0x0b7e83e5), X(0x0ba3281f), X(0x0bc801fa), + X(0x0bed1159), X(0x0c12561c), X(0x0c37d025), X(0x0c5d7f55), + X(0x0c83638d), X(0x0ca97cae), X(0x0ccfca97), X(0x0cf64d2a), + X(0x0d1d0444), X(0x0d43efc7), X(0x0d6b0f92), X(0x0d926383), + X(0x0db9eb79), X(0x0de1a752), X(0x0e0996ee), X(0x0e31ba29), + X(0x0e5a10e2), X(0x0e829af6), X(0x0eab5841), X(0x0ed448a2), + X(0x0efd6bf4), X(0x0f26c214), X(0x0f504ade), X(0x0f7a062e), + X(0x0fa3f3df), X(0x0fce13cd), X(0x0ff865d2), X(0x1022e9ca), + X(0x104d9f8e), X(0x107886f9), X(0x10a39fe5), X(0x10ceea2c), + X(0x10fa65a6), X(0x1126122d), X(0x1151ef9a), X(0x117dfdc5), + X(0x11aa3c87), X(0x11d6abb6), X(0x12034b2c), X(0x12301ac0), + X(0x125d1a48), X(0x128a499b), X(0x12b7a891), X(0x12e536ff), + X(0x1312f4bb), X(0x1340e19c), X(0x136efd75), X(0x139d481e), + X(0x13cbc16a), X(0x13fa692f), X(0x14293f40), X(0x14584371), + X(0x14877597), X(0x14b6d585), X(0x14e6630d), X(0x15161e04), + X(0x1546063b), X(0x15761b85), X(0x15a65db3), X(0x15d6cc99), + X(0x16076806), X(0x16382fcd), X(0x166923bf), X(0x169a43ab), + X(0x16cb8f62), X(0x16fd06b5), X(0x172ea973), X(0x1760776b), + X(0x1792706e), X(0x17c49449), X(0x17f6e2cb), X(0x18295bc3), + X(0x185bfeff), X(0x188ecc4c), X(0x18c1c379), X(0x18f4e452), + X(0x19282ea4), X(0x195ba23c), X(0x198f3ee6), X(0x19c3046e), + X(0x19f6f2a1), X(0x1a2b094a), X(0x1a5f4833), X(0x1a93af28), + X(0x1ac83df3), X(0x1afcf460), X(0x1b31d237), X(0x1b66d744), + X(0x1b9c034e), X(0x1bd15621), X(0x1c06cf84), X(0x1c3c6f40), + X(0x1c72351e), X(0x1ca820e6), X(0x1cde3260), X(0x1d146953), + X(0x1d4ac587), X(0x1d8146c3), X(0x1db7eccd), X(0x1deeb76c), + X(0x1e25a667), X(0x1e5cb982), X(0x1e93f085), X(0x1ecb4b33), + X(0x1f02c953), X(0x1f3a6aaa), X(0x1f722efb), X(0x1faa160b), + X(0x1fe21f9e), X(0x201a4b79), X(0x2052995d), X(0x208b0910), + X(0x20c39a53), X(0x20fc4cea), X(0x21352097), X(0x216e151c), + X(0x21a72a3a), X(0x21e05fb5), X(0x2219b54d), X(0x22532ac3), + X(0x228cbfd8), X(0x22c6744d), X(0x230047e2), X(0x233a3a58), + X(0x23744b6d), X(0x23ae7ae3), X(0x23e8c878), X(0x242333ec), + X(0x245dbcfd), X(0x24986369), X(0x24d326f1), X(0x250e0750), + X(0x25490446), X(0x25841d90), X(0x25bf52ec), X(0x25faa417), + X(0x263610cd), X(0x267198cc), X(0x26ad3bcf), X(0x26e8f994), + X(0x2724d1d6), X(0x2760c451), X(0x279cd0c0), X(0x27d8f6e0), + X(0x2815366a), X(0x28518f1b), X(0x288e00ac), X(0x28ca8ad8), + X(0x29072d5a), X(0x2943e7eb), X(0x2980ba45), X(0x29bda422), + X(0x29faa53c), X(0x2a37bd4a), X(0x2a74ec07), X(0x2ab2312b), + X(0x2aef8c6f), X(0x2b2cfd8b), X(0x2b6a8437), X(0x2ba8202c), + X(0x2be5d120), X(0x2c2396cc), X(0x2c6170e7), X(0x2c9f5f29), + X(0x2cdd6147), X(0x2d1b76fa), X(0x2d599ff7), X(0x2d97dbf5), + X(0x2dd62aab), X(0x2e148bcf), X(0x2e52ff16), X(0x2e918436), + X(0x2ed01ae5), X(0x2f0ec2d9), X(0x2f4d7bc6), X(0x2f8c4562), + X(0x2fcb1f62), X(0x300a097a), X(0x3049035f), X(0x30880cc6), + X(0x30c72563), X(0x31064cea), X(0x3145830f), X(0x3184c786), + X(0x31c41a03), X(0x32037a39), X(0x3242e7dc), X(0x3282629f), + X(0x32c1ea36), X(0x33017e53), X(0x33411ea9), X(0x3380caec), + X(0x33c082ce), X(0x34004602), X(0x34401439), X(0x347fed27), + X(0x34bfd07e), X(0x34ffbdf0), X(0x353fb52e), X(0x357fb5ec), + X(0x35bfbfda), X(0x35ffd2aa), X(0x363fee0f), X(0x368011b9), + X(0x36c03d5a), X(0x370070a4), X(0x3740ab48), X(0x3780ecf7), + X(0x37c13562), X(0x3801843a), X(0x3841d931), X(0x388233f7), + X(0x38c2943d), X(0x3902f9b4), X(0x3943640d), X(0x3983d2f8), + X(0x39c44626), X(0x3a04bd48), X(0x3a45380e), X(0x3a85b62a), + X(0x3ac6374a), X(0x3b06bb20), X(0x3b47415c), X(0x3b87c9ae), + X(0x3bc853c7), X(0x3c08df57), X(0x3c496c0f), X(0x3c89f99f), + X(0x3cca87b6), X(0x3d0b1605), X(0x3d4ba43d), X(0x3d8c320e), + X(0x3dccbf27), X(0x3e0d4b3a), X(0x3e4dd5f6), X(0x3e8e5f0c), + X(0x3ecee62b), X(0x3f0f6b05), X(0x3f4fed49), X(0x3f906ca8), + X(0x3fd0e8d2), X(0x40116177), X(0x4051d648), X(0x409246f6), + X(0x40d2b330), X(0x41131aa7), X(0x41537d0c), X(0x4193da10), + X(0x41d43162), X(0x421482b4), X(0x4254cdb7), X(0x4295121b), + X(0x42d54f91), X(0x431585ca), X(0x4355b477), X(0x4395db49), + X(0x43d5f9f1), X(0x44161021), X(0x44561d8a), X(0x449621dd), + X(0x44d61ccc), X(0x45160e08), X(0x4555f544), X(0x4595d230), + X(0x45d5a47f), X(0x46156be3), X(0x4655280e), X(0x4694d8b2), + X(0x46d47d82), X(0x4714162f), X(0x4753a26d), X(0x479321ef), + X(0x47d29466), X(0x4811f987), X(0x48515104), X(0x48909a91), + X(0x48cfd5e1), X(0x490f02a7), X(0x494e2098), X(0x498d2f66), + X(0x49cc2ec7), X(0x4a0b1e6f), X(0x4a49fe11), X(0x4a88cd62), + X(0x4ac78c18), X(0x4b0639e6), X(0x4b44d683), X(0x4b8361a2), + X(0x4bc1dafa), X(0x4c004241), X(0x4c3e972c), X(0x4c7cd970), + X(0x4cbb08c5), X(0x4cf924e1), X(0x4d372d7a), X(0x4d752247), + X(0x4db30300), X(0x4df0cf5a), X(0x4e2e870f), X(0x4e6c29d6), + X(0x4ea9b766), X(0x4ee72f78), X(0x4f2491c4), X(0x4f61de02), + X(0x4f9f13ec), X(0x4fdc333b), X(0x50193ba8), X(0x50562ced), + X(0x509306c3), X(0x50cfc8e5), X(0x510c730d), X(0x514904f6), + X(0x51857e5a), X(0x51c1def5), X(0x51fe2682), X(0x523a54bc), + X(0x52766961), X(0x52b2642c), X(0x52ee44d9), X(0x532a0b26), + X(0x5365b6d0), X(0x53a14793), X(0x53dcbd2f), X(0x54181760), + X(0x545355e5), X(0x548e787d), X(0x54c97ee6), X(0x550468e1), + X(0x553f362c), X(0x5579e687), X(0x55b479b3), X(0x55eeef70), + X(0x5629477f), X(0x566381a1), X(0x569d9d97), X(0x56d79b24), + X(0x57117a0a), X(0x574b3a0a), X(0x5784dae9), X(0x57be5c69), + X(0x57f7be4d), X(0x5831005a), X(0x586a2254), X(0x58a32400), + X(0x58dc0522), X(0x5914c57f), X(0x594d64de), X(0x5985e305), + X(0x59be3fba), X(0x59f67ac3), X(0x5a2e93e9), X(0x5a668af2), + X(0x5a9e5fa6), X(0x5ad611ce), X(0x5b0da133), X(0x5b450d9d), + X(0x5b7c56d7), X(0x5bb37ca9), X(0x5bea7ede), X(0x5c215d41), + X(0x5c58179d), X(0x5c8eadbe), X(0x5cc51f6f), X(0x5cfb6c7c), + X(0x5d3194b2), X(0x5d6797de), X(0x5d9d75cf), X(0x5dd32e51), + X(0x5e08c132), X(0x5e3e2e43), X(0x5e737551), X(0x5ea8962d), + X(0x5edd90a7), X(0x5f12648e), X(0x5f4711b4), X(0x5f7b97ea), + X(0x5faff702), X(0x5fe42ece), X(0x60183f20), X(0x604c27cc), + X(0x607fe8a6), X(0x60b38180), X(0x60e6f22f), X(0x611a3a89), + X(0x614d5a62), X(0x61805190), X(0x61b31fe9), X(0x61e5c545), + X(0x62184179), X(0x624a945d), X(0x627cbdca), X(0x62aebd98), + X(0x62e0939f), X(0x63123fba), X(0x6343c1c1), X(0x6375198f), + X(0x63a646ff), X(0x63d749ec), X(0x64082232), X(0x6438cfad), + X(0x64695238), X(0x6499a9b3), X(0x64c9d5f9), X(0x64f9d6ea), + X(0x6529ac63), X(0x65595643), X(0x6588d46a), X(0x65b826b8), + X(0x65e74d0e), X(0x6616474b), X(0x66451552), X(0x6673b704), + X(0x66a22c44), X(0x66d074f4), X(0x66fe90f8), X(0x672c8033), + X(0x675a428a), X(0x6787d7e1), X(0x67b5401f), X(0x67e27b27), + X(0x680f88e1), X(0x683c6934), X(0x68691c05), X(0x6895a13e), + X(0x68c1f8c7), X(0x68ee2287), X(0x691a1e68), X(0x6945ec54), + X(0x69718c35), X(0x699cfdf5), X(0x69c8417f), X(0x69f356c0), + X(0x6a1e3da3), X(0x6a48f615), X(0x6a738002), X(0x6a9ddb5a), + X(0x6ac80808), X(0x6af205fd), X(0x6b1bd526), X(0x6b457575), + X(0x6b6ee6d8), X(0x6b982940), X(0x6bc13c9f), X(0x6bea20e5), + X(0x6c12d605), X(0x6c3b5bf1), X(0x6c63b29c), X(0x6c8bd9fb), + X(0x6cb3d200), X(0x6cdb9aa0), X(0x6d0333d0), X(0x6d2a9d86), + X(0x6d51d7b7), X(0x6d78e25a), X(0x6d9fbd67), X(0x6dc668d3), + X(0x6dece498), X(0x6e1330ad), X(0x6e394d0c), X(0x6e5f39ae), + X(0x6e84f68d), X(0x6eaa83a2), X(0x6ecfe0ea), X(0x6ef50e5e), + X(0x6f1a0bfc), X(0x6f3ed9bf), X(0x6f6377a4), X(0x6f87e5a8), + X(0x6fac23c9), X(0x6fd03206), X(0x6ff4105c), X(0x7017becc), + X(0x703b3d54), X(0x705e8bf5), X(0x7081aaaf), X(0x70a49984), + X(0x70c75874), X(0x70e9e783), X(0x710c46b2), X(0x712e7605), + X(0x7150757f), X(0x71724523), X(0x7193e4f6), X(0x71b554fd), + X(0x71d6953e), X(0x71f7a5bd), X(0x72188681), X(0x72393792), + X(0x7259b8f5), X(0x727a0ab2), X(0x729a2cd2), X(0x72ba1f5d), + X(0x72d9e25c), X(0x72f975d8), X(0x7318d9db), X(0x73380e6f), + X(0x735713a0), X(0x7375e978), X(0x73949003), X(0x73b3074c), + X(0x73d14f61), X(0x73ef684f), X(0x740d5222), X(0x742b0ce9), + X(0x744898b1), X(0x7465f589), X(0x74832381), X(0x74a022a8), + X(0x74bcf30e), X(0x74d994c3), X(0x74f607d8), X(0x75124c5f), + X(0x752e6268), X(0x754a4a05), X(0x7566034b), X(0x75818e4a), + X(0x759ceb16), X(0x75b819c4), X(0x75d31a66), X(0x75eded12), + X(0x760891dc), X(0x762308da), X(0x763d5221), X(0x76576dc8), + X(0x76715be4), X(0x768b1c8c), X(0x76a4afd9), X(0x76be15e0), + X(0x76d74ebb), X(0x76f05a82), X(0x7709394d), X(0x7721eb35), + X(0x773a7054), X(0x7752c8c4), X(0x776af49f), X(0x7782f400), + X(0x779ac701), X(0x77b26dbd), X(0x77c9e851), X(0x77e136d8), + X(0x77f8596f), X(0x780f5032), X(0x78261b3f), X(0x783cbab2), + X(0x78532eaa), X(0x78697745), X(0x787f94a0), X(0x789586db), + X(0x78ab4e15), X(0x78c0ea6d), X(0x78d65c03), X(0x78eba2f7), + X(0x7900bf68), X(0x7915b179), X(0x792a7949), X(0x793f16fb), + X(0x79538aaf), X(0x7967d488), X(0x797bf4a8), X(0x798feb31), + X(0x79a3b846), X(0x79b75c0a), X(0x79cad6a1), X(0x79de282e), + X(0x79f150d5), X(0x7a0450bb), X(0x7a172803), X(0x7a29d6d3), + X(0x7a3c5d50), X(0x7a4ebb9f), X(0x7a60f1e6), X(0x7a73004a), + X(0x7a84e6f2), X(0x7a96a604), X(0x7aa83da7), X(0x7ab9ae01), + X(0x7acaf73a), X(0x7adc1979), X(0x7aed14e6), X(0x7afde9a8), + X(0x7b0e97e8), X(0x7b1f1fcd), X(0x7b2f8182), X(0x7b3fbd2d), + X(0x7b4fd2f9), X(0x7b5fc30f), X(0x7b6f8d98), X(0x7b7f32bd), + X(0x7b8eb2a9), X(0x7b9e0d85), X(0x7bad437d), X(0x7bbc54b9), + X(0x7bcb4166), X(0x7bda09ae), X(0x7be8adbc), X(0x7bf72dbc), + X(0x7c0589d8), X(0x7c13c23d), X(0x7c21d716), X(0x7c2fc88f), + X(0x7c3d96d5), X(0x7c4b4214), X(0x7c58ca78), X(0x7c66302d), + X(0x7c737362), X(0x7c809443), X(0x7c8d92fc), X(0x7c9a6fbc), + X(0x7ca72aaf), X(0x7cb3c404), X(0x7cc03be8), X(0x7ccc9288), + X(0x7cd8c814), X(0x7ce4dcb9), X(0x7cf0d0a5), X(0x7cfca406), + X(0x7d08570c), X(0x7d13e9e5), X(0x7d1f5cbf), X(0x7d2aafca), + X(0x7d35e335), X(0x7d40f72e), X(0x7d4bebe4), X(0x7d56c188), + X(0x7d617848), X(0x7d6c1054), X(0x7d7689db), X(0x7d80e50e), + X(0x7d8b221b), X(0x7d954133), X(0x7d9f4286), X(0x7da92643), + X(0x7db2ec9b), X(0x7dbc95bd), X(0x7dc621da), X(0x7dcf9123), + X(0x7dd8e3c6), X(0x7de219f6), X(0x7deb33e2), X(0x7df431ba), + X(0x7dfd13af), X(0x7e05d9f2), X(0x7e0e84b4), X(0x7e171424), + X(0x7e1f8874), X(0x7e27e1d4), X(0x7e302074), X(0x7e384487), + X(0x7e404e3c), X(0x7e483dc4), X(0x7e501350), X(0x7e57cf11), + X(0x7e5f7138), X(0x7e66f9f4), X(0x7e6e6979), X(0x7e75bff5), + X(0x7e7cfd9a), X(0x7e842298), X(0x7e8b2f22), X(0x7e922366), + X(0x7e98ff97), X(0x7e9fc3e4), X(0x7ea6707f), X(0x7ead0598), + X(0x7eb38360), X(0x7eb9ea07), X(0x7ec039bf), X(0x7ec672b7), + X(0x7ecc9521), X(0x7ed2a12c), X(0x7ed8970a), X(0x7ede76ea), + X(0x7ee440fd), X(0x7ee9f573), X(0x7eef947d), X(0x7ef51e4b), + X(0x7efa930d), X(0x7efff2f2), X(0x7f053e2b), X(0x7f0a74e8), + X(0x7f0f9758), X(0x7f14a5ac), X(0x7f19a013), X(0x7f1e86bc), + X(0x7f2359d8), X(0x7f281995), X(0x7f2cc623), X(0x7f315fb1), + X(0x7f35e66e), X(0x7f3a5a8a), X(0x7f3ebc33), X(0x7f430b98), + X(0x7f4748e7), X(0x7f4b7450), X(0x7f4f8e01), X(0x7f539629), + X(0x7f578cf5), X(0x7f5b7293), X(0x7f5f4732), X(0x7f630b00), + X(0x7f66be2b), X(0x7f6a60df), X(0x7f6df34b), X(0x7f71759b), + X(0x7f74e7fe), X(0x7f784aa0), X(0x7f7b9daf), X(0x7f7ee156), + X(0x7f8215c3), X(0x7f853b22), X(0x7f88519f), X(0x7f8b5967), + X(0x7f8e52a6), X(0x7f913d87), X(0x7f941a36), X(0x7f96e8df), + X(0x7f99a9ad), X(0x7f9c5ccb), X(0x7f9f0265), X(0x7fa19aa5), + X(0x7fa425b5), X(0x7fa6a3c1), X(0x7fa914f3), X(0x7fab7974), + X(0x7fadd16f), X(0x7fb01d0d), X(0x7fb25c78), X(0x7fb48fd9), + X(0x7fb6b75a), X(0x7fb8d323), X(0x7fbae35d), X(0x7fbce831), + X(0x7fbee1c7), X(0x7fc0d047), X(0x7fc2b3d9), X(0x7fc48ca5), + X(0x7fc65ad3), X(0x7fc81e88), X(0x7fc9d7ee), X(0x7fcb872a), + X(0x7fcd2c63), X(0x7fcec7bf), X(0x7fd05966), X(0x7fd1e17c), + X(0x7fd36027), X(0x7fd4d58d), X(0x7fd641d3), X(0x7fd7a51e), + X(0x7fd8ff94), X(0x7fda5157), X(0x7fdb9a8e), X(0x7fdcdb5b), + X(0x7fde13e2), X(0x7fdf4448), X(0x7fe06caf), X(0x7fe18d3b), + X(0x7fe2a60e), X(0x7fe3b74b), X(0x7fe4c114), X(0x7fe5c38b), + X(0x7fe6bed2), X(0x7fe7b30a), X(0x7fe8a055), X(0x7fe986d4), + X(0x7fea66a7), X(0x7feb3ff0), X(0x7fec12cd), X(0x7fecdf5f), + X(0x7feda5c5), X(0x7fee6620), X(0x7fef208d), X(0x7fefd52c), + X(0x7ff0841c), X(0x7ff12d7a), X(0x7ff1d164), X(0x7ff26ff9), + X(0x7ff30955), X(0x7ff39d96), X(0x7ff42cd9), X(0x7ff4b739), + X(0x7ff53cd4), X(0x7ff5bdc5), X(0x7ff63a28), X(0x7ff6b217), + X(0x7ff725af), X(0x7ff7950a), X(0x7ff80043), X(0x7ff86773), + X(0x7ff8cab4), X(0x7ff92a21), X(0x7ff985d1), X(0x7ff9dddf), + X(0x7ffa3262), X(0x7ffa8374), X(0x7ffad12c), X(0x7ffb1ba1), + X(0x7ffb62ec), X(0x7ffba723), X(0x7ffbe85c), X(0x7ffc26b0), + X(0x7ffc6233), X(0x7ffc9afb), X(0x7ffcd11e), X(0x7ffd04b1), + X(0x7ffd35c9), X(0x7ffd647b), X(0x7ffd90da), X(0x7ffdbafa), + X(0x7ffde2f0), X(0x7ffe08ce), X(0x7ffe2ca7), X(0x7ffe4e8e), + X(0x7ffe6e95), X(0x7ffe8cce), X(0x7ffea94a), X(0x7ffec41b), + X(0x7ffedd52), X(0x7ffef4ff), X(0x7fff0b33), X(0x7fff1ffd), + X(0x7fff336e), X(0x7fff4593), X(0x7fff567d), X(0x7fff663a), + X(0x7fff74d8), X(0x7fff8265), X(0x7fff8eee), X(0x7fff9a81), + X(0x7fffa52b), X(0x7fffaef8), X(0x7fffb7f5), X(0x7fffc02d), + X(0x7fffc7ab), X(0x7fffce7c), X(0x7fffd4a9), X(0x7fffda3e), + X(0x7fffdf44), X(0x7fffe3c6), X(0x7fffe7cc), X(0x7fffeb60), + X(0x7fffee8a), X(0x7ffff153), X(0x7ffff3c4), X(0x7ffff5e3), + X(0x7ffff7b8), X(0x7ffff94b), X(0x7ffffaa1), X(0x7ffffbc1), + X(0x7ffffcb2), X(0x7ffffd78), X(0x7ffffe19), X(0x7ffffe9a), + X(0x7ffffeff), X(0x7fffff4e), X(0x7fffff89), X(0x7fffffb3), + X(0x7fffffd2), X(0x7fffffe6), X(0x7ffffff3), X(0x7ffffffa), + X(0x7ffffffe), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), +}; + +static LOOKUP_T vwin4096[2048] = { + X(0x000001f0), X(0x00001171), X(0x00003072), X(0x00005ef5), + X(0x00009cf8), X(0x0000ea7c), X(0x00014780), X(0x0001b405), + X(0x0002300b), X(0x0002bb91), X(0x00035698), X(0x0004011e), + X(0x0004bb25), X(0x000584ac), X(0x00065db3), X(0x0007463a), + X(0x00083e41), X(0x000945c7), X(0x000a5ccc), X(0x000b8350), + X(0x000cb954), X(0x000dfed7), X(0x000f53d8), X(0x0010b857), + X(0x00122c55), X(0x0013afd1), X(0x001542ca), X(0x0016e541), + X(0x00189735), X(0x001a58a7), X(0x001c2995), X(0x001e09ff), + X(0x001ff9e6), X(0x0021f948), X(0x00240826), X(0x00262680), + X(0x00285454), X(0x002a91a3), X(0x002cde6c), X(0x002f3aaf), + X(0x0031a66b), X(0x003421a0), X(0x0036ac4f), X(0x00394675), + X(0x003bf014), X(0x003ea92a), X(0x004171b7), X(0x004449bb), + X(0x00473135), X(0x004a2824), X(0x004d2e8a), X(0x00504463), + X(0x005369b2), X(0x00569e74), X(0x0059e2aa), X(0x005d3652), + X(0x0060996d), X(0x00640bf9), X(0x00678df7), X(0x006b1f66), + X(0x006ec045), X(0x00727093), X(0x00763051), X(0x0079ff7d), + X(0x007dde16), X(0x0081cc1d), X(0x0085c991), X(0x0089d671), + X(0x008df2bc), X(0x00921e71), X(0x00965991), X(0x009aa41a), + X(0x009efe0c), X(0x00a36766), X(0x00a7e028), X(0x00ac6850), + X(0x00b0ffde), X(0x00b5a6d1), X(0x00ba5d28), X(0x00bf22e4), + X(0x00c3f802), X(0x00c8dc83), X(0x00cdd065), X(0x00d2d3a8), + X(0x00d7e64a), X(0x00dd084c), X(0x00e239ac), X(0x00e77a69), + X(0x00ecca83), X(0x00f229f9), X(0x00f798ca), X(0x00fd16f5), + X(0x0102a479), X(0x01084155), X(0x010ded89), X(0x0113a913), + X(0x011973f3), X(0x011f4e27), X(0x012537af), X(0x012b308a), + X(0x013138b7), X(0x01375035), X(0x013d7702), X(0x0143ad1f), + X(0x0149f289), X(0x01504741), X(0x0156ab44), X(0x015d1e92), + X(0x0163a12a), X(0x016a330b), X(0x0170d433), X(0x017784a3), + X(0x017e4458), X(0x01851351), X(0x018bf18e), X(0x0192df0d), + X(0x0199dbcd), X(0x01a0e7cd), X(0x01a8030c), X(0x01af2d89), + X(0x01b66743), X(0x01bdb038), X(0x01c50867), X(0x01cc6fd0), + X(0x01d3e670), X(0x01db6c47), X(0x01e30153), X(0x01eaa593), + X(0x01f25907), X(0x01fa1bac), X(0x0201ed81), X(0x0209ce86), + X(0x0211beb8), X(0x0219be17), X(0x0221cca2), X(0x0229ea56), + X(0x02321733), X(0x023a5337), X(0x02429e60), X(0x024af8af), + X(0x02536220), X(0x025bdab3), X(0x02646267), X(0x026cf93a), + X(0x02759f2a), X(0x027e5436), X(0x0287185d), X(0x028feb9d), + X(0x0298cdf4), X(0x02a1bf62), X(0x02aabfe5), X(0x02b3cf7b), + X(0x02bcee23), X(0x02c61bdb), X(0x02cf58a2), X(0x02d8a475), + X(0x02e1ff55), X(0x02eb693e), X(0x02f4e230), X(0x02fe6a29), + X(0x03080127), X(0x0311a729), X(0x031b5c2d), X(0x03252031), + X(0x032ef334), X(0x0338d534), X(0x0342c630), X(0x034cc625), + X(0x0356d512), X(0x0360f2f6), X(0x036b1fce), X(0x03755b99), + X(0x037fa655), X(0x038a0001), X(0x0394689a), X(0x039ee020), + X(0x03a9668f), X(0x03b3fbe6), X(0x03bea024), X(0x03c95347), + X(0x03d4154d), X(0x03dee633), X(0x03e9c5f9), X(0x03f4b49b), + X(0x03ffb219), X(0x040abe71), X(0x0415d9a0), X(0x042103a5), + X(0x042c3c7d), X(0x04378428), X(0x0442daa2), X(0x044e3fea), + X(0x0459b3fd), X(0x046536db), X(0x0470c880), X(0x047c68eb), + X(0x0488181a), X(0x0493d60b), X(0x049fa2bc), X(0x04ab7e2a), + X(0x04b76854), X(0x04c36137), X(0x04cf68d1), X(0x04db7f21), + X(0x04e7a424), X(0x04f3d7d8), X(0x05001a3b), X(0x050c6b4a), + X(0x0518cb04), X(0x05253966), X(0x0531b66e), X(0x053e421a), + X(0x054adc68), X(0x05578555), X(0x05643cdf), X(0x05710304), + X(0x057dd7c1), X(0x058abb15), X(0x0597acfd), X(0x05a4ad76), + X(0x05b1bc7f), X(0x05beda14), X(0x05cc0635), X(0x05d940dd), + X(0x05e68a0b), X(0x05f3e1bd), X(0x060147f0), X(0x060ebca1), + X(0x061c3fcf), X(0x0629d176), X(0x06377194), X(0x06452027), + X(0x0652dd2c), X(0x0660a8a2), X(0x066e8284), X(0x067c6ad1), + X(0x068a6186), X(0x069866a1), X(0x06a67a1e), X(0x06b49bfc), + X(0x06c2cc38), X(0x06d10acf), X(0x06df57bf), X(0x06edb304), + X(0x06fc1c9d), X(0x070a9487), X(0x07191abe), X(0x0727af40), + X(0x0736520b), X(0x0745031c), X(0x0753c270), X(0x07629004), + X(0x07716bd6), X(0x078055e2), X(0x078f4e26), X(0x079e549f), + X(0x07ad694b), X(0x07bc8c26), X(0x07cbbd2e), X(0x07dafc5f), + X(0x07ea49b7), X(0x07f9a533), X(0x08090ed1), X(0x0818868c), + X(0x08280c62), X(0x0837a051), X(0x08474255), X(0x0856f26b), + X(0x0866b091), X(0x08767cc3), X(0x088656fe), X(0x08963f3f), + X(0x08a63584), X(0x08b639c8), X(0x08c64c0a), X(0x08d66c45), + X(0x08e69a77), X(0x08f6d69d), X(0x090720b3), X(0x091778b7), + X(0x0927dea5), X(0x0938527a), X(0x0948d433), X(0x095963cc), + X(0x096a0143), X(0x097aac94), X(0x098b65bb), X(0x099c2cb6), + X(0x09ad0182), X(0x09bde41a), X(0x09ced47d), X(0x09dfd2a5), + X(0x09f0de90), X(0x0a01f83b), X(0x0a131fa3), X(0x0a2454c3), + X(0x0a359798), X(0x0a46e820), X(0x0a584656), X(0x0a69b237), + X(0x0a7b2bc0), X(0x0a8cb2ec), X(0x0a9e47ba), X(0x0aafea24), + X(0x0ac19a29), X(0x0ad357c3), X(0x0ae522ef), X(0x0af6fbab), + X(0x0b08e1f1), X(0x0b1ad5c0), X(0x0b2cd712), X(0x0b3ee5e5), + X(0x0b510234), X(0x0b632bfd), X(0x0b75633b), X(0x0b87a7eb), + X(0x0b99fa08), X(0x0bac5990), X(0x0bbec67e), X(0x0bd140cf), + X(0x0be3c87e), X(0x0bf65d89), X(0x0c08ffeb), X(0x0c1bafa1), + X(0x0c2e6ca6), X(0x0c4136f6), X(0x0c540e8f), X(0x0c66f36c), + X(0x0c79e588), X(0x0c8ce4e1), X(0x0c9ff172), X(0x0cb30b37), + X(0x0cc6322c), X(0x0cd9664d), X(0x0ceca797), X(0x0cfff605), + X(0x0d135193), X(0x0d26ba3d), X(0x0d3a2fff), X(0x0d4db2d5), + X(0x0d6142ba), X(0x0d74dfac), X(0x0d8889a5), X(0x0d9c40a1), + X(0x0db0049d), X(0x0dc3d593), X(0x0dd7b380), X(0x0deb9e60), + X(0x0dff962f), X(0x0e139ae7), X(0x0e27ac85), X(0x0e3bcb05), + X(0x0e4ff662), X(0x0e642e98), X(0x0e7873a2), X(0x0e8cc57d), + X(0x0ea12423), X(0x0eb58f91), X(0x0eca07c2), X(0x0ede8cb1), + X(0x0ef31e5b), X(0x0f07bcba), X(0x0f1c67cb), X(0x0f311f88), + X(0x0f45e3ee), X(0x0f5ab4f7), X(0x0f6f92a0), X(0x0f847ce3), + X(0x0f9973bc), X(0x0fae7726), X(0x0fc3871e), X(0x0fd8a39d), + X(0x0fedcca1), X(0x10030223), X(0x1018441f), X(0x102d9291), + X(0x1042ed74), X(0x105854c3), X(0x106dc879), X(0x10834892), + X(0x1098d508), X(0x10ae6dd8), X(0x10c412fc), X(0x10d9c46f), + X(0x10ef822d), X(0x11054c30), X(0x111b2274), X(0x113104f5), + X(0x1146f3ac), X(0x115cee95), X(0x1172f5ab), X(0x118908e9), + X(0x119f284a), X(0x11b553ca), X(0x11cb8b62), X(0x11e1cf0f), + X(0x11f81ecb), X(0x120e7a90), X(0x1224e25a), X(0x123b5624), + X(0x1251d5e9), X(0x126861a3), X(0x127ef94e), X(0x12959ce3), + X(0x12ac4c5f), X(0x12c307bb), X(0x12d9cef2), X(0x12f0a200), + X(0x130780df), X(0x131e6b8a), X(0x133561fa), X(0x134c642c), + X(0x1363721a), X(0x137a8bbe), X(0x1391b113), X(0x13a8e214), + X(0x13c01eba), X(0x13d76702), X(0x13eebae5), X(0x14061a5e), + X(0x141d8567), X(0x1434fbfb), X(0x144c7e14), X(0x14640bae), + X(0x147ba4c1), X(0x14934949), X(0x14aaf941), X(0x14c2b4a2), + X(0x14da7b67), X(0x14f24d8a), X(0x150a2b06), X(0x152213d5), + X(0x153a07f1), X(0x15520755), X(0x156a11fb), X(0x158227dd), + X(0x159a48f5), X(0x15b2753d), X(0x15caacb1), X(0x15e2ef49), + X(0x15fb3d01), X(0x161395d2), X(0x162bf9b6), X(0x164468a8), + X(0x165ce2a1), X(0x1675679c), X(0x168df793), X(0x16a69280), + X(0x16bf385c), X(0x16d7e922), X(0x16f0a4cc), X(0x17096b54), + X(0x17223cb4), X(0x173b18e5), X(0x1753ffe2), X(0x176cf1a5), + X(0x1785ee27), X(0x179ef562), X(0x17b80750), X(0x17d123eb), + X(0x17ea4b2d), X(0x18037d10), X(0x181cb98d), X(0x1836009e), + X(0x184f523c), X(0x1868ae63), X(0x1882150a), X(0x189b862c), + X(0x18b501c4), X(0x18ce87c9), X(0x18e81836), X(0x1901b305), + X(0x191b582f), X(0x193507ad), X(0x194ec17a), X(0x1968858f), + X(0x198253e5), X(0x199c2c75), X(0x19b60f3a), X(0x19cffc2d), + X(0x19e9f347), X(0x1a03f482), X(0x1a1dffd7), X(0x1a381540), + X(0x1a5234b5), X(0x1a6c5e31), X(0x1a8691ac), X(0x1aa0cf21), + X(0x1abb1687), X(0x1ad567da), X(0x1aefc311), X(0x1b0a2826), + X(0x1b249712), X(0x1b3f0fd0), X(0x1b599257), X(0x1b741ea1), + X(0x1b8eb4a7), X(0x1ba95462), X(0x1bc3fdcd), X(0x1bdeb0de), + X(0x1bf96d91), X(0x1c1433dd), X(0x1c2f03bc), X(0x1c49dd27), + X(0x1c64c017), X(0x1c7fac85), X(0x1c9aa269), X(0x1cb5a1be), + X(0x1cd0aa7c), X(0x1cebbc9c), X(0x1d06d816), X(0x1d21fce4), + X(0x1d3d2aff), X(0x1d586260), X(0x1d73a2fe), X(0x1d8eecd4), + X(0x1daa3fda), X(0x1dc59c09), X(0x1de1015a), X(0x1dfc6fc5), + X(0x1e17e743), X(0x1e3367cd), X(0x1e4ef15b), X(0x1e6a83e7), + X(0x1e861f6a), X(0x1ea1c3da), X(0x1ebd7133), X(0x1ed9276b), + X(0x1ef4e67c), X(0x1f10ae5e), X(0x1f2c7f0a), X(0x1f485879), + X(0x1f643aa2), X(0x1f80257f), X(0x1f9c1908), X(0x1fb81536), + X(0x1fd41a00), X(0x1ff02761), X(0x200c3d4f), X(0x20285bc3), + X(0x204482b7), X(0x2060b221), X(0x207ce9fb), X(0x20992a3e), + X(0x20b572e0), X(0x20d1c3dc), X(0x20ee1d28), X(0x210a7ebe), + X(0x2126e895), X(0x21435aa6), X(0x215fd4ea), X(0x217c5757), + X(0x2198e1e8), X(0x21b57493), X(0x21d20f51), X(0x21eeb21b), + X(0x220b5ce7), X(0x22280fb0), X(0x2244ca6c), X(0x22618d13), + X(0x227e579f), X(0x229b2a06), X(0x22b80442), X(0x22d4e649), + X(0x22f1d015), X(0x230ec19d), X(0x232bbad9), X(0x2348bbc1), + X(0x2365c44c), X(0x2382d474), X(0x239fec30), X(0x23bd0b78), + X(0x23da3244), X(0x23f7608b), X(0x24149646), X(0x2431d36c), + X(0x244f17f5), X(0x246c63da), X(0x2489b711), X(0x24a71193), + X(0x24c47358), X(0x24e1dc57), X(0x24ff4c88), X(0x251cc3e2), + X(0x253a425e), X(0x2557c7f4), X(0x2575549a), X(0x2592e848), + X(0x25b082f7), X(0x25ce249e), X(0x25ebcd34), X(0x26097cb2), + X(0x2627330e), X(0x2644f040), X(0x2662b441), X(0x26807f07), + X(0x269e5089), X(0x26bc28c1), X(0x26da07a4), X(0x26f7ed2b), + X(0x2715d94d), X(0x2733cc02), X(0x2751c540), X(0x276fc500), + X(0x278dcb39), X(0x27abd7e2), X(0x27c9eaf3), X(0x27e80463), + X(0x28062429), X(0x28244a3e), X(0x28427697), X(0x2860a92d), + X(0x287ee1f7), X(0x289d20eb), X(0x28bb6603), X(0x28d9b134), + X(0x28f80275), X(0x291659c0), X(0x2934b709), X(0x29531a49), + X(0x29718378), X(0x298ff28b), X(0x29ae677b), X(0x29cce23e), + X(0x29eb62cb), X(0x2a09e91b), X(0x2a287523), X(0x2a4706dc), + X(0x2a659e3c), X(0x2a843b39), X(0x2aa2ddcd), X(0x2ac185ec), + X(0x2ae0338f), X(0x2afee6ad), X(0x2b1d9f3c), X(0x2b3c5d33), + X(0x2b5b208b), X(0x2b79e939), X(0x2b98b734), X(0x2bb78a74), + X(0x2bd662ef), X(0x2bf5409d), X(0x2c142374), X(0x2c330b6b), + X(0x2c51f87a), X(0x2c70ea97), X(0x2c8fe1b9), X(0x2caeddd6), + X(0x2ccddee7), X(0x2cece4e1), X(0x2d0befbb), X(0x2d2aff6d), + X(0x2d4a13ec), X(0x2d692d31), X(0x2d884b32), X(0x2da76de4), + X(0x2dc69540), X(0x2de5c13d), X(0x2e04f1d0), X(0x2e2426f0), + X(0x2e436095), X(0x2e629eb4), X(0x2e81e146), X(0x2ea1283f), + X(0x2ec07398), X(0x2edfc347), X(0x2eff1742), X(0x2f1e6f80), + X(0x2f3dcbf8), X(0x2f5d2ca0), X(0x2f7c916f), X(0x2f9bfa5c), + X(0x2fbb675d), X(0x2fdad869), X(0x2ffa4d76), X(0x3019c67b), + X(0x3039436f), X(0x3058c448), X(0x307848fc), X(0x3097d183), + X(0x30b75dd3), X(0x30d6ede2), X(0x30f681a6), X(0x31161917), + X(0x3135b42b), X(0x315552d8), X(0x3174f514), X(0x31949ad7), + X(0x31b44417), X(0x31d3f0ca), X(0x31f3a0e6), X(0x32135462), + X(0x32330b35), X(0x3252c555), X(0x327282b7), X(0x32924354), + X(0x32b20720), X(0x32d1ce13), X(0x32f19823), X(0x33116546), + X(0x33313573), X(0x3351089f), X(0x3370dec2), X(0x3390b7d1), + X(0x33b093c3), X(0x33d0728f), X(0x33f05429), X(0x3410388a), + X(0x34301fa7), X(0x34500977), X(0x346ff5ef), X(0x348fe506), + X(0x34afd6b3), X(0x34cfcaeb), X(0x34efc1a5), X(0x350fbad7), + X(0x352fb678), X(0x354fb47d), X(0x356fb4dd), X(0x358fb78e), + X(0x35afbc86), X(0x35cfc3bc), X(0x35efcd25), X(0x360fd8b8), + X(0x362fe66c), X(0x364ff636), X(0x3670080c), X(0x36901be5), + X(0x36b031b7), X(0x36d04978), X(0x36f0631e), X(0x37107ea0), + X(0x37309bf3), X(0x3750bb0e), X(0x3770dbe6), X(0x3790fe73), + X(0x37b122aa), X(0x37d14881), X(0x37f16fee), X(0x381198e8), + X(0x3831c365), X(0x3851ef5a), X(0x38721cbe), X(0x38924b87), + X(0x38b27bac), X(0x38d2ad21), X(0x38f2dfde), X(0x391313d8), + X(0x39334906), X(0x39537f5d), X(0x3973b6d4), X(0x3993ef60), + X(0x39b428f9), X(0x39d46393), X(0x39f49f25), X(0x3a14dba6), + X(0x3a35190a), X(0x3a555748), X(0x3a759657), X(0x3a95d62c), + X(0x3ab616be), X(0x3ad65801), X(0x3af699ed), X(0x3b16dc78), + X(0x3b371f97), X(0x3b576341), X(0x3b77a76c), X(0x3b97ec0d), + X(0x3bb8311b), X(0x3bd8768b), X(0x3bf8bc55), X(0x3c19026d), + X(0x3c3948ca), X(0x3c598f62), X(0x3c79d62b), X(0x3c9a1d1b), + X(0x3cba6428), X(0x3cdaab48), X(0x3cfaf271), X(0x3d1b3999), + X(0x3d3b80b6), X(0x3d5bc7be), X(0x3d7c0ea8), X(0x3d9c5569), + X(0x3dbc9bf7), X(0x3ddce248), X(0x3dfd2852), X(0x3e1d6e0c), + X(0x3e3db36c), X(0x3e5df866), X(0x3e7e3cf2), X(0x3e9e8106), + X(0x3ebec497), X(0x3edf079b), X(0x3eff4a09), X(0x3f1f8bd7), + X(0x3f3fccfa), X(0x3f600d69), X(0x3f804d1a), X(0x3fa08c02), + X(0x3fc0ca19), X(0x3fe10753), X(0x400143a7), X(0x40217f0a), + X(0x4041b974), X(0x4061f2da), X(0x40822b32), X(0x40a26272), + X(0x40c29891), X(0x40e2cd83), X(0x41030140), X(0x412333bd), + X(0x414364f1), X(0x416394d2), X(0x4183c355), X(0x41a3f070), + X(0x41c41c1b), X(0x41e4464a), X(0x42046ef4), X(0x42249610), + X(0x4244bb92), X(0x4264df72), X(0x428501a5), X(0x42a52222), + X(0x42c540de), X(0x42e55dd0), X(0x430578ed), X(0x4325922d), + X(0x4345a985), X(0x4365beeb), X(0x4385d255), X(0x43a5e3ba), + X(0x43c5f30f), X(0x43e6004b), X(0x44060b65), X(0x44261451), + X(0x44461b07), X(0x44661f7c), X(0x448621a7), X(0x44a6217d), + X(0x44c61ef6), X(0x44e61a07), X(0x450612a6), X(0x452608ca), + X(0x4545fc69), X(0x4565ed79), X(0x4585dbf1), X(0x45a5c7c6), + X(0x45c5b0ef), X(0x45e59761), X(0x46057b15), X(0x46255bfe), + X(0x46453a15), X(0x4665154f), X(0x4684eda2), X(0x46a4c305), + X(0x46c4956e), X(0x46e464d3), X(0x4704312b), X(0x4723fa6c), + X(0x4743c08d), X(0x47638382), X(0x47834344), X(0x47a2ffc9), + X(0x47c2b906), X(0x47e26ef2), X(0x48022183), X(0x4821d0b1), + X(0x48417c71), X(0x486124b9), X(0x4880c981), X(0x48a06abe), + X(0x48c00867), X(0x48dfa272), X(0x48ff38d6), X(0x491ecb8a), + X(0x493e5a84), X(0x495de5b9), X(0x497d6d22), X(0x499cf0b4), + X(0x49bc7066), X(0x49dbec2e), X(0x49fb6402), X(0x4a1ad7db), + X(0x4a3a47ad), X(0x4a59b370), X(0x4a791b1a), X(0x4a987ea1), + X(0x4ab7ddfd), X(0x4ad73924), X(0x4af6900c), X(0x4b15e2ad), + X(0x4b3530fc), X(0x4b547af1), X(0x4b73c082), X(0x4b9301a6), + X(0x4bb23e53), X(0x4bd17681), X(0x4bf0aa25), X(0x4c0fd937), + X(0x4c2f03ae), X(0x4c4e297f), X(0x4c6d4aa3), X(0x4c8c670f), + X(0x4cab7eba), X(0x4cca919c), X(0x4ce99fab), X(0x4d08a8de), + X(0x4d27ad2c), X(0x4d46ac8b), X(0x4d65a6f3), X(0x4d849c5a), + X(0x4da38cb7), X(0x4dc27802), X(0x4de15e31), X(0x4e003f3a), + X(0x4e1f1b16), X(0x4e3df1ba), X(0x4e5cc31e), X(0x4e7b8f3a), + X(0x4e9a5603), X(0x4eb91771), X(0x4ed7d37b), X(0x4ef68a18), + X(0x4f153b3f), X(0x4f33e6e7), X(0x4f528d08), X(0x4f712d97), + X(0x4f8fc88e), X(0x4fae5de1), X(0x4fcced8a), X(0x4feb777f), + X(0x5009fbb6), X(0x50287a28), X(0x5046f2cc), X(0x50656598), + X(0x5083d284), X(0x50a23988), X(0x50c09a9a), X(0x50def5b1), + X(0x50fd4ac7), X(0x511b99d0), X(0x5139e2c5), X(0x5158259e), + X(0x51766251), X(0x519498d6), X(0x51b2c925), X(0x51d0f334), + X(0x51ef16fb), X(0x520d3473), X(0x522b4b91), X(0x52495c4e), + X(0x526766a2), X(0x52856a83), X(0x52a367e9), X(0x52c15ecd), + X(0x52df4f24), X(0x52fd38e8), X(0x531b1c10), X(0x5338f892), + X(0x5356ce68), X(0x53749d89), X(0x539265eb), X(0x53b02788), + X(0x53cde257), X(0x53eb964f), X(0x54094369), X(0x5426e99c), + X(0x544488df), X(0x5462212c), X(0x547fb279), X(0x549d3cbe), + X(0x54babff4), X(0x54d83c12), X(0x54f5b110), X(0x55131ee7), + X(0x5530858d), X(0x554de4fc), X(0x556b3d2a), X(0x55888e11), + X(0x55a5d7a8), X(0x55c319e7), X(0x55e054c7), X(0x55fd883f), + X(0x561ab447), X(0x5637d8d8), X(0x5654f5ea), X(0x56720b75), + X(0x568f1971), X(0x56ac1fd7), X(0x56c91e9e), X(0x56e615c0), + X(0x57030534), X(0x571fecf2), X(0x573cccf3), X(0x5759a530), + X(0x577675a0), X(0x57933e3c), X(0x57affefd), X(0x57ccb7db), + X(0x57e968ce), X(0x580611cf), X(0x5822b2d6), X(0x583f4bdd), + X(0x585bdcdb), X(0x587865c9), X(0x5894e69f), X(0x58b15f57), + X(0x58cdcfe9), X(0x58ea384e), X(0x5906987d), X(0x5922f071), + X(0x593f4022), X(0x595b8788), X(0x5977c69c), X(0x5993fd57), + X(0x59b02bb2), X(0x59cc51a6), X(0x59e86f2c), X(0x5a04843c), + X(0x5a2090d0), X(0x5a3c94e0), X(0x5a589065), X(0x5a748359), + X(0x5a906db4), X(0x5aac4f70), X(0x5ac82884), X(0x5ae3f8ec), + X(0x5affc09f), X(0x5b1b7f97), X(0x5b3735cd), X(0x5b52e33a), + X(0x5b6e87d8), X(0x5b8a239f), X(0x5ba5b689), X(0x5bc1408f), + X(0x5bdcc1aa), X(0x5bf839d5), X(0x5c13a907), X(0x5c2f0f3b), + X(0x5c4a6c6a), X(0x5c65c08d), X(0x5c810b9e), X(0x5c9c4d97), + X(0x5cb78670), X(0x5cd2b623), X(0x5ceddcaa), X(0x5d08f9ff), + X(0x5d240e1b), X(0x5d3f18f8), X(0x5d5a1a8f), X(0x5d7512da), + X(0x5d9001d3), X(0x5daae773), X(0x5dc5c3b5), X(0x5de09692), + X(0x5dfb6004), X(0x5e162004), X(0x5e30d68d), X(0x5e4b8399), + X(0x5e662721), X(0x5e80c11f), X(0x5e9b518e), X(0x5eb5d867), + X(0x5ed055a4), X(0x5eeac940), X(0x5f053334), X(0x5f1f937b), + X(0x5f39ea0f), X(0x5f5436ea), X(0x5f6e7a06), X(0x5f88b35d), + X(0x5fa2e2e9), X(0x5fbd08a6), X(0x5fd7248d), X(0x5ff13698), + X(0x600b3ec2), X(0x60253d05), X(0x603f315b), X(0x60591bc0), + X(0x6072fc2d), X(0x608cd29e), X(0x60a69f0b), X(0x60c06171), + X(0x60da19ca), X(0x60f3c80f), X(0x610d6c3d), X(0x6127064d), + X(0x6140963a), X(0x615a1bff), X(0x61739797), X(0x618d08fc), + X(0x61a67029), X(0x61bfcd1a), X(0x61d91fc8), X(0x61f2682f), + X(0x620ba64a), X(0x6224da13), X(0x623e0386), X(0x6257229d), + X(0x62703754), X(0x628941a6), X(0x62a2418e), X(0x62bb3706), + X(0x62d4220a), X(0x62ed0296), X(0x6305d8a3), X(0x631ea42f), + X(0x63376533), X(0x63501bab), X(0x6368c793), X(0x638168e5), + X(0x6399ff9e), X(0x63b28bb8), X(0x63cb0d2f), X(0x63e383ff), + X(0x63fbf022), X(0x64145195), X(0x642ca853), X(0x6444f457), + X(0x645d359e), X(0x64756c22), X(0x648d97e0), X(0x64a5b8d3), + X(0x64bdcef6), X(0x64d5da47), X(0x64eddabf), X(0x6505d05c), + X(0x651dbb19), X(0x65359af2), X(0x654d6fe3), X(0x656539e7), + X(0x657cf8fb), X(0x6594ad1b), X(0x65ac5643), X(0x65c3f46e), + X(0x65db8799), X(0x65f30fc0), X(0x660a8ce0), X(0x6621fef3), + X(0x663965f7), X(0x6650c1e7), X(0x666812c1), X(0x667f5880), + X(0x66969320), X(0x66adc29e), X(0x66c4e6f7), X(0x66dc0026), + X(0x66f30e28), X(0x670a10fa), X(0x67210898), X(0x6737f4ff), + X(0x674ed62b), X(0x6765ac19), X(0x677c76c5), X(0x6793362c), + X(0x67a9ea4b), X(0x67c0931f), X(0x67d730a3), X(0x67edc2d6), + X(0x680449b3), X(0x681ac538), X(0x68313562), X(0x68479a2d), + X(0x685df396), X(0x6874419b), X(0x688a8438), X(0x68a0bb6a), + X(0x68b6e72e), X(0x68cd0782), X(0x68e31c63), X(0x68f925cd), + X(0x690f23be), X(0x69251633), X(0x693afd29), X(0x6950d89e), + X(0x6966a88f), X(0x697c6cf8), X(0x699225d9), X(0x69a7d32d), + X(0x69bd74f3), X(0x69d30b27), X(0x69e895c8), X(0x69fe14d2), + X(0x6a138844), X(0x6a28f01b), X(0x6a3e4c54), X(0x6a539ced), + X(0x6a68e1e4), X(0x6a7e1b37), X(0x6a9348e3), X(0x6aa86ae6), + X(0x6abd813d), X(0x6ad28be7), X(0x6ae78ae2), X(0x6afc7e2b), + X(0x6b1165c0), X(0x6b26419f), X(0x6b3b11c7), X(0x6b4fd634), + X(0x6b648ee6), X(0x6b793bda), X(0x6b8ddd0e), X(0x6ba27281), + X(0x6bb6fc31), X(0x6bcb7a1b), X(0x6bdfec3e), X(0x6bf45299), + X(0x6c08ad29), X(0x6c1cfbed), X(0x6c313ee4), X(0x6c45760a), + X(0x6c59a160), X(0x6c6dc0e4), X(0x6c81d493), X(0x6c95dc6d), + X(0x6ca9d86f), X(0x6cbdc899), X(0x6cd1acea), X(0x6ce5855f), + X(0x6cf951f7), X(0x6d0d12b1), X(0x6d20c78c), X(0x6d347087), + X(0x6d480da0), X(0x6d5b9ed6), X(0x6d6f2427), X(0x6d829d94), + X(0x6d960b1a), X(0x6da96cb9), X(0x6dbcc270), X(0x6dd00c3c), + X(0x6de34a1f), X(0x6df67c16), X(0x6e09a221), X(0x6e1cbc3f), + X(0x6e2fca6e), X(0x6e42ccaf), X(0x6e55c300), X(0x6e68ad60), + X(0x6e7b8bd0), X(0x6e8e5e4d), X(0x6ea124d8), X(0x6eb3df70), + X(0x6ec68e13), X(0x6ed930c3), X(0x6eebc77d), X(0x6efe5242), + X(0x6f10d111), X(0x6f2343e9), X(0x6f35aacb), X(0x6f4805b5), + X(0x6f5a54a8), X(0x6f6c97a2), X(0x6f7ecea4), X(0x6f90f9ae), + X(0x6fa318be), X(0x6fb52bd6), X(0x6fc732f4), X(0x6fd92e19), + X(0x6feb1d44), X(0x6ffd0076), X(0x700ed7ad), X(0x7020a2eb), + X(0x7032622f), X(0x7044157a), X(0x7055bcca), X(0x70675821), + X(0x7078e77e), X(0x708a6ae2), X(0x709be24c), X(0x70ad4dbd), + X(0x70bead36), X(0x70d000b5), X(0x70e1483d), X(0x70f283cc), + X(0x7103b363), X(0x7114d704), X(0x7125eead), X(0x7136fa60), + X(0x7147fa1c), X(0x7158ede4), X(0x7169d5b6), X(0x717ab193), + X(0x718b817d), X(0x719c4573), X(0x71acfd76), X(0x71bda988), + X(0x71ce49a8), X(0x71deddd7), X(0x71ef6617), X(0x71ffe267), + X(0x721052ca), X(0x7220b73e), X(0x72310fc6), X(0x72415c62), + X(0x72519d14), X(0x7261d1db), X(0x7271faba), X(0x728217b1), + X(0x729228c0), X(0x72a22dea), X(0x72b22730), X(0x72c21491), + X(0x72d1f611), X(0x72e1cbaf), X(0x72f1956c), X(0x7301534c), + X(0x7311054d), X(0x7320ab72), X(0x733045bc), X(0x733fd42d), + X(0x734f56c5), X(0x735ecd86), X(0x736e3872), X(0x737d9789), + X(0x738ceacf), X(0x739c3243), X(0x73ab6de7), X(0x73ba9dbe), + X(0x73c9c1c8), X(0x73d8da08), X(0x73e7e67f), X(0x73f6e72e), + X(0x7405dc17), X(0x7414c53c), X(0x7423a29f), X(0x74327442), + X(0x74413a26), X(0x744ff44d), X(0x745ea2b9), X(0x746d456c), + X(0x747bdc68), X(0x748a67ae), X(0x7498e741), X(0x74a75b23), + X(0x74b5c356), X(0x74c41fdb), X(0x74d270b6), X(0x74e0b5e7), + X(0x74eeef71), X(0x74fd1d57), X(0x750b3f9a), X(0x7519563c), + X(0x75276140), X(0x753560a8), X(0x75435477), X(0x75513cae), + X(0x755f1951), X(0x756cea60), X(0x757aafdf), X(0x758869d1), + X(0x75961837), X(0x75a3bb14), X(0x75b1526a), X(0x75bede3c), + X(0x75cc5e8d), X(0x75d9d35f), X(0x75e73cb5), X(0x75f49a91), + X(0x7601ecf6), X(0x760f33e6), X(0x761c6f65), X(0x76299f74), + X(0x7636c417), X(0x7643dd51), X(0x7650eb24), X(0x765ded93), + X(0x766ae4a0), X(0x7677d050), X(0x7684b0a4), X(0x7691859f), + X(0x769e4f45), X(0x76ab0d98), X(0x76b7c09c), X(0x76c46852), + X(0x76d104bf), X(0x76dd95e6), X(0x76ea1bc9), X(0x76f6966b), + X(0x770305d0), X(0x770f69fb), X(0x771bc2ef), X(0x772810af), + X(0x7734533e), X(0x77408aa0), X(0x774cb6d7), X(0x7758d7e8), + X(0x7764edd5), X(0x7770f8a2), X(0x777cf852), X(0x7788ece8), + X(0x7794d668), X(0x77a0b4d5), X(0x77ac8833), X(0x77b85085), + X(0x77c40dce), X(0x77cfc013), X(0x77db6756), X(0x77e7039b), + X(0x77f294e6), X(0x77fe1b3b), X(0x7809969c), X(0x7815070e), + X(0x78206c93), X(0x782bc731), X(0x783716ea), X(0x78425bc3), + X(0x784d95be), X(0x7858c4e1), X(0x7863e92d), X(0x786f02a8), + X(0x787a1156), X(0x78851539), X(0x78900e56), X(0x789afcb1), + X(0x78a5e04d), X(0x78b0b92f), X(0x78bb875b), X(0x78c64ad4), + X(0x78d1039e), X(0x78dbb1be), X(0x78e65537), X(0x78f0ee0e), + X(0x78fb7c46), X(0x7905ffe4), X(0x791078ec), X(0x791ae762), + X(0x79254b4a), X(0x792fa4a7), X(0x7939f380), X(0x794437d7), + X(0x794e71b0), X(0x7958a111), X(0x7962c5fd), X(0x796ce078), + X(0x7976f087), X(0x7980f62f), X(0x798af173), X(0x7994e258), + X(0x799ec8e2), X(0x79a8a515), X(0x79b276f7), X(0x79bc3e8b), + X(0x79c5fbd6), X(0x79cfaedc), X(0x79d957a2), X(0x79e2f62c), + X(0x79ec8a7f), X(0x79f6149f), X(0x79ff9492), X(0x7a090a5a), + X(0x7a1275fe), X(0x7a1bd781), X(0x7a252ee9), X(0x7a2e7c39), + X(0x7a37bf77), X(0x7a40f8a7), X(0x7a4a27ce), X(0x7a534cf0), + X(0x7a5c6813), X(0x7a65793b), X(0x7a6e806d), X(0x7a777dad), + X(0x7a807100), X(0x7a895a6b), X(0x7a9239f4), X(0x7a9b0f9e), + X(0x7aa3db6f), X(0x7aac9d6b), X(0x7ab55597), X(0x7abe03f9), + X(0x7ac6a895), X(0x7acf4370), X(0x7ad7d48f), X(0x7ae05bf6), + X(0x7ae8d9ac), X(0x7af14db5), X(0x7af9b815), X(0x7b0218d2), + X(0x7b0a6ff2), X(0x7b12bd78), X(0x7b1b016a), X(0x7b233bce), + X(0x7b2b6ca7), X(0x7b3393fc), X(0x7b3bb1d1), X(0x7b43c62c), + X(0x7b4bd111), X(0x7b53d286), X(0x7b5bca90), X(0x7b63b935), + X(0x7b6b9e78), X(0x7b737a61), X(0x7b7b4cf3), X(0x7b831634), + X(0x7b8ad629), X(0x7b928cd8), X(0x7b9a3a45), X(0x7ba1de77), + X(0x7ba97972), X(0x7bb10b3c), X(0x7bb893d9), X(0x7bc01350), + X(0x7bc789a6), X(0x7bcef6e0), X(0x7bd65b03), X(0x7bddb616), + X(0x7be5081c), X(0x7bec511c), X(0x7bf3911b), X(0x7bfac81f), + X(0x7c01f62c), X(0x7c091b49), X(0x7c10377b), X(0x7c174ac7), + X(0x7c1e5532), X(0x7c2556c4), X(0x7c2c4f80), X(0x7c333f6c), + X(0x7c3a268e), X(0x7c4104ec), X(0x7c47da8a), X(0x7c4ea76f), + X(0x7c556ba1), X(0x7c5c2724), X(0x7c62d9fe), X(0x7c698435), + X(0x7c7025cf), X(0x7c76bed0), X(0x7c7d4f40), X(0x7c83d723), + X(0x7c8a567f), X(0x7c90cd5a), X(0x7c973bb9), X(0x7c9da1a2), + X(0x7ca3ff1b), X(0x7caa542a), X(0x7cb0a0d3), X(0x7cb6e51e), + X(0x7cbd210f), X(0x7cc354ac), X(0x7cc97ffc), X(0x7ccfa304), + X(0x7cd5bdc9), X(0x7cdbd051), X(0x7ce1daa3), X(0x7ce7dcc3), + X(0x7cedd6b8), X(0x7cf3c888), X(0x7cf9b238), X(0x7cff93cf), + X(0x7d056d51), X(0x7d0b3ec5), X(0x7d110830), X(0x7d16c99a), + X(0x7d1c8306), X(0x7d22347c), X(0x7d27de00), X(0x7d2d7f9a), + X(0x7d33194f), X(0x7d38ab24), X(0x7d3e351f), X(0x7d43b748), + X(0x7d4931a2), X(0x7d4ea435), X(0x7d540f06), X(0x7d59721b), + X(0x7d5ecd7b), X(0x7d64212a), X(0x7d696d2f), X(0x7d6eb190), + X(0x7d73ee53), X(0x7d79237e), X(0x7d7e5117), X(0x7d837723), + X(0x7d8895a9), X(0x7d8dacae), X(0x7d92bc3a), X(0x7d97c451), + X(0x7d9cc4f9), X(0x7da1be39), X(0x7da6b017), X(0x7dab9a99), + X(0x7db07dc4), X(0x7db5599e), X(0x7dba2e2f), X(0x7dbefb7b), + X(0x7dc3c189), X(0x7dc8805e), X(0x7dcd3802), X(0x7dd1e879), + X(0x7dd691ca), X(0x7ddb33fb), X(0x7ddfcf12), X(0x7de46315), + X(0x7de8f00a), X(0x7ded75f8), X(0x7df1f4e3), X(0x7df66cd3), + X(0x7dfaddcd), X(0x7dff47d7), X(0x7e03aaf8), X(0x7e080735), + X(0x7e0c5c95), X(0x7e10ab1e), X(0x7e14f2d5), X(0x7e1933c1), + X(0x7e1d6de8), X(0x7e21a150), X(0x7e25cdff), X(0x7e29f3fc), + X(0x7e2e134c), X(0x7e322bf5), X(0x7e363dfd), X(0x7e3a496b), + X(0x7e3e4e45), X(0x7e424c90), X(0x7e464454), X(0x7e4a3595), + X(0x7e4e205a), X(0x7e5204aa), X(0x7e55e289), X(0x7e59b9ff), + X(0x7e5d8b12), X(0x7e6155c7), X(0x7e651a24), X(0x7e68d831), + X(0x7e6c8ff2), X(0x7e70416e), X(0x7e73ecac), X(0x7e7791b0), + X(0x7e7b3082), X(0x7e7ec927), X(0x7e825ba6), X(0x7e85e804), + X(0x7e896e48), X(0x7e8cee77), X(0x7e906899), X(0x7e93dcb2), + X(0x7e974aca), X(0x7e9ab2e5), X(0x7e9e150b), X(0x7ea17141), + X(0x7ea4c78e), X(0x7ea817f7), X(0x7eab6283), X(0x7eaea737), + X(0x7eb1e61a), X(0x7eb51f33), X(0x7eb85285), X(0x7ebb8019), + X(0x7ebea7f4), X(0x7ec1ca1d), X(0x7ec4e698), X(0x7ec7fd6d), + X(0x7ecb0ea1), X(0x7ece1a3a), X(0x7ed1203f), X(0x7ed420b6), + X(0x7ed71ba4), X(0x7eda110f), X(0x7edd00ff), X(0x7edfeb78), + X(0x7ee2d081), X(0x7ee5b01f), X(0x7ee88a5a), X(0x7eeb5f36), + X(0x7eee2eba), X(0x7ef0f8ed), X(0x7ef3bdd3), X(0x7ef67d73), + X(0x7ef937d3), X(0x7efbecf9), X(0x7efe9ceb), X(0x7f0147ae), + X(0x7f03ed4a), X(0x7f068dc4), X(0x7f092922), X(0x7f0bbf69), + X(0x7f0e50a1), X(0x7f10dcce), X(0x7f1363f7), X(0x7f15e622), + X(0x7f186355), X(0x7f1adb95), X(0x7f1d4ee9), X(0x7f1fbd57), + X(0x7f2226e4), X(0x7f248b96), X(0x7f26eb74), X(0x7f294683), + X(0x7f2b9cc9), X(0x7f2dee4d), X(0x7f303b13), X(0x7f328322), + X(0x7f34c680), X(0x7f370533), X(0x7f393f40), X(0x7f3b74ad), + X(0x7f3da581), X(0x7f3fd1c1), X(0x7f41f972), X(0x7f441c9c), + X(0x7f463b43), X(0x7f48556d), X(0x7f4a6b21), X(0x7f4c7c64), + X(0x7f4e893c), X(0x7f5091ae), X(0x7f5295c1), X(0x7f54957a), + X(0x7f5690e0), X(0x7f5887f7), X(0x7f5a7ac5), X(0x7f5c6951), + X(0x7f5e53a0), X(0x7f6039b8), X(0x7f621b9e), X(0x7f63f958), + X(0x7f65d2ed), X(0x7f67a861), X(0x7f6979ba), X(0x7f6b46ff), + X(0x7f6d1034), X(0x7f6ed560), X(0x7f709687), X(0x7f7253b1), + X(0x7f740ce1), X(0x7f75c21f), X(0x7f777370), X(0x7f7920d8), + X(0x7f7aca5f), X(0x7f7c7008), X(0x7f7e11db), X(0x7f7fafdd), + X(0x7f814a13), X(0x7f82e082), X(0x7f847331), X(0x7f860224), + X(0x7f878d62), X(0x7f8914f0), X(0x7f8a98d4), X(0x7f8c1912), + X(0x7f8d95b0), X(0x7f8f0eb5), X(0x7f908425), X(0x7f91f605), + X(0x7f93645c), X(0x7f94cf2f), X(0x7f963683), X(0x7f979a5d), + X(0x7f98fac4), X(0x7f9a57bb), X(0x7f9bb14a), X(0x7f9d0775), + X(0x7f9e5a41), X(0x7f9fa9b4), X(0x7fa0f5d3), X(0x7fa23ea4), + X(0x7fa3842b), X(0x7fa4c66f), X(0x7fa60575), X(0x7fa74141), + X(0x7fa879d9), X(0x7fa9af42), X(0x7faae182), X(0x7fac109e), + X(0x7fad3c9a), X(0x7fae657d), X(0x7faf8b4c), X(0x7fb0ae0b), + X(0x7fb1cdc0), X(0x7fb2ea70), X(0x7fb40420), X(0x7fb51ad5), + X(0x7fb62e95), X(0x7fb73f64), X(0x7fb84d48), X(0x7fb95846), + X(0x7fba6062), X(0x7fbb65a2), X(0x7fbc680c), X(0x7fbd67a3), + X(0x7fbe646d), X(0x7fbf5e70), X(0x7fc055af), X(0x7fc14a31), + X(0x7fc23bf9), X(0x7fc32b0d), X(0x7fc41773), X(0x7fc5012e), + X(0x7fc5e844), X(0x7fc6ccba), X(0x7fc7ae94), X(0x7fc88dd8), + X(0x7fc96a8a), X(0x7fca44af), X(0x7fcb1c4c), X(0x7fcbf167), + X(0x7fccc403), X(0x7fcd9425), X(0x7fce61d3), X(0x7fcf2d11), + X(0x7fcff5e3), X(0x7fd0bc4f), X(0x7fd1805a), X(0x7fd24207), + X(0x7fd3015c), X(0x7fd3be5d), X(0x7fd47910), X(0x7fd53178), + X(0x7fd5e79b), X(0x7fd69b7c), X(0x7fd74d21), X(0x7fd7fc8e), + X(0x7fd8a9c8), X(0x7fd954d4), X(0x7fd9fdb5), X(0x7fdaa471), + X(0x7fdb490b), X(0x7fdbeb89), X(0x7fdc8bef), X(0x7fdd2a42), + X(0x7fddc685), X(0x7fde60be), X(0x7fdef8f0), X(0x7fdf8f20), + X(0x7fe02353), X(0x7fe0b58d), X(0x7fe145d3), X(0x7fe1d428), + X(0x7fe26091), X(0x7fe2eb12), X(0x7fe373b0), X(0x7fe3fa6f), + X(0x7fe47f53), X(0x7fe50260), X(0x7fe5839b), X(0x7fe60308), + X(0x7fe680ab), X(0x7fe6fc88), X(0x7fe776a4), X(0x7fe7ef02), + X(0x7fe865a7), X(0x7fe8da97), X(0x7fe94dd6), X(0x7fe9bf68), + X(0x7fea2f51), X(0x7fea9d95), X(0x7feb0a39), X(0x7feb7540), + X(0x7febdeae), X(0x7fec4687), X(0x7fecaccf), X(0x7fed118b), + X(0x7fed74be), X(0x7fedd66c), X(0x7fee3698), X(0x7fee9548), + X(0x7feef27e), X(0x7fef4e3f), X(0x7fefa88e), X(0x7ff0016f), + X(0x7ff058e7), X(0x7ff0aef8), X(0x7ff103a6), X(0x7ff156f6), + X(0x7ff1a8eb), X(0x7ff1f988), X(0x7ff248d2), X(0x7ff296cc), + X(0x7ff2e37a), X(0x7ff32edf), X(0x7ff378ff), X(0x7ff3c1de), + X(0x7ff4097e), X(0x7ff44fe5), X(0x7ff49515), X(0x7ff4d911), + X(0x7ff51bde), X(0x7ff55d7f), X(0x7ff59df7), X(0x7ff5dd4a), + X(0x7ff61b7b), X(0x7ff6588d), X(0x7ff69485), X(0x7ff6cf65), + X(0x7ff70930), X(0x7ff741eb), X(0x7ff77998), X(0x7ff7b03b), + X(0x7ff7e5d7), X(0x7ff81a6f), X(0x7ff84e06), X(0x7ff880a1), + X(0x7ff8b241), X(0x7ff8e2ea), X(0x7ff912a0), X(0x7ff94165), + X(0x7ff96f3d), X(0x7ff99c2b), X(0x7ff9c831), X(0x7ff9f354), + X(0x7ffa1d95), X(0x7ffa46f9), X(0x7ffa6f81), X(0x7ffa9731), + X(0x7ffabe0d), X(0x7ffae416), X(0x7ffb0951), X(0x7ffb2dbf), + X(0x7ffb5164), X(0x7ffb7442), X(0x7ffb965d), X(0x7ffbb7b8), + X(0x7ffbd854), X(0x7ffbf836), X(0x7ffc175f), X(0x7ffc35d3), + X(0x7ffc5394), X(0x7ffc70a5), X(0x7ffc8d09), X(0x7ffca8c2), + X(0x7ffcc3d4), X(0x7ffcde3f), X(0x7ffcf809), X(0x7ffd1132), + X(0x7ffd29be), X(0x7ffd41ae), X(0x7ffd5907), X(0x7ffd6fc9), + X(0x7ffd85f9), X(0x7ffd9b97), X(0x7ffdb0a7), X(0x7ffdc52b), + X(0x7ffdd926), X(0x7ffdec99), X(0x7ffdff88), X(0x7ffe11f4), + X(0x7ffe23e0), X(0x7ffe354f), X(0x7ffe4642), X(0x7ffe56bc), + X(0x7ffe66bf), X(0x7ffe764e), X(0x7ffe856a), X(0x7ffe9416), + X(0x7ffea254), X(0x7ffeb026), X(0x7ffebd8e), X(0x7ffeca8f), + X(0x7ffed72a), X(0x7ffee362), X(0x7ffeef38), X(0x7ffefaaf), + X(0x7fff05c9), X(0x7fff1087), X(0x7fff1aec), X(0x7fff24f9), + X(0x7fff2eb1), X(0x7fff3816), X(0x7fff4128), X(0x7fff49eb), + X(0x7fff5260), X(0x7fff5a88), X(0x7fff6266), X(0x7fff69fc), + X(0x7fff714b), X(0x7fff7854), X(0x7fff7f1a), X(0x7fff859f), + X(0x7fff8be3), X(0x7fff91ea), X(0x7fff97b3), X(0x7fff9d41), + X(0x7fffa296), X(0x7fffa7b3), X(0x7fffac99), X(0x7fffb14b), + X(0x7fffb5c9), X(0x7fffba15), X(0x7fffbe31), X(0x7fffc21d), + X(0x7fffc5dc), X(0x7fffc96f), X(0x7fffccd8), X(0x7fffd016), + X(0x7fffd32d), X(0x7fffd61c), X(0x7fffd8e7), X(0x7fffdb8d), + X(0x7fffde0f), X(0x7fffe071), X(0x7fffe2b1), X(0x7fffe4d2), + X(0x7fffe6d5), X(0x7fffe8bb), X(0x7fffea85), X(0x7fffec34), + X(0x7fffedc9), X(0x7fffef45), X(0x7ffff0aa), X(0x7ffff1f7), + X(0x7ffff330), X(0x7ffff453), X(0x7ffff562), X(0x7ffff65f), + X(0x7ffff749), X(0x7ffff823), X(0x7ffff8ec), X(0x7ffff9a6), + X(0x7ffffa51), X(0x7ffffaee), X(0x7ffffb7e), X(0x7ffffc02), + X(0x7ffffc7a), X(0x7ffffce7), X(0x7ffffd4a), X(0x7ffffda3), + X(0x7ffffdf4), X(0x7ffffe3c), X(0x7ffffe7c), X(0x7ffffeb6), + X(0x7ffffee8), X(0x7fffff15), X(0x7fffff3c), X(0x7fffff5e), + X(0x7fffff7b), X(0x7fffff95), X(0x7fffffaa), X(0x7fffffbc), + X(0x7fffffcb), X(0x7fffffd7), X(0x7fffffe2), X(0x7fffffea), + X(0x7ffffff0), X(0x7ffffff5), X(0x7ffffff9), X(0x7ffffffb), + X(0x7ffffffd), X(0x7ffffffe), X(0x7fffffff), X(0x7fffffff), + X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), +}; + +#ifndef LIMIT_TO_64kHz + +static LOOKUP_T vwin8192[4096] = { + X(0x0000007c), X(0x0000045c), X(0x00000c1d), X(0x000017bd), + X(0x0000273e), X(0x00003a9f), X(0x000051e0), X(0x00006d02), + X(0x00008c03), X(0x0000aee5), X(0x0000d5a7), X(0x00010049), + X(0x00012ecb), X(0x0001612d), X(0x00019770), X(0x0001d193), + X(0x00020f96), X(0x00025178), X(0x0002973c), X(0x0002e0df), + X(0x00032e62), X(0x00037fc5), X(0x0003d509), X(0x00042e2c), + X(0x00048b30), X(0x0004ec13), X(0x000550d7), X(0x0005b97a), + X(0x000625fe), X(0x00069661), X(0x00070aa4), X(0x000782c8), + X(0x0007fecb), X(0x00087eae), X(0x00090271), X(0x00098a14), + X(0x000a1597), X(0x000aa4f9), X(0x000b383b), X(0x000bcf5d), + X(0x000c6a5f), X(0x000d0941), X(0x000dac02), X(0x000e52a3), + X(0x000efd23), X(0x000fab84), X(0x00105dc3), X(0x001113e3), + X(0x0011cde2), X(0x00128bc0), X(0x00134d7e), X(0x0014131b), + X(0x0014dc98), X(0x0015a9f4), X(0x00167b30), X(0x0017504a), + X(0x00182945), X(0x0019061e), X(0x0019e6d7), X(0x001acb6f), + X(0x001bb3e6), X(0x001ca03c), X(0x001d9071), X(0x001e8485), + X(0x001f7c79), X(0x0020784b), X(0x002177fc), X(0x00227b8c), + X(0x002382fb), X(0x00248e49), X(0x00259d76), X(0x0026b081), + X(0x0027c76b), X(0x0028e234), X(0x002a00dc), X(0x002b2361), + X(0x002c49c6), X(0x002d7409), X(0x002ea22a), X(0x002fd42a), + X(0x00310a08), X(0x003243c5), X(0x00338160), X(0x0034c2d9), + X(0x00360830), X(0x00375165), X(0x00389e78), X(0x0039ef6a), + X(0x003b4439), X(0x003c9ce6), X(0x003df971), X(0x003f59da), + X(0x0040be20), X(0x00422645), X(0x00439247), X(0x00450226), + X(0x004675e3), X(0x0047ed7e), X(0x004968f5), X(0x004ae84b), + X(0x004c6b7d), X(0x004df28d), X(0x004f7d7a), X(0x00510c44), + X(0x00529eeb), X(0x00543570), X(0x0055cfd1), X(0x00576e0f), + X(0x00591029), X(0x005ab621), X(0x005c5ff5), X(0x005e0da6), + X(0x005fbf33), X(0x0061749d), X(0x00632de4), X(0x0064eb06), + X(0x0066ac05), X(0x006870e0), X(0x006a3998), X(0x006c062b), + X(0x006dd69b), X(0x006faae6), X(0x0071830d), X(0x00735f10), + X(0x00753eef), X(0x007722a9), X(0x00790a3f), X(0x007af5b1), + X(0x007ce4fe), X(0x007ed826), X(0x0080cf29), X(0x0082ca08), + X(0x0084c8c2), X(0x0086cb57), X(0x0088d1c7), X(0x008adc11), + X(0x008cea37), X(0x008efc37), X(0x00911212), X(0x00932bc7), + X(0x00954957), X(0x00976ac2), X(0x00999006), X(0x009bb925), + X(0x009de61e), X(0x00a016f1), X(0x00a24b9e), X(0x00a48425), + X(0x00a6c086), X(0x00a900c0), X(0x00ab44d4), X(0x00ad8cc2), + X(0x00afd889), X(0x00b22829), X(0x00b47ba2), X(0x00b6d2f5), + X(0x00b92e21), X(0x00bb8d26), X(0x00bdf004), X(0x00c056ba), + X(0x00c2c149), X(0x00c52fb1), X(0x00c7a1f1), X(0x00ca180a), + X(0x00cc91fb), X(0x00cf0fc5), X(0x00d19166), X(0x00d416df), + X(0x00d6a031), X(0x00d92d5a), X(0x00dbbe5b), X(0x00de5333), + X(0x00e0ebe3), X(0x00e3886b), X(0x00e628c9), X(0x00e8ccff), + X(0x00eb750c), X(0x00ee20f0), X(0x00f0d0ab), X(0x00f3843d), + X(0x00f63ba5), X(0x00f8f6e4), X(0x00fbb5fa), X(0x00fe78e5), + X(0x01013fa7), X(0x01040a3f), X(0x0106d8ae), X(0x0109aaf2), + X(0x010c810c), X(0x010f5afb), X(0x011238c0), X(0x01151a5b), + X(0x0117ffcb), X(0x011ae910), X(0x011dd62a), X(0x0120c719), + X(0x0123bbdd), X(0x0126b476), X(0x0129b0e4), X(0x012cb126), + X(0x012fb53c), X(0x0132bd27), X(0x0135c8e6), X(0x0138d879), + X(0x013bebdf), X(0x013f031a), X(0x01421e28), X(0x01453d0a), + X(0x01485fbf), X(0x014b8648), X(0x014eb0a4), X(0x0151ded2), + X(0x015510d4), X(0x015846a8), X(0x015b8050), X(0x015ebdc9), + X(0x0161ff15), X(0x01654434), X(0x01688d24), X(0x016bd9e6), + X(0x016f2a7b), X(0x01727ee1), X(0x0175d718), X(0x01793321), + X(0x017c92fc), X(0x017ff6a7), X(0x01835e24), X(0x0186c972), + X(0x018a3890), X(0x018dab7f), X(0x0191223f), X(0x01949ccf), + X(0x01981b2f), X(0x019b9d5f), X(0x019f235f), X(0x01a2ad2f), + X(0x01a63acf), X(0x01a9cc3e), X(0x01ad617c), X(0x01b0fa8a), + X(0x01b49767), X(0x01b83813), X(0x01bbdc8d), X(0x01bf84d6), + X(0x01c330ee), X(0x01c6e0d4), X(0x01ca9488), X(0x01ce4c0b), + X(0x01d2075b), X(0x01d5c679), X(0x01d98964), X(0x01dd501d), + X(0x01e11aa3), X(0x01e4e8f6), X(0x01e8bb17), X(0x01ec9104), + X(0x01f06abd), X(0x01f44844), X(0x01f82996), X(0x01fc0eb5), + X(0x01fff7a0), X(0x0203e456), X(0x0207d4d9), X(0x020bc926), + X(0x020fc140), X(0x0213bd24), X(0x0217bcd4), X(0x021bc04e), + X(0x021fc793), X(0x0223d2a3), X(0x0227e17d), X(0x022bf421), + X(0x02300a90), X(0x023424c8), X(0x023842ca), X(0x023c6495), + X(0x02408a2a), X(0x0244b389), X(0x0248e0b0), X(0x024d11a0), + X(0x02514659), X(0x02557eda), X(0x0259bb24), X(0x025dfb35), + X(0x02623f0f), X(0x026686b1), X(0x026ad21a), X(0x026f214b), + X(0x02737443), X(0x0277cb02), X(0x027c2588), X(0x028083d5), + X(0x0284e5e9), X(0x02894bc2), X(0x028db562), X(0x029222c8), + X(0x029693f4), X(0x029b08e6), X(0x029f819d), X(0x02a3fe19), + X(0x02a87e5b), X(0x02ad0261), X(0x02b18a2c), X(0x02b615bb), + X(0x02baa50f), X(0x02bf3827), X(0x02c3cf03), X(0x02c869a3), + X(0x02cd0807), X(0x02d1aa2d), X(0x02d65017), X(0x02daf9c4), + X(0x02dfa734), X(0x02e45866), X(0x02e90d5b), X(0x02edc612), + X(0x02f2828b), X(0x02f742c6), X(0x02fc06c3), X(0x0300ce80), + X(0x030599ff), X(0x030a6940), X(0x030f3c40), X(0x03141302), + X(0x0318ed84), X(0x031dcbc6), X(0x0322adc8), X(0x0327938a), + X(0x032c7d0c), X(0x03316a4c), X(0x03365b4d), X(0x033b500c), + X(0x03404889), X(0x034544c6), X(0x034a44c0), X(0x034f4879), + X(0x03544ff0), X(0x03595b24), X(0x035e6a16), X(0x03637cc5), + X(0x03689331), X(0x036dad5a), X(0x0372cb40), X(0x0377ece2), + X(0x037d1240), X(0x03823b5a), X(0x03876830), X(0x038c98c1), + X(0x0391cd0e), X(0x03970516), X(0x039c40d8), X(0x03a18055), + X(0x03a6c38d), X(0x03ac0a7f), X(0x03b1552b), X(0x03b6a390), + X(0x03bbf5af), X(0x03c14b88), X(0x03c6a519), X(0x03cc0263), + X(0x03d16366), X(0x03d6c821), X(0x03dc3094), X(0x03e19cc0), + X(0x03e70ca2), X(0x03ec803d), X(0x03f1f78e), X(0x03f77296), + X(0x03fcf155), X(0x040273cb), X(0x0407f9f7), X(0x040d83d9), + X(0x04131170), X(0x0418a2bd), X(0x041e37c0), X(0x0423d077), + X(0x04296ce4), X(0x042f0d04), X(0x0434b0da), X(0x043a5863), + X(0x044003a0), X(0x0445b290), X(0x044b6534), X(0x04511b8b), + X(0x0456d595), X(0x045c9352), X(0x046254c1), X(0x046819e1), + X(0x046de2b4), X(0x0473af39), X(0x04797f6e), X(0x047f5355), + X(0x04852aec), X(0x048b0635), X(0x0490e52d), X(0x0496c7d6), + X(0x049cae2e), X(0x04a29836), X(0x04a885ed), X(0x04ae7753), + X(0x04b46c68), X(0x04ba652b), X(0x04c0619d), X(0x04c661bc), + X(0x04cc658a), X(0x04d26d04), X(0x04d8782c), X(0x04de8701), + X(0x04e49983), X(0x04eaafb0), X(0x04f0c98a), X(0x04f6e710), + X(0x04fd0842), X(0x05032d1e), X(0x050955a6), X(0x050f81d8), + X(0x0515b1b5), X(0x051be53d), X(0x05221c6e), X(0x05285748), + X(0x052e95cd), X(0x0534d7fa), X(0x053b1dd0), X(0x0541674e), + X(0x0547b475), X(0x054e0544), X(0x055459bb), X(0x055ab1d9), + X(0x05610d9e), X(0x05676d0a), X(0x056dd01c), X(0x057436d5), + X(0x057aa134), X(0x05810f38), X(0x058780e2), X(0x058df631), + X(0x05946f25), X(0x059aebbe), X(0x05a16bfa), X(0x05a7efdb), + X(0x05ae775f), X(0x05b50287), X(0x05bb9152), X(0x05c223c0), + X(0x05c8b9d0), X(0x05cf5382), X(0x05d5f0d6), X(0x05dc91cc), + X(0x05e33663), X(0x05e9de9c), X(0x05f08a75), X(0x05f739ee), + X(0x05fded07), X(0x0604a3c0), X(0x060b5e19), X(0x06121c11), + X(0x0618dda8), X(0x061fa2dd), X(0x06266bb1), X(0x062d3822), + X(0x06340831), X(0x063adbde), X(0x0641b328), X(0x06488e0e), + X(0x064f6c91), X(0x06564eaf), X(0x065d346a), X(0x06641dc0), + X(0x066b0ab1), X(0x0671fb3d), X(0x0678ef64), X(0x067fe724), + X(0x0686e27f), X(0x068de173), X(0x0694e400), X(0x069bea27), + X(0x06a2f3e6), X(0x06aa013d), X(0x06b1122c), X(0x06b826b3), + X(0x06bf3ed1), X(0x06c65a86), X(0x06cd79d1), X(0x06d49cb3), + X(0x06dbc32b), X(0x06e2ed38), X(0x06ea1adb), X(0x06f14c13), + X(0x06f880df), X(0x06ffb940), X(0x0706f535), X(0x070e34bd), + X(0x071577d9), X(0x071cbe88), X(0x072408c9), X(0x072b569d), + X(0x0732a802), X(0x0739fcf9), X(0x07415582), X(0x0748b19b), + X(0x07501145), X(0x0757747f), X(0x075edb49), X(0x076645a3), + X(0x076db38c), X(0x07752503), X(0x077c9a09), X(0x0784129e), + X(0x078b8ec0), X(0x07930e70), X(0x079a91ac), X(0x07a21876), + X(0x07a9a2cc), X(0x07b130ad), X(0x07b8c21b), X(0x07c05714), + X(0x07c7ef98), X(0x07cf8ba6), X(0x07d72b3f), X(0x07dece62), + X(0x07e6750e), X(0x07ee1f43), X(0x07f5cd01), X(0x07fd7e48), + X(0x08053316), X(0x080ceb6d), X(0x0814a74a), X(0x081c66af), + X(0x0824299a), X(0x082bf00c), X(0x0833ba03), X(0x083b8780), + X(0x08435882), X(0x084b2d09), X(0x08530514), X(0x085ae0a3), + X(0x0862bfb6), X(0x086aa24c), X(0x08728865), X(0x087a7201), + X(0x08825f1e), X(0x088a4fbe), X(0x089243de), X(0x089a3b80), + X(0x08a236a2), X(0x08aa3545), X(0x08b23767), X(0x08ba3d09), + X(0x08c2462a), X(0x08ca52c9), X(0x08d262e7), X(0x08da7682), + X(0x08e28d9c), X(0x08eaa832), X(0x08f2c645), X(0x08fae7d4), + X(0x09030cdf), X(0x090b3566), X(0x09136168), X(0x091b90e5), + X(0x0923c3dc), X(0x092bfa4d), X(0x09343437), X(0x093c719b), + X(0x0944b277), X(0x094cf6cc), X(0x09553e99), X(0x095d89dd), + X(0x0965d899), X(0x096e2acb), X(0x09768073), X(0x097ed991), + X(0x09873625), X(0x098f962e), X(0x0997f9ac), X(0x09a0609e), + X(0x09a8cb04), X(0x09b138dd), X(0x09b9aa29), X(0x09c21ee8), + X(0x09ca9719), X(0x09d312bc), X(0x09db91d0), X(0x09e41456), + X(0x09ec9a4b), X(0x09f523b1), X(0x09fdb087), X(0x0a0640cc), + X(0x0a0ed47f), X(0x0a176ba2), X(0x0a200632), X(0x0a28a42f), + X(0x0a31459a), X(0x0a39ea72), X(0x0a4292b5), X(0x0a4b3e65), + X(0x0a53ed80), X(0x0a5ca006), X(0x0a6555f7), X(0x0a6e0f51), + X(0x0a76cc16), X(0x0a7f8c44), X(0x0a884fda), X(0x0a9116d9), + X(0x0a99e140), X(0x0aa2af0e), X(0x0aab8043), X(0x0ab454df), + X(0x0abd2ce1), X(0x0ac60849), X(0x0acee716), X(0x0ad7c948), + X(0x0ae0aedf), X(0x0ae997d9), X(0x0af28437), X(0x0afb73f7), + X(0x0b04671b), X(0x0b0d5da0), X(0x0b165788), X(0x0b1f54d0), + X(0x0b285579), X(0x0b315983), X(0x0b3a60ec), X(0x0b436bb5), + X(0x0b4c79dd), X(0x0b558b63), X(0x0b5ea048), X(0x0b67b88a), + X(0x0b70d429), X(0x0b79f324), X(0x0b83157c), X(0x0b8c3b30), + X(0x0b95643f), X(0x0b9e90a8), X(0x0ba7c06c), X(0x0bb0f38a), + X(0x0bba2a01), X(0x0bc363d1), X(0x0bcca0f9), X(0x0bd5e17a), + X(0x0bdf2552), X(0x0be86c81), X(0x0bf1b706), X(0x0bfb04e2), + X(0x0c045613), X(0x0c0daa99), X(0x0c170274), X(0x0c205da3), + X(0x0c29bc25), X(0x0c331dfb), X(0x0c3c8323), X(0x0c45eb9e), + X(0x0c4f576a), X(0x0c58c688), X(0x0c6238f6), X(0x0c6baeb5), + X(0x0c7527c3), X(0x0c7ea421), X(0x0c8823cd), X(0x0c91a6c8), + X(0x0c9b2d10), X(0x0ca4b6a6), X(0x0cae4389), X(0x0cb7d3b8), + X(0x0cc16732), X(0x0ccafdf8), X(0x0cd49809), X(0x0cde3564), + X(0x0ce7d609), X(0x0cf179f7), X(0x0cfb212e), X(0x0d04cbad), + X(0x0d0e7974), X(0x0d182a83), X(0x0d21ded8), X(0x0d2b9673), + X(0x0d355154), X(0x0d3f0f7b), X(0x0d48d0e6), X(0x0d529595), + X(0x0d5c5d88), X(0x0d6628be), X(0x0d6ff737), X(0x0d79c8f2), + X(0x0d839dee), X(0x0d8d762c), X(0x0d9751aa), X(0x0da13068), + X(0x0dab1266), X(0x0db4f7a3), X(0x0dbee01e), X(0x0dc8cbd8), + X(0x0dd2bace), X(0x0ddcad02), X(0x0de6a272), X(0x0df09b1e), + X(0x0dfa9705), X(0x0e049627), X(0x0e0e9883), X(0x0e189e19), + X(0x0e22a6e8), X(0x0e2cb2f0), X(0x0e36c230), X(0x0e40d4a8), + X(0x0e4aea56), X(0x0e55033b), X(0x0e5f1f56), X(0x0e693ea7), + X(0x0e73612c), X(0x0e7d86e5), X(0x0e87afd3), X(0x0e91dbf3), + X(0x0e9c0b47), X(0x0ea63dcc), X(0x0eb07383), X(0x0ebaac6b), + X(0x0ec4e883), X(0x0ecf27cc), X(0x0ed96a44), X(0x0ee3afea), + X(0x0eedf8bf), X(0x0ef844c2), X(0x0f0293f2), X(0x0f0ce64e), + X(0x0f173bd6), X(0x0f21948a), X(0x0f2bf069), X(0x0f364f72), + X(0x0f40b1a5), X(0x0f4b1701), X(0x0f557f86), X(0x0f5feb32), + X(0x0f6a5a07), X(0x0f74cc02), X(0x0f7f4124), X(0x0f89b96b), + X(0x0f9434d8), X(0x0f9eb369), X(0x0fa9351e), X(0x0fb3b9f7), + X(0x0fbe41f3), X(0x0fc8cd11), X(0x0fd35b51), X(0x0fddecb2), + X(0x0fe88134), X(0x0ff318d6), X(0x0ffdb397), X(0x10085177), + X(0x1012f275), X(0x101d9691), X(0x10283dca), X(0x1032e81f), + X(0x103d9591), X(0x1048461e), X(0x1052f9c5), X(0x105db087), + X(0x10686a62), X(0x10732756), X(0x107de763), X(0x1088aa87), + X(0x109370c2), X(0x109e3a14), X(0x10a9067c), X(0x10b3d5f9), + X(0x10bea88b), X(0x10c97e31), X(0x10d456eb), X(0x10df32b8), + X(0x10ea1197), X(0x10f4f387), X(0x10ffd889), X(0x110ac09b), + X(0x1115abbe), X(0x112099ef), X(0x112b8b2f), X(0x11367f7d), + X(0x114176d9), X(0x114c7141), X(0x11576eb6), X(0x11626f36), + X(0x116d72c1), X(0x11787957), X(0x118382f6), X(0x118e8f9e), + X(0x11999f4f), X(0x11a4b208), X(0x11afc7c7), X(0x11bae08e), + X(0x11c5fc5a), X(0x11d11b2c), X(0x11dc3d02), X(0x11e761dd), + X(0x11f289ba), X(0x11fdb49b), X(0x1208e27e), X(0x12141362), + X(0x121f4748), X(0x122a7e2d), X(0x1235b812), X(0x1240f4f6), + X(0x124c34d9), X(0x125777b9), X(0x1262bd96), X(0x126e0670), + X(0x12795245), X(0x1284a115), X(0x128ff2e0), X(0x129b47a5), + X(0x12a69f63), X(0x12b1fa19), X(0x12bd57c7), X(0x12c8b86c), + X(0x12d41c08), X(0x12df829a), X(0x12eaec21), X(0x12f6589d), + X(0x1301c80c), X(0x130d3a6f), X(0x1318afc4), X(0x1324280b), + X(0x132fa344), X(0x133b216d), X(0x1346a286), X(0x1352268e), + X(0x135dad85), X(0x1369376a), X(0x1374c43c), X(0x138053fb), + X(0x138be6a5), X(0x13977c3b), X(0x13a314bc), X(0x13aeb026), + X(0x13ba4e79), X(0x13c5efb5), X(0x13d193d9), X(0x13dd3ae4), + X(0x13e8e4d6), X(0x13f491ad), X(0x1400416a), X(0x140bf40b), + X(0x1417a98f), X(0x142361f7), X(0x142f1d41), X(0x143adb6d), + X(0x14469c7a), X(0x14526067), X(0x145e2734), X(0x1469f0df), + X(0x1475bd69), X(0x14818cd0), X(0x148d5f15), X(0x14993435), + X(0x14a50c31), X(0x14b0e708), X(0x14bcc4b8), X(0x14c8a542), + X(0x14d488a5), X(0x14e06edf), X(0x14ec57f1), X(0x14f843d9), + X(0x15043297), X(0x1510242b), X(0x151c1892), X(0x15280fcd), + X(0x153409dc), X(0x154006bc), X(0x154c066e), X(0x155808f1), + X(0x15640e44), X(0x15701666), X(0x157c2157), X(0x15882f16), + X(0x15943fa2), X(0x15a052fb), X(0x15ac691f), X(0x15b8820f), + X(0x15c49dc8), X(0x15d0bc4c), X(0x15dcdd98), X(0x15e901ad), + X(0x15f52888), X(0x1601522b), X(0x160d7e93), X(0x1619adc1), + X(0x1625dfb3), X(0x16321469), X(0x163e4be2), X(0x164a861d), + X(0x1656c31a), X(0x166302d8), X(0x166f4555), X(0x167b8a92), + X(0x1687d28e), X(0x16941d47), X(0x16a06abe), X(0x16acbaf0), + X(0x16b90ddf), X(0x16c56388), X(0x16d1bbeb), X(0x16de1708), + X(0x16ea74dd), X(0x16f6d56a), X(0x170338ae), X(0x170f9ea8), + X(0x171c0758), X(0x172872bd), X(0x1734e0d6), X(0x174151a2), + X(0x174dc520), X(0x175a3b51), X(0x1766b432), X(0x17732fc4), + X(0x177fae05), X(0x178c2ef4), X(0x1798b292), X(0x17a538dd), + X(0x17b1c1d4), X(0x17be4d77), X(0x17cadbc5), X(0x17d76cbc), + X(0x17e4005e), X(0x17f096a7), X(0x17fd2f98), X(0x1809cb31), + X(0x1816696f), X(0x18230a53), X(0x182faddc), X(0x183c5408), + X(0x1848fcd8), X(0x1855a849), X(0x1862565d), X(0x186f0711), + X(0x187bba64), X(0x18887057), X(0x189528e9), X(0x18a1e418), + X(0x18aea1e3), X(0x18bb624b), X(0x18c8254e), X(0x18d4eaeb), + X(0x18e1b321), X(0x18ee7df1), X(0x18fb4b58), X(0x19081b57), + X(0x1914edec), X(0x1921c317), X(0x192e9ad6), X(0x193b7529), + X(0x19485210), X(0x19553189), X(0x19621393), X(0x196ef82e), + X(0x197bdf59), X(0x1988c913), X(0x1995b55c), X(0x19a2a432), + X(0x19af9595), X(0x19bc8983), X(0x19c97ffd), X(0x19d67900), + X(0x19e3748e), X(0x19f072a3), X(0x19fd7341), X(0x1a0a7665), + X(0x1a177c10), X(0x1a248440), X(0x1a318ef4), X(0x1a3e9c2c), + X(0x1a4babe7), X(0x1a58be24), X(0x1a65d2e2), X(0x1a72ea20), + X(0x1a8003de), X(0x1a8d201a), X(0x1a9a3ed5), X(0x1aa7600c), + X(0x1ab483bf), X(0x1ac1a9ee), X(0x1aced297), X(0x1adbfdba), + X(0x1ae92b56), X(0x1af65b69), X(0x1b038df4), X(0x1b10c2f5), + X(0x1b1dfa6b), X(0x1b2b3456), X(0x1b3870b5), X(0x1b45af87), + X(0x1b52f0ca), X(0x1b60347f), X(0x1b6d7aa4), X(0x1b7ac339), + X(0x1b880e3c), X(0x1b955bad), X(0x1ba2ab8b), X(0x1baffdd5), + X(0x1bbd528a), X(0x1bcaa9a9), X(0x1bd80332), X(0x1be55f24), + X(0x1bf2bd7d), X(0x1c001e3d), X(0x1c0d8164), X(0x1c1ae6ef), + X(0x1c284edf), X(0x1c35b932), X(0x1c4325e7), X(0x1c5094fe), + X(0x1c5e0677), X(0x1c6b7a4f), X(0x1c78f086), X(0x1c86691b), + X(0x1c93e40d), X(0x1ca1615c), X(0x1caee107), X(0x1cbc630c), + X(0x1cc9e76b), X(0x1cd76e23), X(0x1ce4f733), X(0x1cf2829a), + X(0x1d001057), X(0x1d0da06a), X(0x1d1b32d1), X(0x1d28c78c), + X(0x1d365e9a), X(0x1d43f7f9), X(0x1d5193a9), X(0x1d5f31aa), + X(0x1d6cd1f9), X(0x1d7a7497), X(0x1d881982), X(0x1d95c0ba), + X(0x1da36a3d), X(0x1db1160a), X(0x1dbec422), X(0x1dcc7482), + X(0x1dda272b), X(0x1de7dc1a), X(0x1df59350), X(0x1e034ccb), + X(0x1e11088a), X(0x1e1ec68c), X(0x1e2c86d1), X(0x1e3a4958), + X(0x1e480e20), X(0x1e55d527), X(0x1e639e6d), X(0x1e7169f1), + X(0x1e7f37b2), X(0x1e8d07b0), X(0x1e9ad9e8), X(0x1ea8ae5b), + X(0x1eb68507), X(0x1ec45dec), X(0x1ed23908), X(0x1ee0165b), + X(0x1eedf5e4), X(0x1efbd7a1), X(0x1f09bb92), X(0x1f17a1b6), + X(0x1f258a0d), X(0x1f337494), X(0x1f41614b), X(0x1f4f5032), + X(0x1f5d4147), X(0x1f6b3489), X(0x1f7929f7), X(0x1f872192), + X(0x1f951b56), X(0x1fa31744), X(0x1fb1155b), X(0x1fbf159a), + X(0x1fcd17ff), X(0x1fdb1c8b), X(0x1fe9233b), X(0x1ff72c0f), + X(0x20053706), X(0x20134420), X(0x2021535a), X(0x202f64b4), + X(0x203d782e), X(0x204b8dc6), X(0x2059a57c), X(0x2067bf4e), + X(0x2075db3b), X(0x2083f943), X(0x20921964), X(0x20a03b9e), + X(0x20ae5fef), X(0x20bc8657), X(0x20caaed5), X(0x20d8d967), + X(0x20e7060e), X(0x20f534c7), X(0x21036592), X(0x2111986e), + X(0x211fcd59), X(0x212e0454), X(0x213c3d5d), X(0x214a7873), + X(0x2158b594), X(0x2166f4c1), X(0x217535f8), X(0x21837938), + X(0x2191be81), X(0x21a005d0), X(0x21ae4f26), X(0x21bc9a81), + X(0x21cae7e0), X(0x21d93743), X(0x21e788a8), X(0x21f5dc0e), + X(0x22043174), X(0x221288da), X(0x2220e23e), X(0x222f3da0), + X(0x223d9afe), X(0x224bfa58), X(0x225a5bac), X(0x2268bef9), + X(0x2277243f), X(0x22858b7d), X(0x2293f4b0), X(0x22a25fda), + X(0x22b0ccf8), X(0x22bf3c09), X(0x22cdad0d), X(0x22dc2002), + X(0x22ea94e8), X(0x22f90bbe), X(0x23078482), X(0x2315ff33), + X(0x23247bd1), X(0x2332fa5b), X(0x23417acf), X(0x234ffd2c), + X(0x235e8173), X(0x236d07a0), X(0x237b8fb4), X(0x238a19ae), + X(0x2398a58c), X(0x23a7334d), X(0x23b5c2f1), X(0x23c45477), + X(0x23d2e7dd), X(0x23e17d22), X(0x23f01446), X(0x23fead47), + X(0x240d4825), X(0x241be4dd), X(0x242a8371), X(0x243923dd), + X(0x2447c622), X(0x24566a3e), X(0x24651031), X(0x2473b7f8), + X(0x24826194), X(0x24910d03), X(0x249fba44), X(0x24ae6957), + X(0x24bd1a39), X(0x24cbccea), X(0x24da816a), X(0x24e937b7), + X(0x24f7efcf), X(0x2506a9b3), X(0x25156560), X(0x252422d6), + X(0x2532e215), X(0x2541a31a), X(0x255065e4), X(0x255f2a74), + X(0x256df0c7), X(0x257cb8dd), X(0x258b82b4), X(0x259a4e4c), + X(0x25a91ba4), X(0x25b7eaba), X(0x25c6bb8e), X(0x25d58e1e), + X(0x25e46269), X(0x25f3386e), X(0x2602102d), X(0x2610e9a4), + X(0x261fc4d3), X(0x262ea1b7), X(0x263d8050), X(0x264c609e), + X(0x265b429e), X(0x266a2650), X(0x26790bb3), X(0x2687f2c6), + X(0x2696db88), X(0x26a5c5f7), X(0x26b4b213), X(0x26c39fda), + X(0x26d28f4c), X(0x26e18067), X(0x26f0732b), X(0x26ff6796), + X(0x270e5da7), X(0x271d555d), X(0x272c4eb7), X(0x273b49b5), + X(0x274a4654), X(0x27594495), X(0x27684475), X(0x277745f4), + X(0x27864910), X(0x27954dc9), X(0x27a4541e), X(0x27b35c0d), + X(0x27c26596), X(0x27d170b7), X(0x27e07d6f), X(0x27ef8bbd), + X(0x27fe9ba0), X(0x280dad18), X(0x281cc022), X(0x282bd4be), + X(0x283aeaeb), X(0x284a02a7), X(0x28591bf2), X(0x286836cb), + X(0x28775330), X(0x28867120), X(0x2895909b), X(0x28a4b19e), + X(0x28b3d42a), X(0x28c2f83d), X(0x28d21dd5), X(0x28e144f3), + X(0x28f06d94), X(0x28ff97b8), X(0x290ec35d), X(0x291df082), + X(0x292d1f27), X(0x293c4f4a), X(0x294b80eb), X(0x295ab407), + X(0x2969e89e), X(0x29791eaf), X(0x29885639), X(0x29978f3b), + X(0x29a6c9b3), X(0x29b605a0), X(0x29c54302), X(0x29d481d7), + X(0x29e3c21e), X(0x29f303d6), X(0x2a0246fd), X(0x2a118b94), + X(0x2a20d198), X(0x2a301909), X(0x2a3f61e6), X(0x2a4eac2c), + X(0x2a5df7dc), X(0x2a6d44f4), X(0x2a7c9374), X(0x2a8be359), + X(0x2a9b34a2), X(0x2aaa8750), X(0x2ab9db60), X(0x2ac930d1), + X(0x2ad887a3), X(0x2ae7dfd3), X(0x2af73962), X(0x2b06944e), + X(0x2b15f096), X(0x2b254e38), X(0x2b34ad34), X(0x2b440d89), + X(0x2b536f34), X(0x2b62d236), X(0x2b72368d), X(0x2b819c38), + X(0x2b910336), X(0x2ba06b86), X(0x2bafd526), X(0x2bbf4015), + X(0x2bceac53), X(0x2bde19de), X(0x2bed88b5), X(0x2bfcf8d7), + X(0x2c0c6a43), X(0x2c1bdcf7), X(0x2c2b50f3), X(0x2c3ac635), + X(0x2c4a3cbd), X(0x2c59b488), X(0x2c692d97), X(0x2c78a7e7), + X(0x2c882378), X(0x2c97a049), X(0x2ca71e58), X(0x2cb69da4), + X(0x2cc61e2c), X(0x2cd59ff0), X(0x2ce522ed), X(0x2cf4a723), + X(0x2d042c90), X(0x2d13b334), X(0x2d233b0d), X(0x2d32c41a), + X(0x2d424e5a), X(0x2d51d9cc), X(0x2d61666e), X(0x2d70f440), + X(0x2d808340), X(0x2d90136e), X(0x2d9fa4c7), X(0x2daf374c), + X(0x2dbecafa), X(0x2dce5fd1), X(0x2dddf5cf), X(0x2ded8cf4), + X(0x2dfd253d), X(0x2e0cbeab), X(0x2e1c593b), X(0x2e2bf4ed), + X(0x2e3b91c0), X(0x2e4b2fb1), X(0x2e5acec1), X(0x2e6a6eee), + X(0x2e7a1037), X(0x2e89b29b), X(0x2e995618), X(0x2ea8faad), + X(0x2eb8a05a), X(0x2ec8471c), X(0x2ed7eef4), X(0x2ee797df), + X(0x2ef741dc), X(0x2f06eceb), X(0x2f16990a), X(0x2f264639), + X(0x2f35f475), X(0x2f45a3bd), X(0x2f555412), X(0x2f650570), + X(0x2f74b7d8), X(0x2f846b48), X(0x2f941fbe), X(0x2fa3d53a), + X(0x2fb38bbb), X(0x2fc3433f), X(0x2fd2fbc5), X(0x2fe2b54c), + X(0x2ff26fd3), X(0x30022b58), X(0x3011e7db), X(0x3021a55a), + X(0x303163d4), X(0x30412348), X(0x3050e3b5), X(0x3060a519), + X(0x30706773), X(0x30802ac3), X(0x308fef06), X(0x309fb43d), + X(0x30af7a65), X(0x30bf417d), X(0x30cf0985), X(0x30ded27a), + X(0x30ee9c5d), X(0x30fe672b), X(0x310e32e3), X(0x311dff85), + X(0x312dcd0f), X(0x313d9b80), X(0x314d6ad7), X(0x315d3b12), + X(0x316d0c30), X(0x317cde31), X(0x318cb113), X(0x319c84d4), + X(0x31ac5974), X(0x31bc2ef1), X(0x31cc054b), X(0x31dbdc7f), + X(0x31ebb48e), X(0x31fb8d74), X(0x320b6733), X(0x321b41c7), + X(0x322b1d31), X(0x323af96e), X(0x324ad67e), X(0x325ab45f), + X(0x326a9311), X(0x327a7291), X(0x328a52e0), X(0x329a33fb), + X(0x32aa15e1), X(0x32b9f892), X(0x32c9dc0c), X(0x32d9c04d), + X(0x32e9a555), X(0x32f98b22), X(0x330971b4), X(0x33195909), + X(0x3329411f), X(0x333929f6), X(0x3349138c), X(0x3358fde1), + X(0x3368e8f2), X(0x3378d4c0), X(0x3388c147), X(0x3398ae89), + X(0x33a89c82), X(0x33b88b32), X(0x33c87a98), X(0x33d86ab2), + X(0x33e85b80), X(0x33f84d00), X(0x34083f30), X(0x34183210), + X(0x3428259f), X(0x343819db), X(0x34480ec3), X(0x34580455), + X(0x3467fa92), X(0x3477f176), X(0x3487e902), X(0x3497e134), + X(0x34a7da0a), X(0x34b7d384), X(0x34c7cda0), X(0x34d7c85e), + X(0x34e7c3bb), X(0x34f7bfb7), X(0x3507bc50), X(0x3517b985), + X(0x3527b756), X(0x3537b5c0), X(0x3547b4c3), X(0x3557b45d), + X(0x3567b48d), X(0x3577b552), X(0x3587b6aa), X(0x3597b895), + X(0x35a7bb12), X(0x35b7be1e), X(0x35c7c1b9), X(0x35d7c5e1), + X(0x35e7ca96), X(0x35f7cfd6), X(0x3607d5a0), X(0x3617dbf3), + X(0x3627e2cd), X(0x3637ea2d), X(0x3647f212), X(0x3657fa7b), + X(0x36680366), X(0x36780cd2), X(0x368816bf), X(0x3698212b), + X(0x36a82c14), X(0x36b83779), X(0x36c8435a), X(0x36d84fb4), + X(0x36e85c88), X(0x36f869d2), X(0x37087793), X(0x371885c9), + X(0x37289473), X(0x3738a38f), X(0x3748b31d), X(0x3758c31a), + X(0x3768d387), X(0x3778e461), X(0x3788f5a7), X(0x37990759), + X(0x37a91975), X(0x37b92bf9), X(0x37c93ee4), X(0x37d95236), + X(0x37e965ed), X(0x37f97a08), X(0x38098e85), X(0x3819a363), + X(0x3829b8a2), X(0x3839ce3f), X(0x3849e43a), X(0x3859fa91), + X(0x386a1143), X(0x387a284f), X(0x388a3fb4), X(0x389a5770), + X(0x38aa6f83), X(0x38ba87ea), X(0x38caa0a5), X(0x38dab9b2), + X(0x38ead311), X(0x38faecbf), X(0x390b06bc), X(0x391b2107), + X(0x392b3b9e), X(0x393b5680), X(0x394b71ac), X(0x395b8d20), + X(0x396ba8dc), X(0x397bc4dd), X(0x398be124), X(0x399bfdae), + X(0x39ac1a7a), X(0x39bc3788), X(0x39cc54d5), X(0x39dc7261), + X(0x39ec902a), X(0x39fcae2f), X(0x3a0ccc70), X(0x3a1ceaea), + X(0x3a2d099c), X(0x3a3d2885), X(0x3a4d47a5), X(0x3a5d66f9), + X(0x3a6d8680), X(0x3a7da63a), X(0x3a8dc625), X(0x3a9de63f), + X(0x3aae0688), X(0x3abe26fe), X(0x3ace47a0), X(0x3ade686d), + X(0x3aee8963), X(0x3afeaa82), X(0x3b0ecbc7), X(0x3b1eed32), + X(0x3b2f0ec2), X(0x3b3f3075), X(0x3b4f524a), X(0x3b5f7440), + X(0x3b6f9656), X(0x3b7fb889), X(0x3b8fdada), X(0x3b9ffd46), + X(0x3bb01fce), X(0x3bc0426e), X(0x3bd06526), X(0x3be087f6), + X(0x3bf0aada), X(0x3c00cdd4), X(0x3c10f0e0), X(0x3c2113fe), + X(0x3c31372d), X(0x3c415a6b), X(0x3c517db7), X(0x3c61a110), + X(0x3c71c475), X(0x3c81e7e4), X(0x3c920b5c), X(0x3ca22edc), + X(0x3cb25262), X(0x3cc275ee), X(0x3cd2997e), X(0x3ce2bd11), + X(0x3cf2e0a6), X(0x3d03043b), X(0x3d1327cf), X(0x3d234b61), + X(0x3d336ef0), X(0x3d43927a), X(0x3d53b5ff), X(0x3d63d97c), + X(0x3d73fcf1), X(0x3d84205c), X(0x3d9443bd), X(0x3da46711), + X(0x3db48a58), X(0x3dc4ad91), X(0x3dd4d0ba), X(0x3de4f3d1), + X(0x3df516d7), X(0x3e0539c9), X(0x3e155ca6), X(0x3e257f6d), + X(0x3e35a21d), X(0x3e45c4b4), X(0x3e55e731), X(0x3e660994), + X(0x3e762bda), X(0x3e864e03), X(0x3e96700d), X(0x3ea691f7), + X(0x3eb6b3bf), X(0x3ec6d565), X(0x3ed6f6e8), X(0x3ee71845), + X(0x3ef7397c), X(0x3f075a8c), X(0x3f177b73), X(0x3f279c30), + X(0x3f37bcc2), X(0x3f47dd27), X(0x3f57fd5f), X(0x3f681d68), + X(0x3f783d40), X(0x3f885ce7), X(0x3f987c5c), X(0x3fa89b9c), + X(0x3fb8baa7), X(0x3fc8d97c), X(0x3fd8f819), X(0x3fe9167e), + X(0x3ff934a8), X(0x40095296), X(0x40197049), X(0x40298dbd), + X(0x4039aaf2), X(0x4049c7e7), X(0x4059e49a), X(0x406a010a), + X(0x407a1d36), X(0x408a391d), X(0x409a54bd), X(0x40aa7015), + X(0x40ba8b25), X(0x40caa5ea), X(0x40dac063), X(0x40eada90), + X(0x40faf46e), X(0x410b0dfe), X(0x411b273d), X(0x412b402a), + X(0x413b58c4), X(0x414b710a), X(0x415b88fa), X(0x416ba093), + X(0x417bb7d5), X(0x418bcebe), X(0x419be54c), X(0x41abfb7e), + X(0x41bc1153), X(0x41cc26ca), X(0x41dc3be2), X(0x41ec5099), + X(0x41fc64ef), X(0x420c78e1), X(0x421c8c6f), X(0x422c9f97), + X(0x423cb258), X(0x424cc4b2), X(0x425cd6a2), X(0x426ce827), + X(0x427cf941), X(0x428d09ee), X(0x429d1a2c), X(0x42ad29fb), + X(0x42bd3959), X(0x42cd4846), X(0x42dd56bf), X(0x42ed64c3), + X(0x42fd7252), X(0x430d7f6a), X(0x431d8c0a), X(0x432d9831), + X(0x433da3dd), X(0x434daf0d), X(0x435db9c0), X(0x436dc3f5), + X(0x437dcdab), X(0x438dd6df), X(0x439ddf92), X(0x43ade7c1), + X(0x43bdef6c), X(0x43cdf691), X(0x43ddfd2f), X(0x43ee0345), + X(0x43fe08d2), X(0x440e0dd4), X(0x441e124b), X(0x442e1634), + X(0x443e198f), X(0x444e1c5a), X(0x445e1e95), X(0x446e203e), + X(0x447e2153), X(0x448e21d5), X(0x449e21c0), X(0x44ae2115), + X(0x44be1fd1), X(0x44ce1df4), X(0x44de1b7d), X(0x44ee186a), + X(0x44fe14ba), X(0x450e106b), X(0x451e0b7e), X(0x452e05ef), + X(0x453dffbf), X(0x454df8eb), X(0x455df173), X(0x456de956), + X(0x457de092), X(0x458dd726), X(0x459dcd10), X(0x45adc251), + X(0x45bdb6e5), X(0x45cdaacd), X(0x45dd9e06), X(0x45ed9091), + X(0x45fd826a), X(0x460d7392), X(0x461d6407), X(0x462d53c8), + X(0x463d42d4), X(0x464d3129), X(0x465d1ec6), X(0x466d0baa), + X(0x467cf7d3), X(0x468ce342), X(0x469ccdf3), X(0x46acb7e7), + X(0x46bca11c), X(0x46cc8990), X(0x46dc7143), X(0x46ec5833), + X(0x46fc3e5f), X(0x470c23c6), X(0x471c0867), X(0x472bec40), + X(0x473bcf50), X(0x474bb196), X(0x475b9311), X(0x476b73c0), + X(0x477b53a1), X(0x478b32b4), X(0x479b10f6), X(0x47aaee67), + X(0x47bacb06), X(0x47caa6d1), X(0x47da81c7), X(0x47ea5be7), + X(0x47fa3530), X(0x480a0da1), X(0x4819e537), X(0x4829bbf3), + X(0x483991d3), X(0x484966d6), X(0x48593afb), X(0x48690e3f), + X(0x4878e0a3), X(0x4888b225), X(0x489882c4), X(0x48a8527e), + X(0x48b82153), X(0x48c7ef41), X(0x48d7bc47), X(0x48e78863), + X(0x48f75396), X(0x49071ddc), X(0x4916e736), X(0x4926afa2), + X(0x4936771f), X(0x49463dac), X(0x49560347), X(0x4965c7ef), + X(0x49758ba4), X(0x49854e63), X(0x4995102c), X(0x49a4d0fe), + X(0x49b490d7), X(0x49c44fb6), X(0x49d40d9a), X(0x49e3ca82), + X(0x49f3866c), X(0x4a034159), X(0x4a12fb45), X(0x4a22b430), + X(0x4a326c19), X(0x4a4222ff), X(0x4a51d8e1), X(0x4a618dbd), + X(0x4a714192), X(0x4a80f45f), X(0x4a90a623), X(0x4aa056dd), + X(0x4ab0068b), X(0x4abfb52c), X(0x4acf62c0), X(0x4adf0f44), + X(0x4aeebab9), X(0x4afe651c), X(0x4b0e0e6c), X(0x4b1db6a9), + X(0x4b2d5dd1), X(0x4b3d03e2), X(0x4b4ca8dd), X(0x4b5c4cbf), + X(0x4b6bef88), X(0x4b7b9136), X(0x4b8b31c8), X(0x4b9ad13d), + X(0x4baa6f93), X(0x4bba0ccb), X(0x4bc9a8e2), X(0x4bd943d7), + X(0x4be8dda9), X(0x4bf87658), X(0x4c080de1), X(0x4c17a444), + X(0x4c27397f), X(0x4c36cd92), X(0x4c46607b), X(0x4c55f239), + X(0x4c6582cb), X(0x4c75122f), X(0x4c84a065), X(0x4c942d6c), + X(0x4ca3b942), X(0x4cb343e6), X(0x4cc2cd57), X(0x4cd25594), + X(0x4ce1dc9c), X(0x4cf1626d), X(0x4d00e707), X(0x4d106a68), + X(0x4d1fec8f), X(0x4d2f6d7a), X(0x4d3eed2a), X(0x4d4e6b9d), + X(0x4d5de8d1), X(0x4d6d64c5), X(0x4d7cdf79), X(0x4d8c58eb), + X(0x4d9bd11a), X(0x4dab4804), X(0x4dbabdaa), X(0x4dca3209), + X(0x4dd9a520), X(0x4de916ef), X(0x4df88774), X(0x4e07f6ae), + X(0x4e17649c), X(0x4e26d13c), X(0x4e363c8f), X(0x4e45a692), + X(0x4e550f44), X(0x4e6476a4), X(0x4e73dcb2), X(0x4e83416c), + X(0x4e92a4d1), X(0x4ea206df), X(0x4eb16796), X(0x4ec0c6f5), + X(0x4ed024fa), X(0x4edf81a5), X(0x4eeedcf3), X(0x4efe36e5), + X(0x4f0d8f79), X(0x4f1ce6ad), X(0x4f2c3c82), X(0x4f3b90f4), + X(0x4f4ae405), X(0x4f5a35b1), X(0x4f6985fa), X(0x4f78d4dc), + X(0x4f882257), X(0x4f976e6a), X(0x4fa6b914), X(0x4fb60254), + X(0x4fc54a28), X(0x4fd49090), X(0x4fe3d58b), X(0x4ff31917), + X(0x50025b33), X(0x50119bde), X(0x5020db17), X(0x503018dd), + X(0x503f552f), X(0x504e900b), X(0x505dc971), X(0x506d0160), + X(0x507c37d7), X(0x508b6cd3), X(0x509aa055), X(0x50a9d25b), + X(0x50b902e4), X(0x50c831ef), X(0x50d75f7b), X(0x50e68b87), + X(0x50f5b612), X(0x5104df1a), X(0x5114069f), X(0x51232ca0), + X(0x5132511a), X(0x5141740f), X(0x5150957b), X(0x515fb55f), + X(0x516ed3b8), X(0x517df087), X(0x518d0bca), X(0x519c257f), + X(0x51ab3da7), X(0x51ba543f), X(0x51c96947), X(0x51d87cbd), + X(0x51e78ea1), X(0x51f69ef1), X(0x5205adad), X(0x5214bad3), + X(0x5223c662), X(0x5232d05a), X(0x5241d8b9), X(0x5250df7d), + X(0x525fe4a7), X(0x526ee835), X(0x527dea26), X(0x528cea78), + X(0x529be92c), X(0x52aae63f), X(0x52b9e1b0), X(0x52c8db80), + X(0x52d7d3ac), X(0x52e6ca33), X(0x52f5bf15), X(0x5304b251), + X(0x5313a3e5), X(0x532293d0), X(0x53318212), X(0x53406ea8), + X(0x534f5993), X(0x535e42d2), X(0x536d2a62), X(0x537c1043), + X(0x538af475), X(0x5399d6f6), X(0x53a8b7c4), X(0x53b796e0), + X(0x53c67447), X(0x53d54ffa), X(0x53e429f6), X(0x53f3023b), + X(0x5401d8c8), X(0x5410ad9c), X(0x541f80b5), X(0x542e5213), + X(0x543d21b5), X(0x544bef9a), X(0x545abbc0), X(0x54698627), + X(0x54784ece), X(0x548715b3), X(0x5495dad6), X(0x54a49e35), + X(0x54b35fd0), X(0x54c21fa6), X(0x54d0ddb5), X(0x54df99fd), + X(0x54ee547c), X(0x54fd0d32), X(0x550bc41d), X(0x551a793d), + X(0x55292c91), X(0x5537de16), X(0x55468dce), X(0x55553bb6), + X(0x5563e7cd), X(0x55729213), X(0x55813a87), X(0x558fe127), + X(0x559e85f2), X(0x55ad28e9), X(0x55bbca08), X(0x55ca6950), + X(0x55d906c0), X(0x55e7a257), X(0x55f63c13), X(0x5604d3f4), + X(0x561369f8), X(0x5621fe1f), X(0x56309067), X(0x563f20d1), + X(0x564daf5a), X(0x565c3c02), X(0x566ac6c7), X(0x56794faa), + X(0x5687d6a8), X(0x56965bc1), X(0x56a4def4), X(0x56b36040), + X(0x56c1dfa4), X(0x56d05d1f), X(0x56ded8af), X(0x56ed5255), + X(0x56fbca0f), X(0x570a3fdc), X(0x5718b3bc), X(0x572725ac), + X(0x573595ad), X(0x574403bd), X(0x57526fdb), X(0x5760da07), + X(0x576f423f), X(0x577da883), X(0x578c0cd1), X(0x579a6f29), + X(0x57a8cf8a), X(0x57b72df2), X(0x57c58a61), X(0x57d3e4d6), + X(0x57e23d50), X(0x57f093cd), X(0x57fee84e), X(0x580d3ad1), + X(0x581b8b54), X(0x5829d9d8), X(0x5838265c), X(0x584670dd), + X(0x5854b95c), X(0x5862ffd8), X(0x5871444f), X(0x587f86c1), + X(0x588dc72c), X(0x589c0591), X(0x58aa41ed), X(0x58b87c40), + X(0x58c6b489), X(0x58d4eac7), X(0x58e31ef9), X(0x58f1511f), + X(0x58ff8137), X(0x590daf40), X(0x591bdb3a), X(0x592a0524), + X(0x59382cfc), X(0x594652c2), X(0x59547675), X(0x59629815), + X(0x5970b79f), X(0x597ed513), X(0x598cf071), X(0x599b09b7), + X(0x59a920e5), X(0x59b735f9), X(0x59c548f4), X(0x59d359d2), + X(0x59e16895), X(0x59ef753b), X(0x59fd7fc4), X(0x5a0b882d), + X(0x5a198e77), X(0x5a2792a0), X(0x5a3594a9), X(0x5a43948e), + X(0x5a519251), X(0x5a5f8df0), X(0x5a6d876a), X(0x5a7b7ebe), + X(0x5a8973ec), X(0x5a9766f2), X(0x5aa557d0), X(0x5ab34685), + X(0x5ac1330f), X(0x5acf1d6f), X(0x5add05a3), X(0x5aeaebaa), + X(0x5af8cf84), X(0x5b06b12f), X(0x5b1490ab), X(0x5b226df7), + X(0x5b304912), X(0x5b3e21fc), X(0x5b4bf8b2), X(0x5b59cd35), + X(0x5b679f84), X(0x5b756f9e), X(0x5b833d82), X(0x5b91092e), + X(0x5b9ed2a3), X(0x5bac99e0), X(0x5bba5ee3), X(0x5bc821ac), + X(0x5bd5e23a), X(0x5be3a08c), X(0x5bf15ca1), X(0x5bff1679), + X(0x5c0cce12), X(0x5c1a836c), X(0x5c283686), X(0x5c35e760), + X(0x5c4395f7), X(0x5c51424c), X(0x5c5eec5e), X(0x5c6c942b), + X(0x5c7a39b4), X(0x5c87dcf7), X(0x5c957df3), X(0x5ca31ca8), + X(0x5cb0b915), X(0x5cbe5338), X(0x5ccbeb12), X(0x5cd980a1), + X(0x5ce713e5), X(0x5cf4a4dd), X(0x5d023387), X(0x5d0fbfe4), + X(0x5d1d49f2), X(0x5d2ad1b1), X(0x5d38571f), X(0x5d45da3c), + X(0x5d535b08), X(0x5d60d981), X(0x5d6e55a7), X(0x5d7bcf78), + X(0x5d8946f5), X(0x5d96bc1c), X(0x5da42eec), X(0x5db19f65), + X(0x5dbf0d86), X(0x5dcc794e), X(0x5dd9e2bd), X(0x5de749d1), + X(0x5df4ae8a), X(0x5e0210e7), X(0x5e0f70e7), X(0x5e1cce8a), + X(0x5e2a29ce), X(0x5e3782b4), X(0x5e44d93a), X(0x5e522d5f), + X(0x5e5f7f23), X(0x5e6cce85), X(0x5e7a1b85), X(0x5e876620), + X(0x5e94ae58), X(0x5ea1f42a), X(0x5eaf3797), X(0x5ebc789d), + X(0x5ec9b73c), X(0x5ed6f372), X(0x5ee42d41), X(0x5ef164a5), + X(0x5efe999f), X(0x5f0bcc2f), X(0x5f18fc52), X(0x5f262a09), + X(0x5f335553), X(0x5f407e2f), X(0x5f4da49d), X(0x5f5ac89b), + X(0x5f67ea29), X(0x5f750946), X(0x5f8225f2), X(0x5f8f402b), + X(0x5f9c57f2), X(0x5fa96d44), X(0x5fb68023), X(0x5fc3908c), + X(0x5fd09e7f), X(0x5fdda9fc), X(0x5feab302), X(0x5ff7b990), + X(0x6004bda5), X(0x6011bf40), X(0x601ebe62), X(0x602bbb09), + X(0x6038b534), X(0x6045ace4), X(0x6052a216), X(0x605f94cb), + X(0x606c8502), X(0x607972b9), X(0x60865df2), X(0x609346aa), + X(0x60a02ce1), X(0x60ad1096), X(0x60b9f1c9), X(0x60c6d079), + X(0x60d3aca5), X(0x60e0864d), X(0x60ed5d70), X(0x60fa320d), + X(0x61070424), X(0x6113d3b4), X(0x6120a0bc), X(0x612d6b3c), + X(0x613a3332), X(0x6146f89f), X(0x6153bb82), X(0x61607bd9), + X(0x616d39a5), X(0x6179f4e5), X(0x6186ad98), X(0x619363bd), + X(0x61a01753), X(0x61acc85b), X(0x61b976d3), X(0x61c622bc), + X(0x61d2cc13), X(0x61df72d8), X(0x61ec170c), X(0x61f8b8ad), + X(0x620557ba), X(0x6211f434), X(0x621e8e18), X(0x622b2568), + X(0x6237ba21), X(0x62444c44), X(0x6250dbd0), X(0x625d68c4), + X(0x6269f320), X(0x62767ae2), X(0x6283000b), X(0x628f829a), + X(0x629c028e), X(0x62a87fe6), X(0x62b4faa2), X(0x62c172c2), + X(0x62cde844), X(0x62da5b29), X(0x62e6cb6e), X(0x62f33915), + X(0x62ffa41c), X(0x630c0c83), X(0x63187248), X(0x6324d56d), + X(0x633135ef), X(0x633d93ce), X(0x6349ef0b), X(0x635647a3), + X(0x63629d97), X(0x636ef0e6), X(0x637b418f), X(0x63878f92), + X(0x6393daef), X(0x63a023a4), X(0x63ac69b1), X(0x63b8ad15), + X(0x63c4edd1), X(0x63d12be3), X(0x63dd674b), X(0x63e9a008), + X(0x63f5d61a), X(0x64020980), X(0x640e3a39), X(0x641a6846), + X(0x642693a5), X(0x6432bc56), X(0x643ee258), X(0x644b05ab), + X(0x6457264e), X(0x64634441), X(0x646f5f83), X(0x647b7814), + X(0x64878df3), X(0x6493a120), X(0x649fb199), X(0x64abbf5f), + X(0x64b7ca71), X(0x64c3d2ce), X(0x64cfd877), X(0x64dbdb69), + X(0x64e7dba6), X(0x64f3d92b), X(0x64ffd3fa), X(0x650bcc11), + X(0x6517c16f), X(0x6523b415), X(0x652fa402), X(0x653b9134), + X(0x65477bad), X(0x6553636a), X(0x655f486d), X(0x656b2ab3), + X(0x65770a3d), X(0x6582e70a), X(0x658ec11a), X(0x659a986d), + X(0x65a66d00), X(0x65b23ed5), X(0x65be0deb), X(0x65c9da41), + X(0x65d5a3d7), X(0x65e16aac), X(0x65ed2ebf), X(0x65f8f011), + X(0x6604aea1), X(0x66106a6e), X(0x661c2377), X(0x6627d9be), + X(0x66338d40), X(0x663f3dfd), X(0x664aebf5), X(0x66569728), + X(0x66623f95), X(0x666de53b), X(0x6679881b), X(0x66852833), + X(0x6690c583), X(0x669c600b), X(0x66a7f7ca), X(0x66b38cc0), + X(0x66bf1eec), X(0x66caae4f), X(0x66d63ae6), X(0x66e1c4b3), + X(0x66ed4bb4), X(0x66f8cfea), X(0x67045153), X(0x670fcfef), + X(0x671b4bbe), X(0x6726c4bf), X(0x67323af3), X(0x673dae58), + X(0x67491eee), X(0x67548cb5), X(0x675ff7ab), X(0x676b5fd2), + X(0x6776c528), X(0x678227ad), X(0x678d8761), X(0x6798e443), + X(0x67a43e52), X(0x67af958f), X(0x67bae9f9), X(0x67c63b8f), + X(0x67d18a52), X(0x67dcd640), X(0x67e81f59), X(0x67f3659d), + X(0x67fea90c), X(0x6809e9a5), X(0x68152768), X(0x68206254), + X(0x682b9a68), X(0x6836cfa6), X(0x6842020b), X(0x684d3199), + X(0x68585e4d), X(0x68638829), X(0x686eaf2b), X(0x6879d354), + X(0x6884f4a2), X(0x68901316), X(0x689b2eb0), X(0x68a6476d), + X(0x68b15d50), X(0x68bc7056), X(0x68c78080), X(0x68d28dcd), + X(0x68dd983e), X(0x68e89fd0), X(0x68f3a486), X(0x68fea65d), + X(0x6909a555), X(0x6914a16f), X(0x691f9aa9), X(0x692a9104), + X(0x69358480), X(0x6940751b), X(0x694b62d5), X(0x69564daf), + X(0x696135a7), X(0x696c1abe), X(0x6976fcf3), X(0x6981dc46), + X(0x698cb8b6), X(0x69979243), X(0x69a268ed), X(0x69ad3cb4), + X(0x69b80d97), X(0x69c2db96), X(0x69cda6b0), X(0x69d86ee5), + X(0x69e33436), X(0x69edf6a1), X(0x69f8b626), X(0x6a0372c5), + X(0x6a0e2c7e), X(0x6a18e350), X(0x6a23973c), X(0x6a2e4840), + X(0x6a38f65d), X(0x6a43a191), X(0x6a4e49de), X(0x6a58ef42), + X(0x6a6391be), X(0x6a6e3151), X(0x6a78cdfa), X(0x6a8367ba), + X(0x6a8dfe90), X(0x6a98927c), X(0x6aa3237d), X(0x6aadb194), + X(0x6ab83cc0), X(0x6ac2c500), X(0x6acd4a55), X(0x6ad7ccbf), + X(0x6ae24c3c), X(0x6aecc8cd), X(0x6af74271), X(0x6b01b929), + X(0x6b0c2cf4), X(0x6b169dd1), X(0x6b210bc1), X(0x6b2b76c2), + X(0x6b35ded6), X(0x6b4043fc), X(0x6b4aa632), X(0x6b55057a), + X(0x6b5f61d3), X(0x6b69bb3d), X(0x6b7411b7), X(0x6b7e6541), + X(0x6b88b5db), X(0x6b930385), X(0x6b9d4e3f), X(0x6ba79607), + X(0x6bb1dadf), X(0x6bbc1cc6), X(0x6bc65bbb), X(0x6bd097bf), + X(0x6bdad0d0), X(0x6be506f0), X(0x6bef3a1d), X(0x6bf96a58), + X(0x6c0397a0), X(0x6c0dc1f5), X(0x6c17e957), X(0x6c220dc6), + X(0x6c2c2f41), X(0x6c364dc9), X(0x6c40695c), X(0x6c4a81fc), + X(0x6c5497a7), X(0x6c5eaa5d), X(0x6c68ba1f), X(0x6c72c6eb), + X(0x6c7cd0c3), X(0x6c86d7a6), X(0x6c90db92), X(0x6c9adc8a), + X(0x6ca4da8b), X(0x6caed596), X(0x6cb8cdab), X(0x6cc2c2ca), + X(0x6cccb4f2), X(0x6cd6a424), X(0x6ce0905e), X(0x6cea79a1), + X(0x6cf45fee), X(0x6cfe4342), X(0x6d0823a0), X(0x6d120105), + X(0x6d1bdb73), X(0x6d25b2e8), X(0x6d2f8765), X(0x6d3958ea), + X(0x6d432777), X(0x6d4cf30a), X(0x6d56bba5), X(0x6d608147), + X(0x6d6a43f0), X(0x6d7403a0), X(0x6d7dc056), X(0x6d877a13), + X(0x6d9130d6), X(0x6d9ae4a0), X(0x6da4956f), X(0x6dae4345), + X(0x6db7ee20), X(0x6dc19601), X(0x6dcb3ae7), X(0x6dd4dcd3), + X(0x6dde7bc4), X(0x6de817bb), X(0x6df1b0b6), X(0x6dfb46b7), + X(0x6e04d9bc), X(0x6e0e69c7), X(0x6e17f6d5), X(0x6e2180e9), + X(0x6e2b0801), X(0x6e348c1d), X(0x6e3e0d3d), X(0x6e478b62), + X(0x6e51068a), X(0x6e5a7eb7), X(0x6e63f3e7), X(0x6e6d661b), + X(0x6e76d552), X(0x6e80418e), X(0x6e89aacc), X(0x6e93110f), + X(0x6e9c7454), X(0x6ea5d49d), X(0x6eaf31e9), X(0x6eb88c37), + X(0x6ec1e389), X(0x6ecb37de), X(0x6ed48936), X(0x6eddd790), + X(0x6ee722ee), X(0x6ef06b4d), X(0x6ef9b0b0), X(0x6f02f315), + X(0x6f0c327c), X(0x6f156ee6), X(0x6f1ea852), X(0x6f27dec1), + X(0x6f311232), X(0x6f3a42a5), X(0x6f43701a), X(0x6f4c9a91), + X(0x6f55c20a), X(0x6f5ee686), X(0x6f680803), X(0x6f712682), + X(0x6f7a4203), X(0x6f835a86), X(0x6f8c700b), X(0x6f958291), + X(0x6f9e921a), X(0x6fa79ea4), X(0x6fb0a830), X(0x6fb9aebd), + X(0x6fc2b24c), X(0x6fcbb2dd), X(0x6fd4b06f), X(0x6fddab03), + X(0x6fe6a299), X(0x6fef9730), X(0x6ff888c9), X(0x70017763), + X(0x700a62ff), X(0x70134b9c), X(0x701c313b), X(0x702513dc), + X(0x702df37e), X(0x7036d021), X(0x703fa9c6), X(0x7048806d), + X(0x70515415), X(0x705a24bf), X(0x7062f26b), X(0x706bbd17), + X(0x707484c6), X(0x707d4976), X(0x70860b28), X(0x708ec9dc), + X(0x70978591), X(0x70a03e48), X(0x70a8f400), X(0x70b1a6bb), + X(0x70ba5677), X(0x70c30335), X(0x70cbacf5), X(0x70d453b6), + X(0x70dcf77a), X(0x70e59840), X(0x70ee3607), X(0x70f6d0d1), + X(0x70ff689d), X(0x7107fd6b), X(0x71108f3b), X(0x71191e0d), + X(0x7121a9e2), X(0x712a32b9), X(0x7132b892), X(0x713b3b6e), + X(0x7143bb4c), X(0x714c382d), X(0x7154b211), X(0x715d28f7), + X(0x71659ce0), X(0x716e0dcc), X(0x71767bbb), X(0x717ee6ac), + X(0x71874ea1), X(0x718fb399), X(0x71981594), X(0x71a07493), + X(0x71a8d094), X(0x71b1299a), X(0x71b97fa2), X(0x71c1d2af), + X(0x71ca22bf), X(0x71d26fd2), X(0x71dab9ea), X(0x71e30106), + X(0x71eb4526), X(0x71f3864a), X(0x71fbc472), X(0x7203ff9e), + X(0x720c37cf), X(0x72146d05), X(0x721c9f3f), X(0x7224ce7e), + X(0x722cfac2), X(0x7235240b), X(0x723d4a59), X(0x72456dad), + X(0x724d8e05), X(0x7255ab63), X(0x725dc5c7), X(0x7265dd31), + X(0x726df1a0), X(0x72760315), X(0x727e1191), X(0x72861d12), + X(0x728e259a), X(0x72962b28), X(0x729e2dbd), X(0x72a62d59), + X(0x72ae29fc), X(0x72b623a5), X(0x72be1a56), X(0x72c60e0e), + X(0x72cdfece), X(0x72d5ec95), X(0x72ddd764), X(0x72e5bf3b), + X(0x72eda41a), X(0x72f58601), X(0x72fd64f1), X(0x730540e9), + X(0x730d19e9), X(0x7314eff3), X(0x731cc305), X(0x73249321), + X(0x732c6046), X(0x73342a75), X(0x733bf1ad), X(0x7343b5ef), + X(0x734b773b), X(0x73533591), X(0x735af0f2), X(0x7362a95d), + X(0x736a5ed3), X(0x73721153), X(0x7379c0df), X(0x73816d76), + X(0x73891719), X(0x7390bdc7), X(0x73986181), X(0x73a00247), + X(0x73a7a01a), X(0x73af3af8), X(0x73b6d2e4), X(0x73be67dc), + X(0x73c5f9e1), X(0x73cd88f3), X(0x73d51513), X(0x73dc9e40), + X(0x73e4247c), X(0x73eba7c5), X(0x73f3281c), X(0x73faa582), + X(0x74021ff7), X(0x7409977b), X(0x74110c0d), X(0x74187daf), + X(0x741fec61), X(0x74275822), X(0x742ec0f3), X(0x743626d5), + X(0x743d89c7), X(0x7444e9c9), X(0x744c46dd), X(0x7453a101), + X(0x745af837), X(0x74624c7f), X(0x74699dd8), X(0x7470ec44), + X(0x747837c2), X(0x747f8052), X(0x7486c5f5), X(0x748e08ac), + X(0x74954875), X(0x749c8552), X(0x74a3bf43), X(0x74aaf648), + X(0x74b22a62), X(0x74b95b90), X(0x74c089d2), X(0x74c7b52a), + X(0x74cedd97), X(0x74d6031a), X(0x74dd25b2), X(0x74e44561), + X(0x74eb6226), X(0x74f27c02), X(0x74f992f5), X(0x7500a6ff), + X(0x7507b820), X(0x750ec659), X(0x7515d1aa), X(0x751cda14), + X(0x7523df96), X(0x752ae231), X(0x7531e1e5), X(0x7538deb2), + X(0x753fd89a), X(0x7546cf9b), X(0x754dc3b7), X(0x7554b4ed), + X(0x755ba33e), X(0x75628eaa), X(0x75697732), X(0x75705cd5), + X(0x75773f95), X(0x757e1f71), X(0x7584fc6a), X(0x758bd67f), + X(0x7592adb2), X(0x75998203), X(0x75a05371), X(0x75a721fe), + X(0x75adeda9), X(0x75b4b673), X(0x75bb7c5c), X(0x75c23f65), + X(0x75c8ff8d), X(0x75cfbcd6), X(0x75d6773f), X(0x75dd2ec8), + X(0x75e3e373), X(0x75ea953f), X(0x75f1442d), X(0x75f7f03d), + X(0x75fe996f), X(0x76053fc5), X(0x760be33d), X(0x761283d8), + X(0x76192197), X(0x761fbc7b), X(0x76265482), X(0x762ce9af), + X(0x76337c01), X(0x763a0b78), X(0x76409814), X(0x764721d7), + X(0x764da8c1), X(0x76542cd1), X(0x765aae08), X(0x76612c67), + X(0x7667a7ee), X(0x766e209d), X(0x76749675), X(0x767b0975), + X(0x7681799f), X(0x7687e6f3), X(0x768e5170), X(0x7694b918), + X(0x769b1deb), X(0x76a17fe9), X(0x76a7df13), X(0x76ae3b68), + X(0x76b494ea), X(0x76baeb98), X(0x76c13f74), X(0x76c7907c), + X(0x76cddeb3), X(0x76d42a18), X(0x76da72ab), X(0x76e0b86d), + X(0x76e6fb5e), X(0x76ed3b7f), X(0x76f378d0), X(0x76f9b352), + X(0x76ffeb05), X(0x77061fe8), X(0x770c51fe), X(0x77128145), + X(0x7718adbf), X(0x771ed76c), X(0x7724fe4c), X(0x772b225f), + X(0x773143a7), X(0x77376223), X(0x773d7dd3), X(0x774396ba), + X(0x7749acd5), X(0x774fc027), X(0x7755d0af), X(0x775bde6f), + X(0x7761e965), X(0x7767f193), X(0x776df6fa), X(0x7773f998), + X(0x7779f970), X(0x777ff681), X(0x7785f0cd), X(0x778be852), + X(0x7791dd12), X(0x7797cf0d), X(0x779dbe43), X(0x77a3aab6), + X(0x77a99465), X(0x77af7b50), X(0x77b55f79), X(0x77bb40e0), + X(0x77c11f85), X(0x77c6fb68), X(0x77ccd48a), X(0x77d2aaec), + X(0x77d87e8d), X(0x77de4f6f), X(0x77e41d92), X(0x77e9e8f5), + X(0x77efb19b), X(0x77f57782), X(0x77fb3aad), X(0x7800fb1a), + X(0x7806b8ca), X(0x780c73bf), X(0x78122bf7), X(0x7817e175), + X(0x781d9438), X(0x78234440), X(0x7828f18f), X(0x782e9c25), + X(0x78344401), X(0x7839e925), X(0x783f8b92), X(0x78452b46), + X(0x784ac844), X(0x7850628b), X(0x7855fa1c), X(0x785b8ef8), + X(0x7861211e), X(0x7866b090), X(0x786c3d4d), X(0x7871c757), + X(0x78774ead), X(0x787cd351), X(0x78825543), X(0x7887d483), + X(0x788d5111), X(0x7892caef), X(0x7898421c), X(0x789db69a), + X(0x78a32868), X(0x78a89787), X(0x78ae03f8), X(0x78b36dbb), + X(0x78b8d4d1), X(0x78be393a), X(0x78c39af6), X(0x78c8fa06), + X(0x78ce566c), X(0x78d3b026), X(0x78d90736), X(0x78de5b9c), + X(0x78e3ad58), X(0x78e8fc6c), X(0x78ee48d7), X(0x78f3929b), + X(0x78f8d9b7), X(0x78fe1e2c), X(0x79035ffb), X(0x79089f24), + X(0x790ddba8), X(0x79131587), X(0x79184cc2), X(0x791d8159), + X(0x7922b34d), X(0x7927e29e), X(0x792d0f4d), X(0x7932395a), + X(0x793760c6), X(0x793c8591), X(0x7941a7bd), X(0x7946c749), + X(0x794be435), X(0x7950fe84), X(0x79561634), X(0x795b2b47), + X(0x79603dbc), X(0x79654d96), X(0x796a5ad4), X(0x796f6576), + X(0x79746d7e), X(0x797972eb), X(0x797e75bf), X(0x798375f9), + X(0x7988739b), X(0x798d6ea5), X(0x79926717), X(0x79975cf2), + X(0x799c5037), X(0x79a140e6), X(0x79a62f00), X(0x79ab1a85), + X(0x79b00376), X(0x79b4e9d3), X(0x79b9cd9d), X(0x79beaed4), + X(0x79c38d79), X(0x79c8698d), X(0x79cd4310), X(0x79d21a03), + X(0x79d6ee66), X(0x79dbc03a), X(0x79e08f7f), X(0x79e55c36), + X(0x79ea265f), X(0x79eeedfc), X(0x79f3b30c), X(0x79f87590), + X(0x79fd3589), X(0x7a01f2f7), X(0x7a06addc), X(0x7a0b6636), + X(0x7a101c08), X(0x7a14cf52), X(0x7a198013), X(0x7a1e2e4d), + X(0x7a22da01), X(0x7a27832f), X(0x7a2c29d7), X(0x7a30cdfa), + X(0x7a356f99), X(0x7a3a0eb4), X(0x7a3eab4c), X(0x7a434561), + X(0x7a47dcf5), X(0x7a4c7207), X(0x7a510498), X(0x7a5594a9), + X(0x7a5a223a), X(0x7a5ead4d), X(0x7a6335e0), X(0x7a67bbf6), + X(0x7a6c3f8f), X(0x7a70c0ab), X(0x7a753f4b), X(0x7a79bb6f), + X(0x7a7e3519), X(0x7a82ac48), X(0x7a8720fe), X(0x7a8b933b), + X(0x7a9002ff), X(0x7a94704b), X(0x7a98db20), X(0x7a9d437e), + X(0x7aa1a967), X(0x7aa60cd9), X(0x7aaa6dd7), X(0x7aaecc61), + X(0x7ab32877), X(0x7ab7821b), X(0x7abbd94b), X(0x7ac02e0a), + X(0x7ac48058), X(0x7ac8d035), X(0x7acd1da3), X(0x7ad168a1), + X(0x7ad5b130), X(0x7ad9f751), X(0x7ade3b05), X(0x7ae27c4c), + X(0x7ae6bb27), X(0x7aeaf796), X(0x7aef319a), X(0x7af36934), + X(0x7af79e64), X(0x7afbd12c), X(0x7b00018a), X(0x7b042f81), + X(0x7b085b10), X(0x7b0c8439), X(0x7b10aafc), X(0x7b14cf5a), + X(0x7b18f153), X(0x7b1d10e8), X(0x7b212e1a), X(0x7b2548e9), + X(0x7b296155), X(0x7b2d7761), X(0x7b318b0b), X(0x7b359c55), + X(0x7b39ab3f), X(0x7b3db7cb), X(0x7b41c1f8), X(0x7b45c9c8), + X(0x7b49cf3b), X(0x7b4dd251), X(0x7b51d30b), X(0x7b55d16b), + X(0x7b59cd70), X(0x7b5dc71b), X(0x7b61be6d), X(0x7b65b366), + X(0x7b69a608), X(0x7b6d9653), X(0x7b718447), X(0x7b756fe5), + X(0x7b79592e), X(0x7b7d4022), X(0x7b8124c3), X(0x7b850710), + X(0x7b88e70a), X(0x7b8cc4b3), X(0x7b90a00a), X(0x7b947911), + X(0x7b984fc8), X(0x7b9c242f), X(0x7b9ff648), X(0x7ba3c612), + X(0x7ba79390), X(0x7bab5ec1), X(0x7baf27a5), X(0x7bb2ee3f), + X(0x7bb6b28e), X(0x7bba7493), X(0x7bbe344e), X(0x7bc1f1c1), + X(0x7bc5acec), X(0x7bc965cf), X(0x7bcd1c6c), X(0x7bd0d0c3), + X(0x7bd482d4), X(0x7bd832a1), X(0x7bdbe02a), X(0x7bdf8b70), + X(0x7be33473), X(0x7be6db34), X(0x7bea7fb4), X(0x7bee21f4), + X(0x7bf1c1f3), X(0x7bf55fb3), X(0x7bf8fb35), X(0x7bfc9479), + X(0x7c002b7f), X(0x7c03c04a), X(0x7c0752d8), X(0x7c0ae32b), + X(0x7c0e7144), X(0x7c11fd23), X(0x7c1586c9), X(0x7c190e36), + X(0x7c1c936c), X(0x7c20166b), X(0x7c239733), X(0x7c2715c6), + X(0x7c2a9224), X(0x7c2e0c4e), X(0x7c318444), X(0x7c34fa07), + X(0x7c386d98), X(0x7c3bdef8), X(0x7c3f4e26), X(0x7c42bb25), + X(0x7c4625f4), X(0x7c498e95), X(0x7c4cf507), X(0x7c50594c), + X(0x7c53bb65), X(0x7c571b51), X(0x7c5a7913), X(0x7c5dd4aa), + X(0x7c612e17), X(0x7c64855b), X(0x7c67da76), X(0x7c6b2d6a), + X(0x7c6e7e37), X(0x7c71ccdd), X(0x7c75195e), X(0x7c7863ba), + X(0x7c7babf1), X(0x7c7ef206), X(0x7c8235f7), X(0x7c8577c6), + X(0x7c88b774), X(0x7c8bf502), X(0x7c8f306f), X(0x7c9269bd), + X(0x7c95a0ec), X(0x7c98d5fe), X(0x7c9c08f2), X(0x7c9f39cb), + X(0x7ca26887), X(0x7ca59528), X(0x7ca8bfb0), X(0x7cabe81d), + X(0x7caf0e72), X(0x7cb232af), X(0x7cb554d4), X(0x7cb874e2), + X(0x7cbb92db), X(0x7cbeaebe), X(0x7cc1c88d), X(0x7cc4e047), + X(0x7cc7f5ef), X(0x7ccb0984), X(0x7cce1b08), X(0x7cd12a7b), + X(0x7cd437dd), X(0x7cd74330), X(0x7cda4c74), X(0x7cdd53aa), + X(0x7ce058d3), X(0x7ce35bef), X(0x7ce65cff), X(0x7ce95c04), + X(0x7cec58ff), X(0x7cef53f0), X(0x7cf24cd7), X(0x7cf543b7), + X(0x7cf8388f), X(0x7cfb2b60), X(0x7cfe1c2b), X(0x7d010af1), + X(0x7d03f7b2), X(0x7d06e26f), X(0x7d09cb29), X(0x7d0cb1e0), + X(0x7d0f9696), X(0x7d12794b), X(0x7d1559ff), X(0x7d1838b4), + X(0x7d1b156a), X(0x7d1df022), X(0x7d20c8dd), X(0x7d239f9b), + X(0x7d26745e), X(0x7d294725), X(0x7d2c17f1), X(0x7d2ee6c4), + X(0x7d31b39f), X(0x7d347e81), X(0x7d37476b), X(0x7d3a0e5f), + X(0x7d3cd35d), X(0x7d3f9665), X(0x7d425779), X(0x7d451699), + X(0x7d47d3c6), X(0x7d4a8f01), X(0x7d4d484b), X(0x7d4fffa3), + X(0x7d52b50c), X(0x7d556885), X(0x7d581a0f), X(0x7d5ac9ac), + X(0x7d5d775c), X(0x7d60231f), X(0x7d62ccf6), X(0x7d6574e3), + X(0x7d681ae6), X(0x7d6abeff), X(0x7d6d612f), X(0x7d700178), + X(0x7d729fd9), X(0x7d753c54), X(0x7d77d6e9), X(0x7d7a6f9a), + X(0x7d7d0666), X(0x7d7f9b4f), X(0x7d822e55), X(0x7d84bf79), + X(0x7d874ebc), X(0x7d89dc1e), X(0x7d8c67a1), X(0x7d8ef144), + X(0x7d91790a), X(0x7d93fef2), X(0x7d9682fd), X(0x7d99052d), + X(0x7d9b8581), X(0x7d9e03fb), X(0x7da0809b), X(0x7da2fb62), + X(0x7da57451), X(0x7da7eb68), X(0x7daa60a8), X(0x7dacd413), + X(0x7daf45a9), X(0x7db1b56a), X(0x7db42357), X(0x7db68f71), + X(0x7db8f9b9), X(0x7dbb6230), X(0x7dbdc8d6), X(0x7dc02dac), + X(0x7dc290b3), X(0x7dc4f1eb), X(0x7dc75156), X(0x7dc9aef4), + X(0x7dcc0ac5), X(0x7dce64cc), X(0x7dd0bd07), X(0x7dd31379), + X(0x7dd56821), X(0x7dd7bb01), X(0x7dda0c1a), X(0x7ddc5b6b), + X(0x7ddea8f7), X(0x7de0f4bd), X(0x7de33ebe), X(0x7de586fc), + X(0x7de7cd76), X(0x7dea122e), X(0x7dec5525), X(0x7dee965a), + X(0x7df0d5d0), X(0x7df31386), X(0x7df54f7e), X(0x7df789b8), + X(0x7df9c235), X(0x7dfbf8f5), X(0x7dfe2dfa), X(0x7e006145), + X(0x7e0292d5), X(0x7e04c2ac), X(0x7e06f0cb), X(0x7e091d32), + X(0x7e0b47e1), X(0x7e0d70db), X(0x7e0f981f), X(0x7e11bdaf), + X(0x7e13e18a), X(0x7e1603b3), X(0x7e182429), X(0x7e1a42ed), + X(0x7e1c6001), X(0x7e1e7b64), X(0x7e209518), X(0x7e22ad1d), + X(0x7e24c375), X(0x7e26d81f), X(0x7e28eb1d), X(0x7e2afc70), + X(0x7e2d0c17), X(0x7e2f1a15), X(0x7e31266a), X(0x7e333115), + X(0x7e353a1a), X(0x7e374177), X(0x7e39472e), X(0x7e3b4b3f), + X(0x7e3d4dac), X(0x7e3f4e75), X(0x7e414d9a), X(0x7e434b1e), + X(0x7e4546ff), X(0x7e474140), X(0x7e4939e0), X(0x7e4b30e2), + X(0x7e4d2644), X(0x7e4f1a09), X(0x7e510c30), X(0x7e52fcbc), + X(0x7e54ebab), X(0x7e56d900), X(0x7e58c4bb), X(0x7e5aaedd), + X(0x7e5c9766), X(0x7e5e7e57), X(0x7e6063b2), X(0x7e624776), + X(0x7e6429a5), X(0x7e660a3f), X(0x7e67e945), X(0x7e69c6b8), + X(0x7e6ba299), X(0x7e6d7ce7), X(0x7e6f55a5), X(0x7e712cd3), + X(0x7e730272), X(0x7e74d682), X(0x7e76a904), X(0x7e7879f9), + X(0x7e7a4962), X(0x7e7c173f), X(0x7e7de392), X(0x7e7fae5a), + X(0x7e817799), X(0x7e833f50), X(0x7e85057f), X(0x7e86ca27), + X(0x7e888d49), X(0x7e8a4ee5), X(0x7e8c0efd), X(0x7e8dcd91), + X(0x7e8f8aa1), X(0x7e914630), X(0x7e93003c), X(0x7e94b8c8), + X(0x7e966fd4), X(0x7e982560), X(0x7e99d96e), X(0x7e9b8bfe), + X(0x7e9d3d10), X(0x7e9eeca7), X(0x7ea09ac2), X(0x7ea24762), + X(0x7ea3f288), X(0x7ea59c35), X(0x7ea7446a), X(0x7ea8eb27), + X(0x7eaa906c), X(0x7eac343c), X(0x7eadd696), X(0x7eaf777b), + X(0x7eb116ed), X(0x7eb2b4eb), X(0x7eb45177), X(0x7eb5ec91), + X(0x7eb7863b), X(0x7eb91e74), X(0x7ebab53e), X(0x7ebc4a99), + X(0x7ebdde87), X(0x7ebf7107), X(0x7ec1021b), X(0x7ec291c3), + X(0x7ec42001), X(0x7ec5acd5), X(0x7ec7383f), X(0x7ec8c241), + X(0x7eca4adb), X(0x7ecbd20d), X(0x7ecd57da), X(0x7ecedc41), + X(0x7ed05f44), X(0x7ed1e0e2), X(0x7ed3611d), X(0x7ed4dff6), + X(0x7ed65d6d), X(0x7ed7d983), X(0x7ed95438), X(0x7edacd8f), + X(0x7edc4586), X(0x7eddbc20), X(0x7edf315c), X(0x7ee0a53c), + X(0x7ee217c1), X(0x7ee388ea), X(0x7ee4f8b9), X(0x7ee6672f), + X(0x7ee7d44c), X(0x7ee94012), X(0x7eeaaa80), X(0x7eec1397), + X(0x7eed7b59), X(0x7eeee1c6), X(0x7ef046df), X(0x7ef1aaa5), + X(0x7ef30d18), X(0x7ef46e39), X(0x7ef5ce09), X(0x7ef72c88), + X(0x7ef889b8), X(0x7ef9e599), X(0x7efb402c), X(0x7efc9972), + X(0x7efdf16b), X(0x7eff4818), X(0x7f009d79), X(0x7f01f191), + X(0x7f03445f), X(0x7f0495e4), X(0x7f05e620), X(0x7f073516), + X(0x7f0882c5), X(0x7f09cf2d), X(0x7f0b1a51), X(0x7f0c6430), + X(0x7f0daccc), X(0x7f0ef425), X(0x7f103a3b), X(0x7f117f11), + X(0x7f12c2a5), X(0x7f1404fa), X(0x7f15460f), X(0x7f1685e6), + X(0x7f17c47f), X(0x7f1901db), X(0x7f1a3dfb), X(0x7f1b78e0), + X(0x7f1cb28a), X(0x7f1deafa), X(0x7f1f2231), X(0x7f20582f), + X(0x7f218cf5), X(0x7f22c085), X(0x7f23f2de), X(0x7f252401), + X(0x7f2653f0), X(0x7f2782ab), X(0x7f28b032), X(0x7f29dc87), + X(0x7f2b07aa), X(0x7f2c319c), X(0x7f2d5a5e), X(0x7f2e81f0), + X(0x7f2fa853), X(0x7f30cd88), X(0x7f31f18f), X(0x7f33146a), + X(0x7f343619), X(0x7f35569c), X(0x7f3675f6), X(0x7f379425), + X(0x7f38b12c), X(0x7f39cd0a), X(0x7f3ae7c0), X(0x7f3c0150), + X(0x7f3d19ba), X(0x7f3e30fe), X(0x7f3f471e), X(0x7f405c1a), + X(0x7f416ff3), X(0x7f4282a9), X(0x7f43943e), X(0x7f44a4b2), + X(0x7f45b405), X(0x7f46c239), X(0x7f47cf4e), X(0x7f48db45), + X(0x7f49e61f), X(0x7f4aefdc), X(0x7f4bf87e), X(0x7f4d0004), + X(0x7f4e0670), X(0x7f4f0bc2), X(0x7f500ffb), X(0x7f51131c), + X(0x7f521525), X(0x7f531618), X(0x7f5415f4), X(0x7f5514bb), + X(0x7f56126e), X(0x7f570f0c), X(0x7f580a98), X(0x7f590511), + X(0x7f59fe78), X(0x7f5af6ce), X(0x7f5bee14), X(0x7f5ce44a), + X(0x7f5dd972), X(0x7f5ecd8b), X(0x7f5fc097), X(0x7f60b296), + X(0x7f61a389), X(0x7f629370), X(0x7f63824e), X(0x7f647021), + X(0x7f655ceb), X(0x7f6648ad), X(0x7f673367), X(0x7f681d19), + X(0x7f6905c6), X(0x7f69ed6d), X(0x7f6ad40f), X(0x7f6bb9ad), + X(0x7f6c9e48), X(0x7f6d81e0), X(0x7f6e6475), X(0x7f6f460a), + X(0x7f70269d), X(0x7f710631), X(0x7f71e4c6), X(0x7f72c25c), + X(0x7f739ef4), X(0x7f747a8f), X(0x7f75552e), X(0x7f762ed1), + X(0x7f770779), X(0x7f77df27), X(0x7f78b5db), X(0x7f798b97), + X(0x7f7a605a), X(0x7f7b3425), X(0x7f7c06fa), X(0x7f7cd8d9), + X(0x7f7da9c2), X(0x7f7e79b7), X(0x7f7f48b8), X(0x7f8016c5), + X(0x7f80e3e0), X(0x7f81b009), X(0x7f827b40), X(0x7f834588), + X(0x7f840edf), X(0x7f84d747), X(0x7f859ec1), X(0x7f86654d), + X(0x7f872aec), X(0x7f87ef9e), X(0x7f88b365), X(0x7f897641), + X(0x7f8a3832), X(0x7f8af93a), X(0x7f8bb959), X(0x7f8c7890), + X(0x7f8d36df), X(0x7f8df448), X(0x7f8eb0ca), X(0x7f8f6c67), + X(0x7f90271e), X(0x7f90e0f2), X(0x7f9199e2), X(0x7f9251f0), + X(0x7f93091b), X(0x7f93bf65), X(0x7f9474ce), X(0x7f952958), + X(0x7f95dd01), X(0x7f968fcd), X(0x7f9741ba), X(0x7f97f2ca), + X(0x7f98a2fd), X(0x7f995254), X(0x7f9a00d0), X(0x7f9aae71), + X(0x7f9b5b38), X(0x7f9c0726), X(0x7f9cb23b), X(0x7f9d5c78), + X(0x7f9e05de), X(0x7f9eae6e), X(0x7f9f5627), X(0x7f9ffd0b), + X(0x7fa0a31b), X(0x7fa14856), X(0x7fa1ecbf), X(0x7fa29054), + X(0x7fa33318), X(0x7fa3d50b), X(0x7fa4762c), X(0x7fa5167e), + X(0x7fa5b601), X(0x7fa654b5), X(0x7fa6f29b), X(0x7fa78fb3), + X(0x7fa82bff), X(0x7fa8c77f), X(0x7fa96234), X(0x7fa9fc1e), + X(0x7faa953e), X(0x7fab2d94), X(0x7fabc522), X(0x7fac5be8), + X(0x7facf1e6), X(0x7fad871d), X(0x7fae1b8f), X(0x7faeaf3b), + X(0x7faf4222), X(0x7fafd445), X(0x7fb065a4), X(0x7fb0f641), + X(0x7fb1861b), X(0x7fb21534), X(0x7fb2a38c), X(0x7fb33124), + X(0x7fb3bdfb), X(0x7fb44a14), X(0x7fb4d56f), X(0x7fb5600c), + X(0x7fb5e9ec), X(0x7fb6730f), X(0x7fb6fb76), X(0x7fb78323), + X(0x7fb80a15), X(0x7fb8904d), X(0x7fb915cc), X(0x7fb99a92), + X(0x7fba1ea0), X(0x7fbaa1f7), X(0x7fbb2497), X(0x7fbba681), + X(0x7fbc27b5), X(0x7fbca835), X(0x7fbd2801), X(0x7fbda719), + X(0x7fbe257e), X(0x7fbea331), X(0x7fbf2032), X(0x7fbf9c82), + X(0x7fc01821), X(0x7fc09311), X(0x7fc10d52), X(0x7fc186e4), + X(0x7fc1ffc8), X(0x7fc277ff), X(0x7fc2ef89), X(0x7fc36667), + X(0x7fc3dc9a), X(0x7fc45221), X(0x7fc4c6ff), X(0x7fc53b33), + X(0x7fc5aebe), X(0x7fc621a0), X(0x7fc693db), X(0x7fc7056f), + X(0x7fc7765c), X(0x7fc7e6a3), X(0x7fc85645), X(0x7fc8c542), + X(0x7fc9339b), X(0x7fc9a150), X(0x7fca0e63), X(0x7fca7ad3), + X(0x7fcae6a2), X(0x7fcb51cf), X(0x7fcbbc5c), X(0x7fcc2649), + X(0x7fcc8f97), X(0x7fccf846), X(0x7fcd6058), X(0x7fcdc7cb), + X(0x7fce2ea2), X(0x7fce94dd), X(0x7fcefa7b), X(0x7fcf5f7f), + X(0x7fcfc3e8), X(0x7fd027b7), X(0x7fd08aed), X(0x7fd0ed8b), + X(0x7fd14f90), X(0x7fd1b0fd), X(0x7fd211d4), X(0x7fd27214), + X(0x7fd2d1bf), X(0x7fd330d4), X(0x7fd38f55), X(0x7fd3ed41), + X(0x7fd44a9a), X(0x7fd4a761), X(0x7fd50395), X(0x7fd55f37), + X(0x7fd5ba48), X(0x7fd614c9), X(0x7fd66eba), X(0x7fd6c81b), + X(0x7fd720ed), X(0x7fd77932), X(0x7fd7d0e8), X(0x7fd82812), + X(0x7fd87eae), X(0x7fd8d4bf), X(0x7fd92a45), X(0x7fd97f40), + X(0x7fd9d3b0), X(0x7fda2797), X(0x7fda7af5), X(0x7fdacdca), + X(0x7fdb2018), X(0x7fdb71dd), X(0x7fdbc31c), X(0x7fdc13d5), + X(0x7fdc6408), X(0x7fdcb3b6), X(0x7fdd02df), X(0x7fdd5184), + X(0x7fdd9fa5), X(0x7fdded44), X(0x7fde3a60), X(0x7fde86fb), + X(0x7fded314), X(0x7fdf1eac), X(0x7fdf69c4), X(0x7fdfb45d), + X(0x7fdffe76), X(0x7fe04811), X(0x7fe0912e), X(0x7fe0d9ce), + X(0x7fe121f0), X(0x7fe16996), X(0x7fe1b0c1), X(0x7fe1f770), + X(0x7fe23da4), X(0x7fe2835f), X(0x7fe2c89f), X(0x7fe30d67), + X(0x7fe351b5), X(0x7fe3958c), X(0x7fe3d8ec), X(0x7fe41bd4), + X(0x7fe45e46), X(0x7fe4a042), X(0x7fe4e1c8), X(0x7fe522da), + X(0x7fe56378), X(0x7fe5a3a1), X(0x7fe5e358), X(0x7fe6229b), + X(0x7fe6616d), X(0x7fe69fcc), X(0x7fe6ddbb), X(0x7fe71b39), + X(0x7fe75847), X(0x7fe794e5), X(0x7fe7d114), X(0x7fe80cd5), + X(0x7fe84827), X(0x7fe8830c), X(0x7fe8bd84), X(0x7fe8f78f), + X(0x7fe9312f), X(0x7fe96a62), X(0x7fe9a32b), X(0x7fe9db8a), + X(0x7fea137e), X(0x7fea4b09), X(0x7fea822b), X(0x7feab8e5), + X(0x7feaef37), X(0x7feb2521), X(0x7feb5aa4), X(0x7feb8fc1), + X(0x7febc478), X(0x7febf8ca), X(0x7fec2cb6), X(0x7fec603e), + X(0x7fec9363), X(0x7fecc623), X(0x7fecf881), X(0x7fed2a7c), + X(0x7fed5c16), X(0x7fed8d4e), X(0x7fedbe24), X(0x7fedee9b), + X(0x7fee1eb1), X(0x7fee4e68), X(0x7fee7dc0), X(0x7feeacb9), + X(0x7feedb54), X(0x7fef0991), X(0x7fef3771), X(0x7fef64f5), + X(0x7fef921d), X(0x7fefbee8), X(0x7fefeb59), X(0x7ff0176f), + X(0x7ff0432a), X(0x7ff06e8c), X(0x7ff09995), X(0x7ff0c444), + X(0x7ff0ee9c), X(0x7ff1189b), X(0x7ff14243), X(0x7ff16b94), + X(0x7ff1948e), X(0x7ff1bd32), X(0x7ff1e581), X(0x7ff20d7b), + X(0x7ff2351f), X(0x7ff25c70), X(0x7ff2836d), X(0x7ff2aa17), + X(0x7ff2d06d), X(0x7ff2f672), X(0x7ff31c24), X(0x7ff34185), + X(0x7ff36695), X(0x7ff38b55), X(0x7ff3afc4), X(0x7ff3d3e4), + X(0x7ff3f7b4), X(0x7ff41b35), X(0x7ff43e69), X(0x7ff4614e), + X(0x7ff483e6), X(0x7ff4a631), X(0x7ff4c82f), X(0x7ff4e9e1), + X(0x7ff50b47), X(0x7ff52c62), X(0x7ff54d33), X(0x7ff56db9), + X(0x7ff58df5), X(0x7ff5ade7), X(0x7ff5cd90), X(0x7ff5ecf1), + X(0x7ff60c09), X(0x7ff62ada), X(0x7ff64963), X(0x7ff667a5), + X(0x7ff685a1), X(0x7ff6a357), X(0x7ff6c0c7), X(0x7ff6ddf1), + X(0x7ff6fad7), X(0x7ff71778), X(0x7ff733d6), X(0x7ff74fef), + X(0x7ff76bc6), X(0x7ff78759), X(0x7ff7a2ab), X(0x7ff7bdba), + X(0x7ff7d888), X(0x7ff7f315), X(0x7ff80d61), X(0x7ff8276c), + X(0x7ff84138), X(0x7ff85ac4), X(0x7ff87412), X(0x7ff88d20), + X(0x7ff8a5f0), X(0x7ff8be82), X(0x7ff8d6d7), X(0x7ff8eeef), + X(0x7ff906c9), X(0x7ff91e68), X(0x7ff935cb), X(0x7ff94cf2), + X(0x7ff963dd), X(0x7ff97a8f), X(0x7ff99105), X(0x7ff9a742), + X(0x7ff9bd45), X(0x7ff9d30f), X(0x7ff9e8a0), X(0x7ff9fdf9), + X(0x7ffa131a), X(0x7ffa2803), X(0x7ffa3cb4), X(0x7ffa512f), + X(0x7ffa6573), X(0x7ffa7981), X(0x7ffa8d59), X(0x7ffaa0fc), + X(0x7ffab46a), X(0x7ffac7a3), X(0x7ffadaa8), X(0x7ffaed78), + X(0x7ffb0015), X(0x7ffb127f), X(0x7ffb24b6), X(0x7ffb36bb), + X(0x7ffb488d), X(0x7ffb5a2e), X(0x7ffb6b9d), X(0x7ffb7cdb), + X(0x7ffb8de9), X(0x7ffb9ec6), X(0x7ffbaf73), X(0x7ffbbff1), + X(0x7ffbd03f), X(0x7ffbe05e), X(0x7ffbf04f), X(0x7ffc0012), + X(0x7ffc0fa6), X(0x7ffc1f0d), X(0x7ffc2e47), X(0x7ffc3d54), + X(0x7ffc4c35), X(0x7ffc5ae9), X(0x7ffc6971), X(0x7ffc77ce), + X(0x7ffc8600), X(0x7ffc9407), X(0x7ffca1e4), X(0x7ffcaf96), + X(0x7ffcbd1f), X(0x7ffcca7e), X(0x7ffcd7b4), X(0x7ffce4c1), + X(0x7ffcf1a5), X(0x7ffcfe62), X(0x7ffd0af6), X(0x7ffd1763), + X(0x7ffd23a9), X(0x7ffd2fc8), X(0x7ffd3bc1), X(0x7ffd4793), + X(0x7ffd533f), X(0x7ffd5ec5), X(0x7ffd6a27), X(0x7ffd7563), + X(0x7ffd807a), X(0x7ffd8b6e), X(0x7ffd963d), X(0x7ffda0e8), + X(0x7ffdab70), X(0x7ffdb5d5), X(0x7ffdc017), X(0x7ffdca36), + X(0x7ffdd434), X(0x7ffdde0f), X(0x7ffde7c9), X(0x7ffdf161), + X(0x7ffdfad8), X(0x7ffe042f), X(0x7ffe0d65), X(0x7ffe167b), + X(0x7ffe1f71), X(0x7ffe2848), X(0x7ffe30ff), X(0x7ffe3997), + X(0x7ffe4211), X(0x7ffe4a6c), X(0x7ffe52a9), X(0x7ffe5ac8), + X(0x7ffe62c9), X(0x7ffe6aae), X(0x7ffe7275), X(0x7ffe7a1f), + X(0x7ffe81ad), X(0x7ffe891f), X(0x7ffe9075), X(0x7ffe97b0), + X(0x7ffe9ece), X(0x7ffea5d2), X(0x7ffeacbb), X(0x7ffeb38a), + X(0x7ffeba3e), X(0x7ffec0d8), X(0x7ffec758), X(0x7ffecdbf), + X(0x7ffed40d), X(0x7ffeda41), X(0x7ffee05d), X(0x7ffee660), + X(0x7ffeec4b), X(0x7ffef21f), X(0x7ffef7da), X(0x7ffefd7e), + X(0x7fff030b), X(0x7fff0881), X(0x7fff0de0), X(0x7fff1328), + X(0x7fff185b), X(0x7fff1d77), X(0x7fff227e), X(0x7fff276f), + X(0x7fff2c4b), X(0x7fff3112), X(0x7fff35c4), X(0x7fff3a62), + X(0x7fff3eeb), X(0x7fff4360), X(0x7fff47c2), X(0x7fff4c0f), + X(0x7fff504a), X(0x7fff5471), X(0x7fff5885), X(0x7fff5c87), + X(0x7fff6076), X(0x7fff6452), X(0x7fff681d), X(0x7fff6bd6), + X(0x7fff6f7d), X(0x7fff7313), X(0x7fff7698), X(0x7fff7a0c), + X(0x7fff7d6f), X(0x7fff80c2), X(0x7fff8404), X(0x7fff8736), + X(0x7fff8a58), X(0x7fff8d6b), X(0x7fff906e), X(0x7fff9362), + X(0x7fff9646), X(0x7fff991c), X(0x7fff9be3), X(0x7fff9e9c), + X(0x7fffa146), X(0x7fffa3e2), X(0x7fffa671), X(0x7fffa8f1), + X(0x7fffab65), X(0x7fffadca), X(0x7fffb023), X(0x7fffb26f), + X(0x7fffb4ae), X(0x7fffb6e0), X(0x7fffb906), X(0x7fffbb20), + X(0x7fffbd2e), X(0x7fffbf30), X(0x7fffc126), X(0x7fffc311), + X(0x7fffc4f1), X(0x7fffc6c5), X(0x7fffc88f), X(0x7fffca4d), + X(0x7fffcc01), X(0x7fffcdab), X(0x7fffcf4a), X(0x7fffd0e0), + X(0x7fffd26b), X(0x7fffd3ec), X(0x7fffd564), X(0x7fffd6d2), + X(0x7fffd838), X(0x7fffd993), X(0x7fffdae6), X(0x7fffdc31), + X(0x7fffdd72), X(0x7fffdeab), X(0x7fffdfdb), X(0x7fffe104), + X(0x7fffe224), X(0x7fffe33c), X(0x7fffe44d), X(0x7fffe556), + X(0x7fffe657), X(0x7fffe751), X(0x7fffe844), X(0x7fffe930), + X(0x7fffea15), X(0x7fffeaf3), X(0x7fffebca), X(0x7fffec9b), + X(0x7fffed66), X(0x7fffee2a), X(0x7fffeee8), X(0x7fffefa0), + X(0x7ffff053), X(0x7ffff0ff), X(0x7ffff1a6), X(0x7ffff247), + X(0x7ffff2e4), X(0x7ffff37a), X(0x7ffff40c), X(0x7ffff499), + X(0x7ffff520), X(0x7ffff5a3), X(0x7ffff621), X(0x7ffff69b), + X(0x7ffff710), X(0x7ffff781), X(0x7ffff7ee), X(0x7ffff857), + X(0x7ffff8bb), X(0x7ffff91c), X(0x7ffff979), X(0x7ffff9d2), + X(0x7ffffa27), X(0x7ffffa79), X(0x7ffffac8), X(0x7ffffb13), + X(0x7ffffb5b), X(0x7ffffba0), X(0x7ffffbe2), X(0x7ffffc21), + X(0x7ffffc5d), X(0x7ffffc96), X(0x7ffffccd), X(0x7ffffd01), + X(0x7ffffd32), X(0x7ffffd61), X(0x7ffffd8e), X(0x7ffffdb8), + X(0x7ffffde0), X(0x7ffffe07), X(0x7ffffe2b), X(0x7ffffe4d), + X(0x7ffffe6d), X(0x7ffffe8b), X(0x7ffffea8), X(0x7ffffec3), + X(0x7ffffedc), X(0x7ffffef4), X(0x7fffff0a), X(0x7fffff1f), + X(0x7fffff33), X(0x7fffff45), X(0x7fffff56), X(0x7fffff66), + X(0x7fffff75), X(0x7fffff82), X(0x7fffff8f), X(0x7fffff9a), + X(0x7fffffa5), X(0x7fffffaf), X(0x7fffffb8), X(0x7fffffc0), + X(0x7fffffc8), X(0x7fffffce), X(0x7fffffd5), X(0x7fffffda), + X(0x7fffffdf), X(0x7fffffe4), X(0x7fffffe8), X(0x7fffffeb), + X(0x7fffffef), X(0x7ffffff1), X(0x7ffffff4), X(0x7ffffff6), + X(0x7ffffff8), X(0x7ffffff9), X(0x7ffffffb), X(0x7ffffffc), + X(0x7ffffffd), X(0x7ffffffd), X(0x7ffffffe), X(0x7fffffff), + X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), + X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), + X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), +}; + +#endif diff --git a/librespot-android-decoder-tremolo/src/main/libs/arm64-v8a/libtremolo.so b/librespot-android-decoder-tremolo/src/main/libs/arm64-v8a/libtremolo.so new file mode 100644 index 0000000000000000000000000000000000000000..86f89bc11590dc81d257324af3f58c006d7cbf84 GIT binary patch literal 109312 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 literal 0 HcmV?d00001 diff --git a/settings.gradle b/settings.gradle index 447f673..d6ab69b 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,3 +1,4 @@ +include ':librespot-android-decoder-tremolo' include ':librespot-android-sink' include ':app' rootProject.name = "librespot-android" \ No newline at end of file From ccacbcd00f5e8b489bc673558cc02d85d1c3d764 Mon Sep 17 00:00:00 2001 From: Martin Date: Wed, 21 Apr 2021 15:47:49 +0200 Subject: [PATCH 2/4] Some cleanup --- .../src/main/jni/libtremolo/tremolo-jni.c | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c index 8ec9aa5..97f54df 100644 --- a/librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c +++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c @@ -84,12 +84,6 @@ JNIEXPORT jlong JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecod return pointer; } -static unsigned int samplesWritten = 0; - -static unsigned int pcm_bytes_to_frames(unsigned int bytes) { - return bytes / (2 * (16 >> 3)); -} - JNIEXPORT jlong JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_read(JNIEnv *env, jobject obj, jlong jHandle, jint jLen) { struct OggVorbis_File *vf; @@ -124,8 +118,6 @@ JNIEXPORT jint JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodi return ov_pcm_seek(vf, jSamples); } - - JNIEXPORT jlong JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodingInputStream_tellMs(JNIEnv *env, jobject obj, jlong jHandle) { struct OggVorbis_File *vf; @@ -170,4 +162,4 @@ JNIEXPORT void JNICALL Java_xyz_gianlu_librespot_player_codecs_tremolo_OggDecodi ov_clear(vf); free(vf); vf = NULL; -} \ No newline at end of file +} From 980f5ed8411ff4400d59ae8fa163cd2c2fa6cfee Mon Sep 17 00:00:00 2001 From: Gianlu Date: Wed, 21 Apr 2021 18:22:10 +0200 Subject: [PATCH 3/4] Some refactoring --- .../player/codecs/TremoloVorbisCodec.java | 38 ++++----- .../tremolo/OggDecodingInputStream.java | 83 +++++++++---------- 2 files changed, 57 insertions(+), 64 deletions(-) diff --git a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java index 7a333d5..78731f0 100644 --- a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java +++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java @@ -15,43 +15,40 @@ public class TremoloVorbisCodec extends Codec { private final byte[] buffer = new byte[2 * BUFFER_SIZE]; - - private OggDecodingInputStream inputStream; + private final OggDecodingInputStream in; public TremoloVorbisCodec(@NotNull GeneralAudioStream audioFile, @Nullable NormalizationData normalizationData, @NotNull PlayerConfiguration conf, int duration) throws IOException { super(audioFile, normalizationData, conf, duration); - seekZero = audioIn.pos(); - - inputStream = new OggDecodingInputStream(new SeekableInputStream() { + in = new OggDecodingInputStream(new SeekableInputStream() { @Override public void seek(long positionBytes) throws IOException { - audioFile.stream().seek((int) (positionBytes + seekZero)); + audioIn.seek((int) (positionBytes + seekZero)); } @Override public long tell() { - return audioFile.stream().pos() - seekZero; + return audioIn.pos() - seekZero; } @Override public long length() { - return (audioFile.stream().available() + audioFile.stream().pos()) - seekZero; + return (audioIn.available() + audioIn.pos()) - seekZero; } @Override public int read(byte[] bytes) throws IOException { - return audioFile.stream().read(bytes); + return audioIn.read(bytes); } @Override public void close() { - audioFile.stream().close(); + audioIn.close(); } @Override public int read() throws IOException { - return audioFile.stream().read(); + return audioIn.read(); } }); @@ -62,21 +59,24 @@ public int read() throws IOException { protected synchronized int readInternal(@NotNull OutputStream outputStream) throws IOException { if (closed) return -1; - int count = inputStream.read(buffer); - if (count == -1) return -1; + int count = in.read(buffer); + if (count == -1) + return -1; + try { outputStream.write(buffer, 0, count); outputStream.flush(); } catch (IllegalStateException e) { // TODO logging } + return count; } @Override public int time() throws CannotGetTimeException { try { - return (int) inputStream.tellMs(); + return (int) in.tellMs(); } catch (Exception e) { throw new CannotGetTimeException(); } @@ -84,18 +84,18 @@ public int time() throws CannotGetTimeException { @Override public void close() throws IOException { - if (inputStream != null) { - inputStream.close(); - } + if (in != null) + in.close(); + super.close(); } @Override public /*synchronized*/ void seek(int positionMs) { try { - inputStream.seekMs(positionMs); + in.seekMs(positionMs); } catch (IOException e) { - e.printStackTrace(); + // TODO logging } } } diff --git a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java index db326eb..c84d4a5 100644 --- a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java +++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java @@ -8,9 +8,7 @@ /** * Created by M. Lehmann on 15.11.2016. */ -@SuppressWarnings("unused") public class OggDecodingInputStream extends InputStream { - private static final int BUFFER_SIZE = 4096; private static final int SEEK_SET = 0; private static final int SEEK_CUR = 1; @@ -24,24 +22,22 @@ public class OggDecodingInputStream extends InputStream { * address of native OggFileHandle structure **/ private final long handle; - private final SeekableInputStream oggInputStream; private final ByteBuffer jniBuffer; private final AtomicBoolean isClosed = new AtomicBoolean(false); - public boolean isClosed() { - return isClosed.get(); - } - public OggDecodingInputStream(SeekableInputStream oggInputStream) throws IOException { this.oggInputStream = oggInputStream; jniBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE); handle = initDecoder(jniBuffer); - if (handle == 0) { + if (handle == 0) throw new IOException("Couldn't start decoder!"); - } + } + + public boolean isClosed() { + return isClosed.get(); } private native long initDecoder(ByteBuffer jniBuffer); @@ -55,26 +51,29 @@ private int writeOgg(int size) { jniBuffer.flip(); return read; } + return 0; } catch (Exception e) { // TODO logging } + return -1; } private int seekOgg(long offset, int whence) { try { - if (whence == SEEK_SET) { + if (whence == SEEK_SET) oggInputStream.seek(offset); - } else if (whence == SEEK_CUR) { + else if (whence == SEEK_CUR) oggInputStream.seek(oggInputStream.tell() + offset); - } else if (whence == SEEK_END) { + else if (whence == SEEK_END) oggInputStream.seek(oggInputStream.length() + offset); - } + return 0; } catch (Exception e) { // TODO logging } + return -1; } @@ -84,6 +83,7 @@ private int tellOgg() { } catch (Exception e) { // TODO logging } + return -1; } @@ -102,26 +102,25 @@ private int tellOgg() { @Override public int read() throws IOException { synchronized (isClosed) { - if (isClosed.get()) { + if (isClosed.get()) throw new IOException("OggDecodingInputStream already closed!"); - } + jniBuffer.clear(); int size = read(handle, 1); jniBuffer.limit(size); } - final byte b = jniBuffer.get(); - jniBuffer.clear(); + byte b = jniBuffer.get(); + jniBuffer.clear(); return b; } @Override public synchronized int read(byte[] b, int off, int len) throws IOException { synchronized (isClosed) { - if (isClosed.get()) { + if (isClosed.get()) throw new IOException("read: OggDecodingInputStream already closed!"); - } len = Math.min(len, BUFFER_SIZE); jniBuffer.clear(); @@ -133,60 +132,61 @@ public synchronized int read(byte[] b, int off, int len) throws IOException { return size; } } + return -1; } @Override public synchronized int read(byte[] b) throws IOException { synchronized (isClosed) { - if (isClosed.get()) { + if (isClosed.get()) throw new IOException("OggDecodingInputStream already closed!"); - } + return this.read(b, 0, b.length); } } public synchronized int seekMs(int milliseconds) throws IOException { synchronized (isClosed) { - if (isClosed.get()) { + if (isClosed.get()) throw new IOException("seekMs: OggDecodingInputStream already closed!"); - } + return seekMs(handle, milliseconds); } } public synchronized int seekSamples(int samples) throws IOException { synchronized (isClosed) { - if (isClosed.get()) { + if (isClosed.get()) throw new IOException("seekSamples: OggDecodingInputStream already closed!"); - } + return seekSamples(handle, samples); } } public synchronized long tellMs() throws IOException { synchronized (isClosed) { - if (isClosed.get()) { + if (isClosed.get()) throw new IOException("tellMs: OggDecodingInputStream already closed!"); - } + return tellMs(handle); } } public synchronized long tellSamples() throws IOException { synchronized (isClosed) { - if (isClosed.get()) { + if (isClosed.get()) throw new IOException("tellSamples: OggDecodingInputStream already closed!"); - } + return tellSamples(handle); } } public synchronized long totalSamples() throws IOException { synchronized (isClosed) { - if (isClosed.get()) { + if (isClosed.get()) throw new IOException("totalSamples: OggDecodingInputStream already closed!"); - } + return totalSamples(handle); } } @@ -196,11 +196,13 @@ public void close() throws IOException { if (!isClosed.getAndSet(true)) { synchronized (isClosed) { close(handle); + try { oggInputStream.close(); } catch (IOException ignored) { } } + super.close(); } else { // TODO logging @@ -208,26 +210,17 @@ public void close() throws IOException { } public synchronized long seek(long bytes) throws IOException { - final int samples = (int) (bytes / ((16 * 2) / 8)); + int samples = (int) (bytes / ((16 * 2) / 8)); + int success = seekSamples(samples); + if (success != 0) + throw new IOException("seek: Failed to seekSamples!"); - final int success = seekSamples(samples); - if (success == 0) { - return getSamplesToBytes(tellSamples(), 16, 2); - } - - throw new IOException("seek: Failed to seekSamples!"); + return getSamplesToBytes(tellSamples(), 16, 2); } private long getSamplesToBytes(long samples, int bits, int channels) { return (samples * bits * channels) / 8; } - private int getBytesToMilliSeconds(long bytes, int bits, int channels) { - long bytesPerSecond = (bits * 44100 * channels) / 8; - long seconds = bytes / bytesPerSecond; - - return (int) (seconds * 1000); - } - private native void close(long handle); } From 39eeabbccb2cfad142cef8ee34f22a91b3ead1ff Mon Sep 17 00:00:00 2001 From: Gianlu Date: Sun, 25 Apr 2021 10:11:10 +0200 Subject: [PATCH 4/4] Slimmed down code a lot (maybe too much?) + fixed deps --- app/build.gradle | 3 +- .../build.gradle | 5 +- .../player/codecs/TremoloVorbisCodec.java | 30 +-- .../tremolo/OggDecodingInputStream.java | 188 +++--------------- 4 files changed, 41 insertions(+), 185 deletions(-) diff --git a/app/build.gradle b/app/build.gradle index 729c218..a78c4ce 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -38,8 +38,7 @@ dependencies { implementation('xyz.gianlu.librespot:librespot-player:1.5.6-SNAPSHOT:thin') { exclude group: 'xyz.gianlu.librespot', module: 'librespot-sink' - exclude group: 'org.apache.logging.log4j', module: 'log4j-core' - exclude group: 'org.apache.logging.log4j', module: 'log4j-slf4j-impl' exclude group: 'com.lmax', module: 'disruptor' + exclude group: 'org.apache.logging.log4j' } } \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/build.gradle b/librespot-android-decoder-tremolo/build.gradle index 54446ec..a60f66c 100644 --- a/librespot-android-decoder-tremolo/build.gradle +++ b/librespot-android-decoder-tremolo/build.gradle @@ -37,6 +37,7 @@ android { proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' } } + compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 @@ -44,11 +45,9 @@ android { } dependencies { - // TODO fix dependencies implementation('xyz.gianlu.librespot:librespot-player:1.5.6-SNAPSHOT:thin') { exclude group: 'xyz.gianlu.librespot', module: 'librespot-sink' - exclude group: 'org.apache.logging.log4j', module: 'log4j-core' - exclude group: 'org.apache.logging.log4j', module: 'log4j-slf4j-impl' exclude group: 'com.lmax', module: 'disruptor' + exclude group: 'org.apache.logging.log4j' } } \ No newline at end of file diff --git a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java index 78731f0..610f858 100644 --- a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java +++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java @@ -63,39 +63,27 @@ protected synchronized int readInternal(@NotNull OutputStream outputStream) thro if (count == -1) return -1; - try { - outputStream.write(buffer, 0, count); - outputStream.flush(); - } catch (IllegalStateException e) { - // TODO logging - } - + outputStream.write(buffer, 0, count); + outputStream.flush(); return count; } @Override public int time() throws CannotGetTimeException { - try { - return (int) in.tellMs(); - } catch (Exception e) { - throw new CannotGetTimeException(); - } + if (closed) + throw new CannotGetTimeException("Codec is closed"); + + return (int) in.tellMs(); } @Override public void close() throws IOException { - if (in != null) - in.close(); - + if (in != null) in.close(); super.close(); } @Override - public /*synchronized*/ void seek(int positionMs) { - try { - in.seekMs(positionMs); - } catch (IOException e) { - // TODO logging - } + public void seek(int positionMs) { + if (!closed) in.seekMs(positionMs); } } diff --git a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java index c84d4a5..592b47a 100644 --- a/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java +++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java @@ -1,18 +1,16 @@ package xyz.gianlu.librespot.player.codecs.tremolo; +import org.jetbrains.annotations.NotNull; + import java.io.IOException; import java.io.InputStream; import java.nio.ByteBuffer; -import java.util.concurrent.atomic.AtomicBoolean; /** * Created by M. Lehmann on 15.11.2016. */ public class OggDecodingInputStream extends InputStream { private static final int BUFFER_SIZE = 4096; - private static final int SEEK_SET = 0; - private static final int SEEK_CUR = 1; - private static final int SEEK_END = 2; static { System.loadLibrary("tremolo"); @@ -24,69 +22,17 @@ public class OggDecodingInputStream extends InputStream { private final long handle; private final SeekableInputStream oggInputStream; private final ByteBuffer jniBuffer; - private final AtomicBoolean isClosed = new AtomicBoolean(false); - public OggDecodingInputStream(SeekableInputStream oggInputStream) throws IOException { + public OggDecodingInputStream(@NotNull SeekableInputStream oggInputStream) throws IOException { this.oggInputStream = oggInputStream; - - jniBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE); - - handle = initDecoder(jniBuffer); + this.jniBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE); + this.handle = initDecoder(jniBuffer); if (handle == 0) throw new IOException("Couldn't start decoder!"); } - public boolean isClosed() { - return isClosed.get(); - } - private native long initDecoder(ByteBuffer jniBuffer); - private int writeOgg(int size) { - byte[] bytes = new byte[Math.min(size, BUFFER_SIZE)]; - try { - int read = oggInputStream.read(bytes); - if (read > -1) { - jniBuffer.put(bytes); - jniBuffer.flip(); - return read; - } - - return 0; - } catch (Exception e) { - // TODO logging - } - - return -1; - } - - private int seekOgg(long offset, int whence) { - try { - if (whence == SEEK_SET) - oggInputStream.seek(offset); - else if (whence == SEEK_CUR) - oggInputStream.seek(oggInputStream.tell() + offset); - else if (whence == SEEK_END) - oggInputStream.seek(oggInputStream.length() + offset); - - return 0; - } catch (Exception e) { - // TODO logging - } - - return -1; - } - - private int tellOgg() { - try { - return (int) oggInputStream.tell(); - } catch (Exception e) { - // TODO logging - } - - return -1; - } - private native int read(long handle, int len); private native int seekMs(long handle, int milliseconds); @@ -99,17 +45,14 @@ private int tellOgg() { private native long totalSamples(long handle); - @Override - public int read() throws IOException { - synchronized (isClosed) { - if (isClosed.get()) - throw new IOException("OggDecodingInputStream already closed!"); + private native void close(long handle); - jniBuffer.clear(); - int size = read(handle, 1); + @Override + public synchronized int read() { + jniBuffer.clear(); - jniBuffer.limit(size); - } + int size = read(handle, 1); + jniBuffer.limit(size); byte b = jniBuffer.get(); jniBuffer.clear(); @@ -117,110 +60,37 @@ public int read() throws IOException { } @Override - public synchronized int read(byte[] b, int off, int len) throws IOException { - synchronized (isClosed) { - if (isClosed.get()) - throw new IOException("read: OggDecodingInputStream already closed!"); - - len = Math.min(len, BUFFER_SIZE); + public synchronized int read(byte[] b, int off, int len) { + len = Math.min(len, BUFFER_SIZE); + jniBuffer.clear(); + int size = read(handle, len); + if (size > 0) { + jniBuffer.limit(size); + jniBuffer.get(b, off, size); jniBuffer.clear(); - int size = read(handle, len); - if (size > 0) { - jniBuffer.limit(size); - jniBuffer.get(b, off, size); - jniBuffer.clear(); - return size; - } + return size; } return -1; } @Override - public synchronized int read(byte[] b) throws IOException { - synchronized (isClosed) { - if (isClosed.get()) - throw new IOException("OggDecodingInputStream already closed!"); - - return this.read(b, 0, b.length); - } - } - - public synchronized int seekMs(int milliseconds) throws IOException { - synchronized (isClosed) { - if (isClosed.get()) - throw new IOException("seekMs: OggDecodingInputStream already closed!"); - - return seekMs(handle, milliseconds); - } - } - - public synchronized int seekSamples(int samples) throws IOException { - synchronized (isClosed) { - if (isClosed.get()) - throw new IOException("seekSamples: OggDecodingInputStream already closed!"); - - return seekSamples(handle, samples); - } - } - - public synchronized long tellMs() throws IOException { - synchronized (isClosed) { - if (isClosed.get()) - throw new IOException("tellMs: OggDecodingInputStream already closed!"); - - return tellMs(handle); - } + public synchronized int read(byte[] b) { + return this.read(b, 0, b.length); } - public synchronized long tellSamples() throws IOException { - synchronized (isClosed) { - if (isClosed.get()) - throw new IOException("tellSamples: OggDecodingInputStream already closed!"); - - return tellSamples(handle); - } + public synchronized int seekMs(int milliseconds) { + return seekMs(handle, milliseconds); } - public synchronized long totalSamples() throws IOException { - synchronized (isClosed) { - if (isClosed.get()) - throw new IOException("totalSamples: OggDecodingInputStream already closed!"); - - return totalSamples(handle); - } + public synchronized long tellMs() { + return tellMs(handle); } @Override - public void close() throws IOException { - if (!isClosed.getAndSet(true)) { - synchronized (isClosed) { - close(handle); - - try { - oggInputStream.close(); - } catch (IOException ignored) { - } - } - - super.close(); - } else { - // TODO logging - } + public synchronized void close() throws IOException { + close(handle); + oggInputStream.close(); + super.close(); } - - public synchronized long seek(long bytes) throws IOException { - int samples = (int) (bytes / ((16 * 2) / 8)); - int success = seekSamples(samples); - if (success != 0) - throw new IOException("seek: Failed to seekSamples!"); - - return getSamplesToBytes(tellSamples(), 16, 2); - } - - private long getSamplesToBytes(long samples, int bits, int channels) { - return (samples * bits * channels) / 8; - } - - private native void close(long handle); }