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/.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..a60f66c
--- /dev/null
+++ b/librespot-android-decoder-tremolo/build.gradle
@@ -0,0 +1,53 @@
+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 {
+ implementation('xyz.gianlu.librespot:librespot-player:1.5.6-SNAPSHOT:thin') {
+ exclude group: 'xyz.gianlu.librespot', module: 'librespot-sink'
+ 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/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..610f858
--- /dev/null
+++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/TremoloVorbisCodec.java
@@ -0,0 +1,89 @@
+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 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();
+ in = new OggDecodingInputStream(new SeekableInputStream() {
+ @Override
+ public void seek(long positionBytes) throws IOException {
+ audioIn.seek((int) (positionBytes + seekZero));
+ }
+
+ @Override
+ public long tell() {
+ return audioIn.pos() - seekZero;
+ }
+
+ @Override
+ public long length() {
+ return (audioIn.available() + audioIn.pos()) - seekZero;
+ }
+
+ @Override
+ public int read(byte[] bytes) throws IOException {
+ return audioIn.read(bytes);
+ }
+
+ @Override
+ public void close() {
+ audioIn.close();
+ }
+
+ @Override
+ public int read() throws IOException {
+ return audioIn.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 = in.read(buffer);
+ if (count == -1)
+ return -1;
+
+ outputStream.write(buffer, 0, count);
+ outputStream.flush();
+ return count;
+ }
+
+ @Override
+ public int time() throws CannotGetTimeException {
+ if (closed)
+ throw new CannotGetTimeException("Codec is closed");
+
+ return (int) in.tellMs();
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (in != null) in.close();
+ super.close();
+ }
+
+ @Override
+ 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
new file mode 100644
index 0000000..592b47a
--- /dev/null
+++ b/librespot-android-decoder-tremolo/src/main/java/xyz/gianlu/librespot/player/codecs/tremolo/OggDecodingInputStream.java
@@ -0,0 +1,96 @@
+package xyz.gianlu.librespot.player.codecs.tremolo;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+
+/**
+ * Created by M. Lehmann on 15.11.2016.
+ */
+public class OggDecodingInputStream extends InputStream {
+ private static final int BUFFER_SIZE = 4096;
+
+ static {
+ System.loadLibrary("tremolo");
+ }
+
+ /**
+ * address of native OggFileHandle structure
+ **/
+ private final long handle;
+ private final SeekableInputStream oggInputStream;
+ private final ByteBuffer jniBuffer;
+
+ public OggDecodingInputStream(@NotNull SeekableInputStream oggInputStream) throws IOException {
+ this.oggInputStream = oggInputStream;
+ this.jniBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE);
+ this.handle = initDecoder(jniBuffer);
+ if (handle == 0)
+ throw new IOException("Couldn't start decoder!");
+ }
+
+ private native long initDecoder(ByteBuffer jniBuffer);
+
+ 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);
+
+ private native void close(long handle);
+
+ @Override
+ public synchronized int read() {
+ jniBuffer.clear();
+
+ int size = read(handle, 1);
+ jniBuffer.limit(size);
+
+ byte b = jniBuffer.get();
+ jniBuffer.clear();
+ return b;
+ }
+
+ @Override
+ 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();
+ return size;
+ }
+
+ return -1;
+ }
+
+ @Override
+ public synchronized int read(byte[] b) {
+ return this.read(b, 0, b.length);
+ }
+
+ public synchronized int seekMs(int milliseconds) {
+ return seekMs(handle, milliseconds);
+ }
+
+ public synchronized long tellMs() {
+ return tellMs(handle);
+ }
+
+ @Override
+ public synchronized void close() throws IOException {
+ close(handle);
+ oggInputStream.close();
+ super.close();
+ }
+}
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..97f54df
--- /dev/null
+++ b/librespot-android-decoder-tremolo/src/main/jni/libtremolo/tremolo-jni.c
@@ -0,0 +1,165 @@
+#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;
+}
+
+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;
+}
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;i