From: yeom Date: Wed, 17 Aug 2011 03:13:36 +0000 (+0000) Subject: have linear-type-safe source codes of mp3decoder X-Git-Url: http://plrg.eecs.uci.edu/git/?p=IRC.git;a=commitdiff_plain;h=0f0eb4c886837a58b30f5a6484c0fa036a62d9e2 have linear-type-safe source codes of mp3decoder --- diff --git a/Robust/src/Analysis/SSJava/LinearTypeCheck.java b/Robust/src/Analysis/SSJava/LinearTypeCheck.java index f6d8d35a..aa500018 100644 --- a/Robust/src/Analysis/SSJava/LinearTypeCheck.java +++ b/Robust/src/Analysis/SSJava/LinearTypeCheck.java @@ -55,7 +55,7 @@ public class LinearTypeCheck { State state; SSJavaAnalysis ssjava; String needToNullify = null; - AssignmentNode prevAssignNode; + ExpressionNode prevAssignNode; Set linearTypeCheckSet; @@ -117,7 +117,9 @@ public class LinearTypeCheck { for (int mdIdx = 0; mdIdx < toanalyzeMethodList.size(); mdIdx++) { MethodDescriptor md = toanalyzeMethodList.get(mdIdx); - checkMethodBody(cd, md); + if (ssjava.needToCheckLinearType(md)) { + checkMethodBody(cd, md); + } } } @@ -364,9 +366,10 @@ public class LinearTypeCheck { } } - private void checkTertiaryNode(MethodDescriptor md, SymbolTable nametable, TertiaryNode en) { - // TODO Auto-generated method stub - + private void checkTertiaryNode(MethodDescriptor md, SymbolTable nametable, TertiaryNode tn) { + checkExpressionNode(md, nametable, tn.getCond()); + checkExpressionNode(md, nametable, tn.getTrueExpr()); + checkExpressionNode(md, nametable, tn.getFalseExpr()); } private void checkOffsetNode(MethodDescriptor md, SymbolTable nametable, OffsetNode en) { @@ -423,7 +426,7 @@ public class LinearTypeCheck { TypeDescriptor paramType = calleeMethodDesc.getParamType(i); - if (isReference(argNode.getType())) { + if (isReference(argNode.getType()) && !argNode.getType().isNull()) { boolean isParamOwnedByCallee = false; if (paramType.getExtension() != null) { @@ -579,11 +582,20 @@ public class LinearTypeCheck { } prevAssignNode = an; } else if (an.getSrc().kind() == Kind.ArrayAccessNode) { - if (an.getSrc().getType().isPtr()) { + TypeDescriptor srcType = an.getSrc().getType(); + if (srcType.isPtr() && !srcType.isString()) { throw new Error( "Not allowed to create an alias to the middle of the multidimensional array at " + md.getClassDesc().getSourceFileName() + "::" + an.getNumLine()); } + } else if (an.getSrc().kind() == Kind.CreateObjectNode + || an.getSrc().kind() == Kind.MethodInvokeNode + || an.getSrc().kind() == Kind.ArrayInitializerNode + || an.getSrc().kind() == Kind.LiteralNode) { + + } else { + throw new Error("Not allowed this type of assignment at " + + md.getClassDesc().getSourceFileName() + "::" + an.getNumLine()); } if (isCreatingAlias(an.getSrc())) { @@ -594,12 +606,17 @@ public class LinearTypeCheck { if (srcType.getExtension() != null) { SSJavaType srcLocationType = (SSJavaType) srcType.getExtension(); isSourceOwned = srcLocationType.isOwned(); + } else if (md.isConstructor() + && isFieldOfClass(md.getClassDesc(), an.getSrc().printNode(0))) { + isSourceOwned = true; } - if (!isField(an.getDest()) && isSourceOwned) { - // here, transfer ownership from LHS to RHS when it creates alias - TypeDescriptor destType = getTypeDescriptor(an.getDest()); - destType.setExtension(new SSJavaType(isSourceOwned)); + if (!isField(an.getDest())) { + if (isSourceOwned) { + // here, transfer ownership from LHS to RHS when it creates alias + TypeDescriptor destType = getTypeDescriptor(an.getDest()); + destType.setExtension(new SSJavaType(isSourceOwned)); + } } else { // if instance is not owned by the method, not able to store // instance into field @@ -618,6 +635,86 @@ public class LinearTypeCheck { } + private void checkSource(MethodDescriptor md, ExpressionNode src, ExpressionNode dst) { + + if (src.kind() == Kind.NameNode) { + + NameNode nn = (NameNode) src; + + if (nn.getField() != null) { + needToNullify = nn.getField().getSymbol(); + prevAssignNode = src; + } else if (nn.getExpression() != null) { + if (nn.getExpression() instanceof FieldAccessNode) { + FieldAccessNode fan = (FieldAccessNode) nn.getExpression(); + needToNullify = fan.printNode(0); + prevAssignNode = src; + + } + + } else { + // local variable case + linearTypeCheckSet.add(src); + mapTreeNode2FlatMethod.put(src, state.getMethodFlat(md)); + } + } else if (src.kind() == Kind.FieldAccessNode) { + FieldAccessNode fan = (FieldAccessNode) src; + needToNullify = fan.printNode(0); + if (needToNullify.startsWith("this.")) { + needToNullify = needToNullify.substring(5); + } + prevAssignNode = src; + } else if (src.kind() == Kind.ArrayAccessNode) { + TypeDescriptor srcType = src.getType(); + if (srcType.isPtr() && !srcType.isString()) { + throw new Error( + "Not allowed to create an alias to the middle of the multidimensional array at " + + md.getClassDesc().getSourceFileName() + "::" + src.getNumLine()); + } + } else if (src.kind() == Kind.CreateObjectNode || src.kind() == Kind.MethodInvokeNode + || src.kind() == Kind.ArrayInitializerNode || src.kind() == Kind.LiteralNode) { + + } else { + throw new Error("Not allowed this type of assignment at " + + md.getClassDesc().getSourceFileName() + "::" + src.getNumLine()); + } + + if (isCreatingAlias(src)) { + + TypeDescriptor srcType = getTypeDescriptor(src); + boolean isSourceOwned = false; + + if (srcType.getExtension() != null) { + SSJavaType srcLocationType = (SSJavaType) srcType.getExtension(); + isSourceOwned = srcLocationType.isOwned(); + } else if (md.isConstructor() && isFieldOfClass(md.getClassDesc(), src.printNode(0))) { + isSourceOwned = true; + } + + if (!isField(dst)) { + if (isSourceOwned) { + // here, transfer ownership from LHS to RHS when it creates alias + TypeDescriptor destType = getTypeDescriptor(dst); + destType.setExtension(new SSJavaType(isSourceOwned)); + } + } else { + // if instance is not owned by the method, not able to store + // instance into field + if (!isSourceOwned) { + throw new Error( + "Method is not allowed to store an instance not owned by itself into a field at " + + md.getClassDesc().getSourceFileName() + "::" + src.getNumLine()); + } + } + + } + + } + + private boolean isFieldOfClass(ClassDescriptor classDesc, String varName) { + return classDesc.getFieldTable().contains(varName); + } + private boolean isCreatingAlias(ExpressionNode en) { int kind = en.kind(); @@ -629,7 +726,6 @@ public class LinearTypeCheck { } private TypeDescriptor getTypeDescriptor(ExpressionNode en) { - if (en.kind() == Kind.NameNode) { NameNode nn = (NameNode) en; if (nn.getField() != null) { @@ -645,6 +741,9 @@ public class LinearTypeCheck { } else if (en.kind() == Kind.CreateObjectNode) { CreateObjectNode con = (CreateObjectNode) en; return con.getType(); + } else if (en.kind() == Kind.ArrayAccessNode) { + ArrayAccessNode aan = (ArrayAccessNode) en; + return aan.getExpression().getType(); } return null; @@ -673,8 +772,12 @@ public class LinearTypeCheck { checkExpressionNode(md, nametable, dn.getExpression()); if (dn.getExpression().kind() == Kind.CreateObjectNode) { dn.getVarDescriptor().getType().setExtension(new SSJavaType(true)); + } else if (dn.getExpression().kind() == Kind.ArrayAccessNode + && dn.getExpression().getType().isPtr()) { + throw new Error( + "Not allowed to create an alias to the middle of the multidimensional array at " + + md.getClassDesc().getSourceFileName() + "::" + dn.getNumLine()); } - } } diff --git a/Robust/src/Analysis/SSJava/MethodAnnotationCheck.java b/Robust/src/Analysis/SSJava/MethodAnnotationCheck.java index eba5f777..989903c7 100644 --- a/Robust/src/Analysis/SSJava/MethodAnnotationCheck.java +++ b/Robust/src/Analysis/SSJava/MethodAnnotationCheck.java @@ -4,7 +4,9 @@ import java.util.HashSet; import java.util.Hashtable; import java.util.Iterator; import java.util.Set; +import java.util.Vector; +import IR.AnnotationDescriptor; import IR.ClassDescriptor; import IR.MethodDescriptor; import IR.Operation; @@ -43,6 +45,7 @@ public class MethodAnnotationCheck { Set annotatedMDSet; Hashtable> caller2calleeSet; + Set trustWorthyMDSet; public MethodAnnotationCheck(SSJavaAnalysis ssjava, State state, TypeUtil tu) { this.ssjava = ssjava; @@ -50,6 +53,11 @@ public class MethodAnnotationCheck { this.tu = tu; caller2calleeSet = new Hashtable>(); annotatedMDSet = new HashSet(); + trustWorthyMDSet = new HashSet(); + } + + public Set getTrustWorthyMDSet() { + return trustWorthyMDSet; } public void methodAnnoatationCheck() { @@ -65,6 +73,7 @@ public class MethodAnnotationCheck { if (!cd.isInterface()) { for (Iterator method_it = cd.getMethods(); method_it.hasNext();) { MethodDescriptor md = (MethodDescriptor) method_it.next(); + checkTrustworthyMethodAnnotation(md); checkMethodBody(cd, md); } } @@ -92,19 +101,22 @@ public class MethodAnnotationCheck { if (!visited.contains(p)) { visited.add(p); - tovisit.add(calleeMD); + if (!trustWorthyMDSet.contains(calleeMD)) { + // if method is annotated as "TRUST", do not need to check for + // linear type & flow-down rule + tovisit.add(calleeMD); - Set possibleCalleeSet = - (Set) ssjava.getCallGraph().getMethods(calleeMD); + Set possibleCalleeSet = + (Set) ssjava.getCallGraph().getMethods(calleeMD); - for (Iterator iterator2 = possibleCalleeSet.iterator(); iterator2.hasNext();) { - MethodDescriptor possibleCallee = (MethodDescriptor) iterator2.next(); + for (Iterator iterator2 = possibleCalleeSet.iterator(); iterator2.hasNext();) { + MethodDescriptor possibleCallee = (MethodDescriptor) iterator2.next(); - if (!possibleCallee.isAbstract()) { - ssjava.addAnnotationRequire(possibleCallee); - tovisit.add(possibleCallee); + if (!possibleCallee.isAbstract()) { + ssjava.addAnnotationRequire(possibleCallee); + tovisit.add(possibleCallee); + } } - } } @@ -114,6 +126,19 @@ public class MethodAnnotationCheck { } + private void checkTrustworthyMethodAnnotation(MethodDescriptor md) { + // method annotation parsing + Vector methodAnnotations = md.getModifiers().getAnnotations(); + if (methodAnnotations != null) { + for (int i = 0; i < methodAnnotations.size(); i++) { + AnnotationDescriptor an = methodAnnotations.elementAt(i); + if (an.getMarker().equals(ssjava.TRUST)) { + trustWorthyMDSet.add(md); + } + } + } + } + public void methodAnnoataionInheritanceCheck() { // check If a method is annotated, any method that overrides it should // be annotated. @@ -144,19 +169,21 @@ public class MethodAnnotationCheck { } // need to check super classess if the current method is inherited from - // them, all of ancestor method should be annoated - ClassDescriptor currentCd = cd; - ClassDescriptor superCd = tu.getSuper(currentCd); - while (!superCd.getSymbol().equals("Object")) { - Set possiblematches = superCd.getMethodTable().getSet(md.getSymbol()); + // them, all of ancestor method should be annotated. + + ClassDescriptor curClassDesc; + ClassDescriptor parentClassDesc = cd; + + while (!parentClassDesc.getSymbol().equals("Object")) { + curClassDesc = parentClassDesc; + parentClassDesc = tu.getSuper(curClassDesc); + Set possiblematches = parentClassDesc.getMethodTable().getSet(md.getSymbol()); for (Iterator methodit = possiblematches.iterator(); methodit.hasNext();) { MethodDescriptor matchmd = (MethodDescriptor) methodit.next(); if (md.matches(matchmd)) { ssjava.addAnnotationRequire(matchmd); } } - currentCd = superCd; - superCd = tu.getSuper(currentCd); } Set superIFSet = tu.getSuperIFs(cd); diff --git a/Robust/src/Analysis/SSJava/SSJavaAnalysis.java b/Robust/src/Analysis/SSJava/SSJavaAnalysis.java index 752edfbd..6525be5d 100644 --- a/Robust/src/Analysis/SSJava/SSJavaAnalysis.java +++ b/Robust/src/Analysis/SSJava/SSJavaAnalysis.java @@ -21,7 +21,6 @@ import IR.State; import IR.TypeUtil; import IR.Flat.BuildFlat; import IR.Flat.FlatMethod; -import IR.Tree.TreeNode; import Util.Pair; public class SSJavaAnalysis { @@ -37,6 +36,7 @@ public class SSJavaAnalysis { public static final String TERMINATE = "TERMINATE"; public static final String DELEGATE = "DELEGATE"; public static final String DELEGATETHIS = "DELEGATETHIS"; + public static final String TRUST = "TRUST"; State state; TypeUtil tu; @@ -65,6 +65,9 @@ public class SSJavaAnalysis { // set containing a class that has at least one annoated method Set annotationRequireClassSet; + // the set of method descriptor required to check the linear type property + Set linearTypeCheckMethodSet; + CallGraph callgraph; LinearTypeCheck checker; @@ -80,12 +83,14 @@ public class SSJavaAnalysis { this.annotationRequireClassSet = new HashSet(); this.skipLoopTerminate = new Hashtable(); this.mapSharedLocation2DescriptorSet = new Hashtable>(); + this.linearTypeCheckMethodSet = new HashSet(); this.bf = bf; } public void doCheck() { - doLinearTypeCheck(); doMethodAnnotationCheck(); + computeLinearTypeCheckMethodSet(); + doLinearTypeCheck(); if (state.SSJAVADEBUG) { debugPrint(); } @@ -94,6 +99,36 @@ public class SSJavaAnalysis { doDefinitelyWrittenCheck(); } + private void computeLinearTypeCheckMethodSet() { + + Set allCalledSet = callgraph.getMethodCalls(tu.getMain()); + linearTypeCheckMethodSet.addAll(allCalledSet); + + Set trustedSet = new HashSet(); + + Set trustAnnoatedSet = methodAnnotationChecker.getTrustWorthyMDSet(); + + for (Iterator iterator = trustAnnoatedSet.iterator(); iterator.hasNext();) { + MethodDescriptor trustMethod = (MethodDescriptor) iterator.next(); + Set calledFromTrustMethodSet = callgraph.getMethodCalls(trustMethod); + trustedSet.add(trustMethod); + trustedSet.addAll(calledFromTrustMethodSet); + } + + linearTypeCheckMethodSet.removeAll(trustedSet); + + // if a method is called only by trusted method, no need to check linear + // type & flow down rule + for (Iterator iterator = trustedSet.iterator(); iterator.hasNext();) { + MethodDescriptor md = (MethodDescriptor) iterator.next(); + Set callerSet = callgraph.getCallerSet(md); + if (!trustedSet.containsAll(callerSet) && !trustAnnoatedSet.contains(md)) { + linearTypeCheckMethodSet.add(md); + } + } + + } + private void doLinearTypeCheck() { LinearTypeCheck checker = new LinearTypeCheck(this, state); checker.linearTypeCheck(); @@ -174,7 +209,6 @@ public class SSJavaAnalysis { if (value != null) { maxIteration = Integer.parseInt(value); } - System.out.println("###md=" + md); skipLoopTerminate.put(md, new Integer(maxIteration)); } } @@ -335,6 +369,10 @@ public class SSJavaAnalysis { } } + public boolean needToCheckLinearType(MethodDescriptor md) { + return linearTypeCheckMethodSet.contains(md); + } + public boolean needTobeAnnotated(MethodDescriptor md) { return annotationRequireSet.contains(md); } diff --git a/Robust/src/ClassLibrary/SSJava/String.java b/Robust/src/ClassLibrary/SSJava/String.java index ddacb966..7bbb303b 100644 --- a/Robust/src/ClassLibrary/SSJava/String.java +++ b/Robust/src/ClassLibrary/SSJava/String.java @@ -129,7 +129,6 @@ public class String { String newstr=new String(); newstr.count=this.count+str.count; char charstr[]=new char[newstr.count]; - newstr.value=charstr; newstr.offset=0; for(int i=0; iParams instance that describes the customizable * aspects of the decoder. */ - public Decoder(Params params0) { - if (params0 == null) - params0 = DEFAULT_PARAMS; + public Decoder(@DELEGATE Params params0) { + + if (params0 == null) { + params0 = getDefaultParams(); + } params = params0; @@ -109,20 +111,20 @@ public class Decoder implements DecoderErrors { return (Params) DEFAULT_PARAMS.clone(); } - public void setEqualizer(Equalizer eq) { - if (eq == null) - eq = Equalizer.PASS_THRU_EQ; - - equalizer.setFrom(eq); - - float[] factors = equalizer.getBandFactors(); - - if (filter1 != null) - filter1.setEQ(factors); - - if (filter2 != null) - filter2.setEQ(factors); - } + // public void setEqualizer(Equalizer eq) { + // if (eq == null) + // eq = Equalizer.PASS_THRU_EQ; + // + // equalizer.setFrom(eq); + // + // float[] factors = equalizer.getBandFactors(); + // + // if (filter1 != null) + // filter1.setEQ(factors); + // + // if (filter2 != null) + // filter2.setEQ(factors); + // } /** * Decodes one frame from an MPEG audio bitstream. @@ -136,56 +138,61 @@ public class Decoder implements DecoderErrors { */ @LATTICE("OParams class presents the customizable aspects of the * decoder. @@ -315,7 +250,9 @@ public class Decoder implements DecoderErrors { * Instances of this class are not thread safe. */ public static class Params implements Cloneable { - private OutputChannels outputChannels = OutputChannels.BOTH; + + // private OutputChannels outputChannels = OutputChannels.BOTH; + private OutputChannels outputChannels = new OutputChannels(0); private Equalizer equalizer = new Equalizer(); @@ -325,8 +262,8 @@ public class Decoder implements DecoderErrors { public Object clone() { // TODO: need to have better clone method Params clone = new Params(); - clone.outputChannels = outputChannels; - clone.equalizer = equalizer; + clone.outputChannels = new OutputChannels(outputChannels.getChannelsOutputCode()); + clone.equalizer = new Equalizer(); return clone; // try // { diff --git a/Robust/src/Tests/ssJava/mp3decoder/LayerIIIDecoder.java b/Robust/src/Tests/ssJava/mp3decoder/LayerIIIDecoder.java index b7fde809..3277f38b 100644 --- a/Robust/src/Tests/ssJava/mp3decoder/LayerIIIDecoder.java +++ b/Robust/src/Tests/ssJava/mp3decoder/LayerIIIDecoder.java @@ -72,14 +72,14 @@ final class LayerIIIDecoder implements FrameDecoder { private float[][] k; @LOC("NZ") private int[] nonzero; - @LOC("HD") - private Header header; + // @LOC("HD") + // private Header header; @LOC("FT") private SynthesisFilter filter1; @LOC("FT") private SynthesisFilter filter2; - @LOC("SP") - private Obuffer buffer; // output buffer + // @LOC("SP") + // private Obuffer buffer; // output buffer @LOC("CH0") private int which_channels; @LOC("BR") @@ -108,14 +108,14 @@ final class LayerIIIDecoder implements FrameDecoder { private int part2_start; - /** - * Constructor. - */ - // REVIEW: these constructor arguments should be moved to the - // decodeFrame() method, where possible, so that one - @LATTICE("THIS= is_1d.length) // System.out.println("i0="+i+"/"+(si.ch[ch].gr[gr].big_values<<1)+" Index="+index+" is_1d="+is_1d.length); @@ -895,16 +1075,18 @@ final class LayerIIIDecoder implements FrameDecoder { is_1d[index++] = y[0]; CheckSumHuff = CheckSumHuff + x[0] + y[0]; -// System.out.println("x = " + x[0] + " y = " + y[0]); + // System.out.println("x = " + x[0] + " y = " + y[0]); } // Read count1 area - h = huffcodetab.ht[si.ch[ch].gr[gr].count1table_select + 32]; + + int htIdx = si.ch[ch].gr[gr].count1table_select + 32; + // h = huffcodetab.ht[si.ch[ch].gr[gr].count1table_select + 32]; num_bits = br.hsstell(); while ((num_bits < part2_3_end) && (index < 576)) { - huffcodetab.huffman_decoder(h, x, y, v, w, br); + huffcodetab.huffman_decoder(htIdx, x, y, v, w, br); is_1d[index++] = v[0]; is_1d[index++] = w[0]; @@ -1245,7 +1427,7 @@ final class LayerIIIDecoder implements FrameDecoder { // ssjava @LATTICE("IOOutputChannels instance corresponding to the given + * channel code. + * + * @param code + * one of the OutputChannels channel code constants. + * + * @throws IllegalArgumentException + * if code is not a valid channel code. */ - public static final int LEFT_CHANNEL = 1; + static public OutputChannels fromInt(int code) { + switch (code) { + case LEFT_CHANNEL: + return LEFT; + case RIGHT_CHANNEL: + return RIGHT; + case BOTH_CHANNELS: + return BOTH; + case DOWNMIX_CHANNELS: + return DOWNMIX; + default: + throw new IllegalArgumentException("Invalid channel code: " + code); + } + } + + public OutputChannels(@LOC("IN") int channels) { + outputChannels = channels; + + if (channels < 0 || channels > 3) + throw new IllegalArgumentException("channels"); + } /** - * Flag to indicate output should include the right channel only. + * Retrieves the code representing the desired output channels. Will be one of + * LEFT_CHANNEL, RIGHT_CHANNEL, BOTH_CHANNELS or DOWNMIX_CHANNELS. + * + * @return the channel code represented by this instance. */ - public static final int RIGHT_CHANNEL = 2; + public int getChannelsOutputCode() { + return outputChannels; + } /** - * Flag to indicate output is mono. + * Retrieves the number of output channels represented by this channel output + * type. + * + * @return The number of output channels for this channel output type. This + * will be 2 for BOTH_CHANNELS only, and 1 for all other types. */ - public static final int DOWNMIX_CHANNELS = 3; - - - @LOC("B") public static final OutputChannels LEFT = new OutputChannels(LEFT_CHANNEL); - @LOC("B") public static final OutputChannels RIGHT = new OutputChannels(RIGHT_CHANNEL); - @LOC("B") public static final OutputChannels BOTH = new OutputChannels(BOTH_CHANNELS); - @LOC("B") public static final OutputChannels DOWNMIX = new OutputChannels(DOWNMIX_CHANNELS); - - - @LOC("T") private /*final*/ int outputChannels; - - /** - * Creates an OutputChannels instance - * corresponding to the given channel code. - * - * @param code one of the OutputChannels channel code constants. - * - * @throws IllegalArgumentException if code is not a valid - * channel code. - */ - static public OutputChannels fromInt(int code) - { - switch (code) - { - case LEFT_CHANNEL: - return LEFT; - case RIGHT_CHANNEL: - return RIGHT; - case BOTH_CHANNELS: - return BOTH; - case DOWNMIX_CHANNELS: - return DOWNMIX; - default: - throw new IllegalArgumentException("Invalid channel code: "+code); - } - } - - private OutputChannels(@LOC("IN") int channels) - { - outputChannels = channels; - - if (channels<0 || channels>3) - throw new IllegalArgumentException("channels"); - } - - /** - * Retrieves the code representing the desired output channels. - * Will be one of LEFT_CHANNEL, RIGHT_CHANNEL, BOTH_CHANNELS - * or DOWNMIX_CHANNELS. - * - * @return the channel code represented by this instance. - */ - public int getChannelsOutputCode() - { - return outputChannels; - } - - /** - * Retrieves the number of output channels represented - * by this channel output type. - * - * @return The number of output channels for this channel output - * type. This will be 2 for BOTH_CHANNELS only, and 1 - * for all other types. - */ - public int getChannelCount() - { - int count = (outputChannels==BOTH_CHANNELS) ? 2 : 1; - return count; - } - - - public boolean equals(Object o) - { - boolean equals = false; - - if (o instanceof OutputChannels) - { - OutputChannels oc = (OutputChannels)o; - equals = (oc.outputChannels == outputChannels); - } - - return equals; - } - - public int hashCode() - { - return outputChannels; - } - + public int getChannelCount() { + int count = (outputChannels == BOTH_CHANNELS) ? 2 : 1; + return count; + } + + public boolean equals(Object o) { + boolean equals = false; + + if (o instanceof OutputChannels) { + OutputChannels oc = (OutputChannels) o; + equals = (oc.outputChannels == outputChannels); + } + + return equals; + } + + public int hashCode() { + return outputChannels; + } + } diff --git a/Robust/src/Tests/ssJava/mp3decoder/Player.java b/Robust/src/Tests/ssJava/mp3decoder/Player.java index 3d59e83c..2c54b3d7 100644 --- a/Robust/src/Tests/ssJava/mp3decoder/Player.java +++ b/Robust/src/Tests/ssJava/mp3decoder/Player.java @@ -1,3 +1,5 @@ +import java.awt.image.SampleModel; + import FileOutputStream; /* @@ -41,9 +43,7 @@ public class Player { /** * The MPEG audio bitstream. */ - // javac blank final bug. - /* final */@LOC("ST") - private Bitstream bitstream; + // private Bitstream bitstream; /** * The MPEG audio decoder. @@ -74,12 +74,12 @@ public class Player { /** * Creates a new Player instance. */ - public Player(InputStream stream) throws JavaLayerException { - this(stream, null); + public Player() throws JavaLayerException { + this(null); } - public Player(InputStream stream, AudioDevice device) throws JavaLayerException { - bitstream = new Bitstream(stream); + public Player(AudioDevice device) throws JavaLayerException { + // bitstream = new Bitstream(stream); decoder = new Decoder(); // if (device!=null) @@ -112,15 +112,11 @@ public class Player { public boolean play(@LOC("IN") int frames) throws JavaLayerException { @LOC("IN") boolean ret = true; - // FileOutputStream fos = new FileOutputStream("output.txt"); - int count = 0; SSJAVA: while (frames-- > 0 && ret) { ret = decodeFrame(); } - // fos.flush(); - // fos.close(); /* * if (!ret) { // last frame, ensure all data flushed to the audio device. * AudioDevice out = audio; if (out!=null) { out.flush(); synchronized @@ -183,25 +179,22 @@ public class Player { // if (out==null) // return false; - Header h = bitstream.readFrame(); + // Header h = bitstream.readFrame(); + Header h = BitstreamWrapper.readFrame(); if (h == null) return false; - // eom debug - // System.out.println("header framesize=" + h.framesize); - // System.out.println("br total="+h.getBitReserve().hsstell()); - // - - // sample buffer set when decoder constructed - @LOC("O") SampleBuffer output = (SampleBuffer) decoder.decodeFrame(h, bitstream); + // @LOC("O") SampleBuffer output = (SampleBuffer) decoder.decodeFrame(h); + decoder.decodeFrame(h); // eom debug - int sum=0; - short[] outbuf = output.getBuffer(); - for (int i = 0; i < output.getBufferLength(); i++) { -// System.out.println(outbuf[i]); - sum+=outbuf[i]; + int sum = 0; + short[] outbuf = SampleBufferWrapper.getOutput().getBuffer(); + // short[] outbuf = output.getBuffer(); + for (int i = 0; i < SampleBufferWrapper.getOutput().getBufferLength(); i++) { + // System.out.println(outbuf[i]); + sum += outbuf[i]; } System.out.println(sum); // diff --git a/Robust/src/Tests/ssJava/mp3decoder/SampleBufferWrapper.java b/Robust/src/Tests/ssJava/mp3decoder/SampleBufferWrapper.java new file mode 100644 index 00000000..45f96ef9 --- /dev/null +++ b/Robust/src/Tests/ssJava/mp3decoder/SampleBufferWrapper.java @@ -0,0 +1,15 @@ +public class SampleBufferWrapper { + + static SampleBuffer output; + + @TRUST + static void init(int freq, int channels) { + output = new SampleBuffer(freq, channels); + } + + @TRUST + static SampleBuffer getOutput() { + return output; + } + +} diff --git a/Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java b/Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java index f9b7a4a2..39871d82 100644 --- a/Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java +++ b/Robust/src/Tests/ssJava/mp3decoder/SynthesisFilter.java @@ -35,9 +35,11 @@ * are removed by ignoring higher subbands. */ final class SynthesisFilter { + private int vcount = 0; + private int vidx = 1; private float[] v1; private float[] v2; - private float[] actual_v; // v1 or v2 + // private float[] actual_v; // v1 or v2 private int actual_write_pos; // 0-15 private float[] samples; // 32 new subband samples private int channel; @@ -63,7 +65,7 @@ final class SynthesisFilter { * short values (raw pcm samples are in [-1.0, 1.0], if no violations occur). */ public SynthesisFilter(int channelnumber, float factor, float[] eq0) { - + d16 = splitArray(d, 16); v1 = new float[512]; @@ -71,14 +73,9 @@ final class SynthesisFilter { samples = new float[32]; channel = channelnumber; scalefactor = factor; - setEQ(eq); + // setEQ(eq); // setQuality(HIGH_QUALITY); - reset(); - } - - public void setEQ(float[] eq0) { - this.eq = eq0; if (eq == null) { eq = new float[32]; for (int i = 0; i < 32; i++) @@ -88,6 +85,17 @@ final class SynthesisFilter { throw new IllegalArgumentException("eq0"); } + // reset(); + + for (int p = 0; p < 512; p++) + v1[p] = v2[p] = 0.0f; + + for (int p2 = 0; p2 < 32; p2++) + samples[p2] = 0.0f; + + // actual_v = v1; + actual_write_pos = 15; + } /* @@ -118,7 +126,7 @@ final class SynthesisFilter { for (int p2 = 0; p2 < 32; p2++) samples[p2] = 0.0f; - actual_v = v1; + // actual_v = v1; actual_write_pos = 15; } @@ -135,25 +143,7 @@ final class SynthesisFilter { } } - /** - * Compute new values via a fast cosine transform. - */ - private void compute_new_v() { - // p is fully initialized from x1 - // float[] p = _p; - // pp is fully initialized from p - // float[] pp = _pp; - - // float[] new_v = _new_v; - - // float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure - // 3-A.2 in ISO DIS 11172-3 - // float[] p = new float[16]; - // float[] pp = new float[16]; - - /* - * for (int i=31; i>=0; i--) { new_v[i] = 0.0f; } - */ + private void compute_new_v2_v1() { float new_v0, new_v1, new_v2, new_v3, new_v4, new_v5, new_v6, new_v7, new_v8, new_v9; float new_v10, new_v11, new_v12, new_v13, new_v14, new_v15, new_v16, new_v17, new_v18, new_v19; @@ -199,40 +189,40 @@ final class SynthesisFilter { // float[] p = new float[16]; // float[] pp = new float[16]; - float[] s = samples; - - float s0 = s[0]; - float s1 = s[1]; - float s2 = s[2]; - float s3 = s[3]; - float s4 = s[4]; - float s5 = s[5]; - float s6 = s[6]; - float s7 = s[7]; - float s8 = s[8]; - float s9 = s[9]; - float s10 = s[10]; - float s11 = s[11]; - float s12 = s[12]; - float s13 = s[13]; - float s14 = s[14]; - float s15 = s[15]; - float s16 = s[16]; - float s17 = s[17]; - float s18 = s[18]; - float s19 = s[19]; - float s20 = s[20]; - float s21 = s[21]; - float s22 = s[22]; - float s23 = s[23]; - float s24 = s[24]; - float s25 = s[25]; - float s26 = s[26]; - float s27 = s[27]; - float s28 = s[28]; - float s29 = s[29]; - float s30 = s[30]; - float s31 = s[31]; + // float[] s = samples; + + float s0 = samples[0]; + float s1 = samples[1]; + float s2 = samples[2]; + float s3 = samples[3]; + float s4 = samples[4]; + float s5 = samples[5]; + float s6 = samples[6]; + float s7 = samples[7]; + float s8 = samples[8]; + float s9 = samples[9]; + float s10 = samples[10]; + float s11 = samples[11]; + float s12 = samples[12]; + float s13 = samples[13]; + float s14 = samples[14]; + float s15 = samples[15]; + float s16 = samples[16]; + float s17 = samples[17]; + float s18 = samples[18]; + float s19 = samples[19]; + float s20 = samples[20]; + float s21 = samples[21]; + float s22 = samples[22]; + float s23 = samples[23]; + float s24 = samples[24]; + float s25 = samples[25]; + float s26 = samples[26]; + float s27 = samples[27]; + float s28 = samples[28]; + float s29 = samples[29]; + float s30 = samples[30]; + float s31 = samples[31]; float p0 = s0 + s31; float p1 = s1 + s30; @@ -434,379 +424,447 @@ final class SynthesisFilter { // insert V[0-15] (== new_v[0-15]) into actual v: // float[] x2 = actual_v + actual_write_pos; - float dest[] = actual_v; + // float dest[] = actual_v; v2 int pos = actual_write_pos; - dest[0 + pos] = new_v0; - dest[16 + pos] = new_v1; - dest[32 + pos] = new_v2; - dest[48 + pos] = new_v3; - dest[64 + pos] = new_v4; - dest[80 + pos] = new_v5; - dest[96 + pos] = new_v6; - dest[112 + pos] = new_v7; - dest[128 + pos] = new_v8; - dest[144 + pos] = new_v9; - dest[160 + pos] = new_v10; - dest[176 + pos] = new_v11; - dest[192 + pos] = new_v12; - dest[208 + pos] = new_v13; - dest[224 + pos] = new_v14; - dest[240 + pos] = new_v15; + v2[0 + pos] = new_v0; + v2[16 + pos] = new_v1; + v2[32 + pos] = new_v2; + v2[48 + pos] = new_v3; + v2[64 + pos] = new_v4; + v2[80 + pos] = new_v5; + v2[96 + pos] = new_v6; + v2[112 + pos] = new_v7; + v2[128 + pos] = new_v8; + v2[144 + pos] = new_v9; + v2[160 + pos] = new_v10; + v2[176 + pos] = new_v11; + v2[192 + pos] = new_v12; + v2[208 + pos] = new_v13; + v2[224 + pos] = new_v14; + v2[240 + pos] = new_v15; // V[16] is always 0.0: - dest[256 + pos] = 0.0f; + v2[256 + pos] = 0.0f; // insert V[17-31] (== -new_v[15-1]) into actual v: - dest[272 + pos] = -new_v15; - dest[288 + pos] = -new_v14; - dest[304 + pos] = -new_v13; - dest[320 + pos] = -new_v12; - dest[336 + pos] = -new_v11; - dest[352 + pos] = -new_v10; - dest[368 + pos] = -new_v9; - dest[384 + pos] = -new_v8; - dest[400 + pos] = -new_v7; - dest[416 + pos] = -new_v6; - dest[432 + pos] = -new_v5; - dest[448 + pos] = -new_v4; - dest[464 + pos] = -new_v3; - dest[480 + pos] = -new_v2; - dest[496 + pos] = -new_v1; + v2[272 + pos] = -new_v15; + v2[288 + pos] = -new_v14; + v2[304 + pos] = -new_v13; + v2[320 + pos] = -new_v12; + v2[336 + pos] = -new_v11; + v2[352 + pos] = -new_v10; + v2[368 + pos] = -new_v9; + v2[384 + pos] = -new_v8; + v2[400 + pos] = -new_v7; + v2[416 + pos] = -new_v6; + v2[432 + pos] = -new_v5; + v2[448 + pos] = -new_v4; + v2[464 + pos] = -new_v3; + v2[480 + pos] = -new_v2; + v2[496 + pos] = -new_v1; // insert V[32] (== -new_v[0]) into other v: - dest = (actual_v == v1) ? v2 : v1; + // dest = (actual_v == v1) ? v2 : v1; - dest[0 + pos] = -new_v0; + v1[0 + pos] = -new_v0; // insert V[33-48] (== new_v[16-31]) into other v: - dest[16 + pos] = new_v16; - dest[32 + pos] = new_v17; - dest[48 + pos] = new_v18; - dest[64 + pos] = new_v19; - dest[80 + pos] = new_v20; - dest[96 + pos] = new_v21; - dest[112 + pos] = new_v22; - dest[128 + pos] = new_v23; - dest[144 + pos] = new_v24; - dest[160 + pos] = new_v25; - dest[176 + pos] = new_v26; - dest[192 + pos] = new_v27; - dest[208 + pos] = new_v28; - dest[224 + pos] = new_v29; - dest[240 + pos] = new_v30; - dest[256 + pos] = new_v31; + v1[16 + pos] = new_v16; + v1[32 + pos] = new_v17; + v1[48 + pos] = new_v18; + v1[64 + pos] = new_v19; + v1[80 + pos] = new_v20; + v1[96 + pos] = new_v21; + v1[112 + pos] = new_v22; + v1[128 + pos] = new_v23; + v1[144 + pos] = new_v24; + v1[160 + pos] = new_v25; + v1[176 + pos] = new_v26; + v1[192 + pos] = new_v27; + v1[208 + pos] = new_v28; + v1[224 + pos] = new_v29; + v1[240 + pos] = new_v30; + v1[256 + pos] = new_v31; // insert V[49-63] (== new_v[30-16]) into other v: - dest[272 + pos] = new_v30; - dest[288 + pos] = new_v29; - dest[304 + pos] = new_v28; - dest[320 + pos] = new_v27; - dest[336 + pos] = new_v26; - dest[352 + pos] = new_v25; - dest[368 + pos] = new_v24; - dest[384 + pos] = new_v23; - dest[400 + pos] = new_v22; - dest[416 + pos] = new_v21; - dest[432 + pos] = new_v20; - dest[448 + pos] = new_v19; - dest[464 + pos] = new_v18; - dest[480 + pos] = new_v17; - dest[496 + pos] = new_v16; - /* - * } else { v1[0 + actual_write_pos] = -new_v0; // insert V[33-48] (== - * new_v[16-31]) into other v: v1[16 + actual_write_pos] = new_v16; v1[32 + - * actual_write_pos] = new_v17; v1[48 + actual_write_pos] = new_v18; v1[64 + - * actual_write_pos] = new_v19; v1[80 + actual_write_pos] = new_v20; v1[96 + - * actual_write_pos] = new_v21; v1[112 + actual_write_pos] = new_v22; v1[128 - * + actual_write_pos] = new_v23; v1[144 + actual_write_pos] = new_v24; - * v1[160 + actual_write_pos] = new_v25; v1[176 + actual_write_pos] = - * new_v26; v1[192 + actual_write_pos] = new_v27; v1[208 + actual_write_pos] - * = new_v28; v1[224 + actual_write_pos] = new_v29; v1[240 + - * actual_write_pos] = new_v30; v1[256 + actual_write_pos] = new_v31; - * - * // insert V[49-63] (== new_v[30-16]) into other v: v1[272 + - * actual_write_pos] = new_v30; v1[288 + actual_write_pos] = new_v29; v1[304 - * + actual_write_pos] = new_v28; v1[320 + actual_write_pos] = new_v27; - * v1[336 + actual_write_pos] = new_v26; v1[352 + actual_write_pos] = - * new_v25; v1[368 + actual_write_pos] = new_v24; v1[384 + actual_write_pos] - * = new_v23; v1[400 + actual_write_pos] = new_v22; v1[416 + - * actual_write_pos] = new_v21; v1[432 + actual_write_pos] = new_v20; v1[448 - * + actual_write_pos] = new_v19; v1[464 + actual_write_pos] = new_v18; - * v1[480 + actual_write_pos] = new_v17; v1[496 + actual_write_pos] = - * new_v16; } - */ + v1[272 + pos] = new_v30; + v1[288 + pos] = new_v29; + v1[304 + pos] = new_v28; + v1[320 + pos] = new_v27; + v1[336 + pos] = new_v26; + v1[352 + pos] = new_v25; + v1[368 + pos] = new_v24; + v1[384 + pos] = new_v23; + v1[400 + pos] = new_v22; + v1[416 + pos] = new_v21; + v1[432 + pos] = new_v20; + v1[448 + pos] = new_v19; + v1[464 + pos] = new_v18; + v1[480 + pos] = new_v17; + v1[496 + pos] = new_v16; } - /** - * Compute new values via a fast cosine transform. - */ - private void compute_new_v_old() { - // p is fully initialized from x1 - // float[] p = _p; - // pp is fully initialized from p - // float[] pp = _pp; - - // float[] new_v = _new_v; + private void compute_new_v1_v2() { - float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure 3-A.2 - // in ISO DIS 11172-3 - float[] p = new float[16]; - float[] pp = new float[16]; + float new_v0, new_v1, new_v2, new_v3, new_v4, new_v5, new_v6, new_v7, new_v8, new_v9; + float new_v10, new_v11, new_v12, new_v13, new_v14, new_v15, new_v16, new_v17, new_v18, new_v19; + float new_v20, new_v21, new_v22, new_v23, new_v24, new_v25, new_v26, new_v27, new_v28, new_v29; + float new_v30, new_v31; - for (int i = 31; i >= 0; i--) { - new_v[i] = 0.0f; - } + new_v0 = + new_v1 = + new_v2 = + new_v3 = + new_v4 = + new_v5 = + new_v6 = + new_v7 = + new_v8 = + new_v9 = + new_v10 = + new_v11 = + new_v12 = + new_v13 = + new_v14 = + new_v15 = + new_v16 = + new_v17 = + new_v18 = + new_v19 = + new_v20 = + new_v21 = + new_v22 = + new_v23 = + new_v24 = + new_v25 = + new_v26 = + new_v27 = + new_v28 = + new_v29 = + new_v30 = + new_v31 = + 0.0f; // float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure // 3-A.2 in ISO DIS 11172-3 // float[] p = new float[16]; // float[] pp = new float[16]; - float[] x1 = samples; - - p[0] = x1[0] + x1[31]; - p[1] = x1[1] + x1[30]; - p[2] = x1[2] + x1[29]; - p[3] = x1[3] + x1[28]; - p[4] = x1[4] + x1[27]; - p[5] = x1[5] + x1[26]; - p[6] = x1[6] + x1[25]; - p[7] = x1[7] + x1[24]; - p[8] = x1[8] + x1[23]; - p[9] = x1[9] + x1[22]; - p[10] = x1[10] + x1[21]; - p[11] = x1[11] + x1[20]; - p[12] = x1[12] + x1[19]; - p[13] = x1[13] + x1[18]; - p[14] = x1[14] + x1[17]; - p[15] = x1[15] + x1[16]; - - pp[0] = p[0] + p[15]; - pp[1] = p[1] + p[14]; - pp[2] = p[2] + p[13]; - pp[3] = p[3] + p[12]; - pp[4] = p[4] + p[11]; - pp[5] = p[5] + p[10]; - pp[6] = p[6] + p[9]; - pp[7] = p[7] + p[8]; - pp[8] = (p[0] - p[15]) * cos1_32; - pp[9] = (p[1] - p[14]) * cos3_32; - pp[10] = (p[2] - p[13]) * cos5_32; - pp[11] = (p[3] - p[12]) * cos7_32; - pp[12] = (p[4] - p[11]) * cos9_32; - pp[13] = (p[5] - p[10]) * cos11_32; - pp[14] = (p[6] - p[9]) * cos13_32; - pp[15] = (p[7] - p[8]) * cos15_32; - - p[0] = pp[0] + pp[7]; - p[1] = pp[1] + pp[6]; - p[2] = pp[2] + pp[5]; - p[3] = pp[3] + pp[4]; - p[4] = (pp[0] - pp[7]) * cos1_16; - p[5] = (pp[1] - pp[6]) * cos3_16; - p[6] = (pp[2] - pp[5]) * cos5_16; - p[7] = (pp[3] - pp[4]) * cos7_16; - p[8] = pp[8] + pp[15]; - p[9] = pp[9] + pp[14]; - p[10] = pp[10] + pp[13]; - p[11] = pp[11] + pp[12]; - p[12] = (pp[8] - pp[15]) * cos1_16; - p[13] = (pp[9] - pp[14]) * cos3_16; - p[14] = (pp[10] - pp[13]) * cos5_16; - p[15] = (pp[11] - pp[12]) * cos7_16; - - pp[0] = p[0] + p[3]; - pp[1] = p[1] + p[2]; - pp[2] = (p[0] - p[3]) * cos1_8; - pp[3] = (p[1] - p[2]) * cos3_8; - pp[4] = p[4] + p[7]; - pp[5] = p[5] + p[6]; - pp[6] = (p[4] - p[7]) * cos1_8; - pp[7] = (p[5] - p[6]) * cos3_8; - pp[8] = p[8] + p[11]; - pp[9] = p[9] + p[10]; - pp[10] = (p[8] - p[11]) * cos1_8; - pp[11] = (p[9] - p[10]) * cos3_8; - pp[12] = p[12] + p[15]; - pp[13] = p[13] + p[14]; - pp[14] = (p[12] - p[15]) * cos1_8; - pp[15] = (p[13] - p[14]) * cos3_8; - - p[0] = pp[0] + pp[1]; - p[1] = (pp[0] - pp[1]) * cos1_4; - p[2] = pp[2] + pp[3]; - p[3] = (pp[2] - pp[3]) * cos1_4; - p[4] = pp[4] + pp[5]; - p[5] = (pp[4] - pp[5]) * cos1_4; - p[6] = pp[6] + pp[7]; - p[7] = (pp[6] - pp[7]) * cos1_4; - p[8] = pp[8] + pp[9]; - p[9] = (pp[8] - pp[9]) * cos1_4; - p[10] = pp[10] + pp[11]; - p[11] = (pp[10] - pp[11]) * cos1_4; - p[12] = pp[12] + pp[13]; - p[13] = (pp[12] - pp[13]) * cos1_4; - p[14] = pp[14] + pp[15]; - p[15] = (pp[14] - pp[15]) * cos1_4; + // float[] s = samples; + + float s0 = samples[0]; + float s1 = samples[1]; + float s2 = samples[2]; + float s3 = samples[3]; + float s4 = samples[4]; + float s5 = samples[5]; + float s6 = samples[6]; + float s7 = samples[7]; + float s8 = samples[8]; + float s9 = samples[9]; + float s10 = samples[10]; + float s11 = samples[11]; + float s12 = samples[12]; + float s13 = samples[13]; + float s14 = samples[14]; + float s15 = samples[15]; + float s16 = samples[16]; + float s17 = samples[17]; + float s18 = samples[18]; + float s19 = samples[19]; + float s20 = samples[20]; + float s21 = samples[21]; + float s22 = samples[22]; + float s23 = samples[23]; + float s24 = samples[24]; + float s25 = samples[25]; + float s26 = samples[26]; + float s27 = samples[27]; + float s28 = samples[28]; + float s29 = samples[29]; + float s30 = samples[30]; + float s31 = samples[31]; + + float p0 = s0 + s31; + float p1 = s1 + s30; + float p2 = s2 + s29; + float p3 = s3 + s28; + float p4 = s4 + s27; + float p5 = s5 + s26; + float p6 = s6 + s25; + float p7 = s7 + s24; + float p8 = s8 + s23; + float p9 = s9 + s22; + float p10 = s10 + s21; + float p11 = s11 + s20; + float p12 = s12 + s19; + float p13 = s13 + s18; + float p14 = s14 + s17; + float p15 = s15 + s16; + + float pp0 = p0 + p15; + float pp1 = p1 + p14; + float pp2 = p2 + p13; + float pp3 = p3 + p12; + float pp4 = p4 + p11; + float pp5 = p5 + p10; + float pp6 = p6 + p9; + float pp7 = p7 + p8; + float pp8 = (p0 - p15) * cos1_32; + float pp9 = (p1 - p14) * cos3_32; + float pp10 = (p2 - p13) * cos5_32; + float pp11 = (p3 - p12) * cos7_32; + float pp12 = (p4 - p11) * cos9_32; + float pp13 = (p5 - p10) * cos11_32; + float pp14 = (p6 - p9) * cos13_32; + float pp15 = (p7 - p8) * cos15_32; + + p0 = pp0 + pp7; + p1 = pp1 + pp6; + p2 = pp2 + pp5; + p3 = pp3 + pp4; + p4 = (pp0 - pp7) * cos1_16; + p5 = (pp1 - pp6) * cos3_16; + p6 = (pp2 - pp5) * cos5_16; + p7 = (pp3 - pp4) * cos7_16; + p8 = pp8 + pp15; + p9 = pp9 + pp14; + p10 = pp10 + pp13; + p11 = pp11 + pp12; + p12 = (pp8 - pp15) * cos1_16; + p13 = (pp9 - pp14) * cos3_16; + p14 = (pp10 - pp13) * cos5_16; + p15 = (pp11 - pp12) * cos7_16; + + pp0 = p0 + p3; + pp1 = p1 + p2; + pp2 = (p0 - p3) * cos1_8; + pp3 = (p1 - p2) * cos3_8; + pp4 = p4 + p7; + pp5 = p5 + p6; + pp6 = (p4 - p7) * cos1_8; + pp7 = (p5 - p6) * cos3_8; + pp8 = p8 + p11; + pp9 = p9 + p10; + pp10 = (p8 - p11) * cos1_8; + pp11 = (p9 - p10) * cos3_8; + pp12 = p12 + p15; + pp13 = p13 + p14; + pp14 = (p12 - p15) * cos1_8; + pp15 = (p13 - p14) * cos3_8; + + p0 = pp0 + pp1; + p1 = (pp0 - pp1) * cos1_4; + p2 = pp2 + pp3; + p3 = (pp2 - pp3) * cos1_4; + p4 = pp4 + pp5; + p5 = (pp4 - pp5) * cos1_4; + p6 = pp6 + pp7; + p7 = (pp6 - pp7) * cos1_4; + p8 = pp8 + pp9; + p9 = (pp8 - pp9) * cos1_4; + p10 = pp10 + pp11; + p11 = (pp10 - pp11) * cos1_4; + p12 = pp12 + pp13; + p13 = (pp12 - pp13) * cos1_4; + p14 = pp14 + pp15; + p15 = (pp14 - pp15) * cos1_4; // this is pretty insane coding float tmp1; - new_v[36 - 17] = -(new_v[4] = (new_v[12] = p[7]) + p[5]) - p[6]; - new_v[44 - 17] = -p[6] - p[7] - p[4]; - new_v[6] = (new_v[10] = (new_v[14] = p[15]) + p[11]) + p[13]; - new_v[34 - 17] = -(new_v[2] = p[15] + p[13] + p[9]) - p[14]; - new_v[38 - 17] = (tmp1 = -p[14] - p[15] - p[10] - p[11]) - p[13]; - new_v[46 - 17] = -p[14] - p[15] - p[12] - p[8]; - new_v[42 - 17] = tmp1 - p[12]; - new_v[48 - 17] = -p[0]; - new_v[0] = p[1]; - new_v[40 - 17] = -(new_v[8] = p[3]) - p[2]; - - p[0] = (x1[0] - x1[31]) * cos1_64; - p[1] = (x1[1] - x1[30]) * cos3_64; - p[2] = (x1[2] - x1[29]) * cos5_64; - p[3] = (x1[3] - x1[28]) * cos7_64; - p[4] = (x1[4] - x1[27]) * cos9_64; - p[5] = (x1[5] - x1[26]) * cos11_64; - p[6] = (x1[6] - x1[25]) * cos13_64; - p[7] = (x1[7] - x1[24]) * cos15_64; - p[8] = (x1[8] - x1[23]) * cos17_64; - p[9] = (x1[9] - x1[22]) * cos19_64; - p[10] = (x1[10] - x1[21]) * cos21_64; - p[11] = (x1[11] - x1[20]) * cos23_64; - p[12] = (x1[12] - x1[19]) * cos25_64; - p[13] = (x1[13] - x1[18]) * cos27_64; - p[14] = (x1[14] - x1[17]) * cos29_64; - p[15] = (x1[15] - x1[16]) * cos31_64; - - pp[0] = p[0] + p[15]; - pp[1] = p[1] + p[14]; - pp[2] = p[2] + p[13]; - pp[3] = p[3] + p[12]; - pp[4] = p[4] + p[11]; - pp[5] = p[5] + p[10]; - pp[6] = p[6] + p[9]; - pp[7] = p[7] + p[8]; - pp[8] = (p[0] - p[15]) * cos1_32; - pp[9] = (p[1] - p[14]) * cos3_32; - pp[10] = (p[2] - p[13]) * cos5_32; - pp[11] = (p[3] - p[12]) * cos7_32; - pp[12] = (p[4] - p[11]) * cos9_32; - pp[13] = (p[5] - p[10]) * cos11_32; - pp[14] = (p[6] - p[9]) * cos13_32; - pp[15] = (p[7] - p[8]) * cos15_32; - - p[0] = pp[0] + pp[7]; - p[1] = pp[1] + pp[6]; - p[2] = pp[2] + pp[5]; - p[3] = pp[3] + pp[4]; - p[4] = (pp[0] - pp[7]) * cos1_16; - p[5] = (pp[1] - pp[6]) * cos3_16; - p[6] = (pp[2] - pp[5]) * cos5_16; - p[7] = (pp[3] - pp[4]) * cos7_16; - p[8] = pp[8] + pp[15]; - p[9] = pp[9] + pp[14]; - p[10] = pp[10] + pp[13]; - p[11] = pp[11] + pp[12]; - p[12] = (pp[8] - pp[15]) * cos1_16; - p[13] = (pp[9] - pp[14]) * cos3_16; - p[14] = (pp[10] - pp[13]) * cos5_16; - p[15] = (pp[11] - pp[12]) * cos7_16; - - pp[0] = p[0] + p[3]; - pp[1] = p[1] + p[2]; - pp[2] = (p[0] - p[3]) * cos1_8; - pp[3] = (p[1] - p[2]) * cos3_8; - pp[4] = p[4] + p[7]; - pp[5] = p[5] + p[6]; - pp[6] = (p[4] - p[7]) * cos1_8; - pp[7] = (p[5] - p[6]) * cos3_8; - pp[8] = p[8] + p[11]; - pp[9] = p[9] + p[10]; - pp[10] = (p[8] - p[11]) * cos1_8; - pp[11] = (p[9] - p[10]) * cos3_8; - pp[12] = p[12] + p[15]; - pp[13] = p[13] + p[14]; - pp[14] = (p[12] - p[15]) * cos1_8; - pp[15] = (p[13] - p[14]) * cos3_8; - - p[0] = pp[0] + pp[1]; - p[1] = (pp[0] - pp[1]) * cos1_4; - p[2] = pp[2] + pp[3]; - p[3] = (pp[2] - pp[3]) * cos1_4; - p[4] = pp[4] + pp[5]; - p[5] = (pp[4] - pp[5]) * cos1_4; - p[6] = pp[6] + pp[7]; - p[7] = (pp[6] - pp[7]) * cos1_4; - p[8] = pp[8] + pp[9]; - p[9] = (pp[8] - pp[9]) * cos1_4; - p[10] = pp[10] + pp[11]; - p[11] = (pp[10] - pp[11]) * cos1_4; - p[12] = pp[12] + pp[13]; - p[13] = (pp[12] - pp[13]) * cos1_4; - p[14] = pp[14] + pp[15]; - p[15] = (pp[14] - pp[15]) * cos1_4; + new_v19/* 36-17 */= -(new_v4 = (new_v12 = p7) + p5) - p6; + new_v27/* 44-17 */= -p6 - p7 - p4; + new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13; + new_v17/* 34-17 */= -(new_v2 = p15 + p13 + p9) - p14; + new_v21/* 38-17 */= (tmp1 = -p14 - p15 - p10 - p11) - p13; + new_v29/* 46-17 */= -p14 - p15 - p12 - p8; + new_v25/* 42-17 */= tmp1 - p12; + new_v31/* 48-17 */= -p0; + new_v0 = p1; + new_v23/* 40-17 */= -(new_v8 = p3) - p2; + + p0 = (s0 - s31) * cos1_64; + p1 = (s1 - s30) * cos3_64; + p2 = (s2 - s29) * cos5_64; + p3 = (s3 - s28) * cos7_64; + p4 = (s4 - s27) * cos9_64; + p5 = (s5 - s26) * cos11_64; + p6 = (s6 - s25) * cos13_64; + p7 = (s7 - s24) * cos15_64; + p8 = (s8 - s23) * cos17_64; + p9 = (s9 - s22) * cos19_64; + p10 = (s10 - s21) * cos21_64; + p11 = (s11 - s20) * cos23_64; + p12 = (s12 - s19) * cos25_64; + p13 = (s13 - s18) * cos27_64; + p14 = (s14 - s17) * cos29_64; + p15 = (s15 - s16) * cos31_64; + + pp0 = p0 + p15; + pp1 = p1 + p14; + pp2 = p2 + p13; + pp3 = p3 + p12; + pp4 = p4 + p11; + pp5 = p5 + p10; + pp6 = p6 + p9; + pp7 = p7 + p8; + pp8 = (p0 - p15) * cos1_32; + pp9 = (p1 - p14) * cos3_32; + pp10 = (p2 - p13) * cos5_32; + pp11 = (p3 - p12) * cos7_32; + pp12 = (p4 - p11) * cos9_32; + pp13 = (p5 - p10) * cos11_32; + pp14 = (p6 - p9) * cos13_32; + pp15 = (p7 - p8) * cos15_32; + + p0 = pp0 + pp7; + p1 = pp1 + pp6; + p2 = pp2 + pp5; + p3 = pp3 + pp4; + p4 = (pp0 - pp7) * cos1_16; + p5 = (pp1 - pp6) * cos3_16; + p6 = (pp2 - pp5) * cos5_16; + p7 = (pp3 - pp4) * cos7_16; + p8 = pp8 + pp15; + p9 = pp9 + pp14; + p10 = pp10 + pp13; + p11 = pp11 + pp12; + p12 = (pp8 - pp15) * cos1_16; + p13 = (pp9 - pp14) * cos3_16; + p14 = (pp10 - pp13) * cos5_16; + p15 = (pp11 - pp12) * cos7_16; + + pp0 = p0 + p3; + pp1 = p1 + p2; + pp2 = (p0 - p3) * cos1_8; + pp3 = (p1 - p2) * cos3_8; + pp4 = p4 + p7; + pp5 = p5 + p6; + pp6 = (p4 - p7) * cos1_8; + pp7 = (p5 - p6) * cos3_8; + pp8 = p8 + p11; + pp9 = p9 + p10; + pp10 = (p8 - p11) * cos1_8; + pp11 = (p9 - p10) * cos3_8; + pp12 = p12 + p15; + pp13 = p13 + p14; + pp14 = (p12 - p15) * cos1_8; + pp15 = (p13 - p14) * cos3_8; + + p0 = pp0 + pp1; + p1 = (pp0 - pp1) * cos1_4; + p2 = pp2 + pp3; + p3 = (pp2 - pp3) * cos1_4; + p4 = pp4 + pp5; + p5 = (pp4 - pp5) * cos1_4; + p6 = pp6 + pp7; + p7 = (pp6 - pp7) * cos1_4; + p8 = pp8 + pp9; + p9 = (pp8 - pp9) * cos1_4; + p10 = pp10 + pp11; + p11 = (pp10 - pp11) * cos1_4; + p12 = pp12 + pp13; + p13 = (pp12 - pp13) * cos1_4; + p14 = pp14 + pp15; + p15 = (pp14 - pp15) * cos1_4; // manually doing something that a compiler should handle sucks // coding like this is hard to read float tmp2; - new_v[5] = (new_v[11] = (new_v[13] = (new_v[15] = p[15]) + p[7]) + p[11]) + p[5] + p[13]; - new_v[7] = (new_v[9] = p[15] + p[11] + p[3]) + p[13]; - new_v[33 - 17] = -(new_v[1] = (tmp1 = p[13] + p[15] + p[9]) + p[1]) - p[14]; - new_v[35 - 17] = -(new_v[3] = tmp1 + p[5] + p[7]) - p[6] - p[14]; - - new_v[39 - 17] = (tmp1 = -p[10] - p[11] - p[14] - p[15]) - p[13] - p[2] - p[3]; - new_v[37 - 17] = tmp1 - p[13] - p[5] - p[6] - p[7]; - new_v[41 - 17] = tmp1 - p[12] - p[2] - p[3]; - new_v[43 - 17] = tmp1 - p[12] - (tmp2 = p[4] + p[6] + p[7]); - new_v[47 - 17] = (tmp1 = -p[8] - p[12] - p[14] - p[15]) - p[0]; - new_v[45 - 17] = tmp1 - tmp2; + new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11) + p5 + p13; + new_v7 = (new_v9 = p15 + p11 + p3) + p13; + new_v16/* 33-17 */= -(new_v1 = (tmp1 = p13 + p15 + p9) + p1) - p14; + new_v18/* 35-17 */= -(new_v3 = tmp1 + p5 + p7) - p6 - p14; + + new_v22/* 39-17 */= (tmp1 = -p10 - p11 - p14 - p15) - p13 - p2 - p3; + new_v20/* 37-17 */= tmp1 - p13 - p5 - p6 - p7; + new_v24/* 41-17 */= tmp1 - p12 - p2 - p3; + new_v26/* 43-17 */= tmp1 - p12 - (tmp2 = p4 + p6 + p7); + new_v30/* 47-17 */= (tmp1 = -p8 - p12 - p14 - p15) - p0; + new_v28/* 45-17 */= tmp1 - tmp2; // insert V[0-15] (== new_v[0-15]) into actual v: - x1 = new_v; // float[] x2 = actual_v + actual_write_pos; - float[] dest = actual_v; - - dest[0 + actual_write_pos] = x1[0]; - dest[16 + actual_write_pos] = x1[1]; - dest[32 + actual_write_pos] = x1[2]; - dest[48 + actual_write_pos] = x1[3]; - dest[64 + actual_write_pos] = x1[4]; - dest[80 + actual_write_pos] = x1[5]; - dest[96 + actual_write_pos] = x1[6]; - dest[112 + actual_write_pos] = x1[7]; - dest[128 + actual_write_pos] = x1[8]; - dest[144 + actual_write_pos] = x1[9]; - dest[160 + actual_write_pos] = x1[10]; - dest[176 + actual_write_pos] = x1[11]; - dest[192 + actual_write_pos] = x1[12]; - dest[208 + actual_write_pos] = x1[13]; - dest[224 + actual_write_pos] = x1[14]; - dest[240 + actual_write_pos] = x1[15]; + // float dest[] = actual_v; actual_v=v1; + + int pos = actual_write_pos; + + v1[0 + pos] = new_v0; + v1[16 + pos] = new_v1; + v1[32 + pos] = new_v2; + v1[48 + pos] = new_v3; + v1[64 + pos] = new_v4; + v1[80 + pos] = new_v5; + v1[96 + pos] = new_v6; + v1[112 + pos] = new_v7; + v1[128 + pos] = new_v8; + v1[144 + pos] = new_v9; + v1[160 + pos] = new_v10; + v1[176 + pos] = new_v11; + v1[192 + pos] = new_v12; + v1[208 + pos] = new_v13; + v1[224 + pos] = new_v14; + v1[240 + pos] = new_v15; // V[16] is always 0.0: - dest[256 + actual_write_pos] = 0.0f; + v1[256 + pos] = 0.0f; // insert V[17-31] (== -new_v[15-1]) into actual v: - dest[272 + actual_write_pos] = -x1[15]; - dest[288 + actual_write_pos] = -x1[14]; - dest[304 + actual_write_pos] = -x1[13]; - dest[320 + actual_write_pos] = -x1[12]; - dest[336 + actual_write_pos] = -x1[11]; - dest[352 + actual_write_pos] = -x1[10]; - dest[368 + actual_write_pos] = -x1[9]; - dest[384 + actual_write_pos] = -x1[8]; - dest[400 + actual_write_pos] = -x1[7]; - dest[416 + actual_write_pos] = -x1[6]; - dest[432 + actual_write_pos] = -x1[5]; - dest[448 + actual_write_pos] = -x1[4]; - dest[464 + actual_write_pos] = -x1[3]; - dest[480 + actual_write_pos] = -x1[2]; - dest[496 + actual_write_pos] = -x1[1]; + v1[272 + pos] = -new_v15; + v1[288 + pos] = -new_v14; + v1[304 + pos] = -new_v13; + v1[320 + pos] = -new_v12; + v1[336 + pos] = -new_v11; + v1[352 + pos] = -new_v10; + v1[368 + pos] = -new_v9; + v1[384 + pos] = -new_v8; + v1[400 + pos] = -new_v7; + v1[416 + pos] = -new_v6; + v1[432 + pos] = -new_v5; + v1[448 + pos] = -new_v4; + v1[464 + pos] = -new_v3; + v1[480 + pos] = -new_v2; + v1[496 + pos] = -new_v1; // insert V[32] (== -new_v[0]) into other v: + // dest = (actual_v == v1) ? v2 : v1; + v2[0 + pos] = -new_v0; + // insert V[33-48] (== new_v[16-31]) into other v: + v2[16 + pos] = new_v16; + v2[32 + pos] = new_v17; + v2[48 + pos] = new_v18; + v2[64 + pos] = new_v19; + v2[80 + pos] = new_v20; + v2[96 + pos] = new_v21; + v2[112 + pos] = new_v22; + v2[128 + pos] = new_v23; + v2[144 + pos] = new_v24; + v2[160 + pos] = new_v25; + v2[176 + pos] = new_v26; + v2[192 + pos] = new_v27; + v2[208 + pos] = new_v28; + v2[224 + pos] = new_v29; + v2[240 + pos] = new_v30; + v2[256 + pos] = new_v31; + + // insert V[49-63] (== new_v[30-16]) into other v: + v2[272 + pos] = new_v30; + v2[288 + pos] = new_v29; + v2[304 + pos] = new_v28; + v2[320 + pos] = new_v27; + v2[336 + pos] = new_v26; + v2[352 + pos] = new_v25; + v2[368 + pos] = new_v24; + v2[384 + pos] = new_v23; + v2[400 + pos] = new_v22; + v2[416 + pos] = new_v21; + v2[432 + pos] = new_v20; + v2[448 + pos] = new_v19; + v2[464 + pos] = new_v18; + v2[480 + pos] = new_v17; + v2[496 + pos] = new_v16; } /** @@ -815,455 +873,953 @@ final class SynthesisFilter { private float[] _tmpOut = new float[32]; - private void compute_pcm_samples0(Obuffer buffer) { - final float[] vp = actual_v; - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - float pcm_sample; - final float[] dp = d16[i]; - pcm_sample = - (float) (((vp[0 + dvp] * dp[0]) + (vp[15 + dvp] * dp[1]) + (vp[14 + dvp] * dp[2]) - + (vp[13 + dvp] * dp[3]) + (vp[12 + dvp] * dp[4]) + (vp[11 + dvp] * dp[5]) - + (vp[10 + dvp] * dp[6]) + (vp[9 + dvp] * dp[7]) + (vp[8 + dvp] * dp[8]) - + (vp[7 + dvp] * dp[9]) + (vp[6 + dvp] * dp[10]) + (vp[5 + dvp] * dp[11]) - + (vp[4 + dvp] * dp[12]) + (vp[3 + dvp] * dp[13]) + (vp[2 + dvp] * dp[14]) + (vp[1 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; - - dvp += 16; - } // for - } - - private void compute_pcm_samples1(Obuffer buffer) { - final float[] vp = actual_v; - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[1 + dvp] * dp[0]) + (vp[0 + dvp] * dp[1]) + (vp[15 + dvp] * dp[2]) - + (vp[14 + dvp] * dp[3]) + (vp[13 + dvp] * dp[4]) + (vp[12 + dvp] * dp[5]) - + (vp[11 + dvp] * dp[6]) + (vp[10 + dvp] * dp[7]) + (vp[9 + dvp] * dp[8]) - + (vp[8 + dvp] * dp[9]) + (vp[7 + dvp] * dp[10]) + (vp[6 + dvp] * dp[11]) - + (vp[5 + dvp] * dp[12]) + (vp[4 + dvp] * dp[13]) + (vp[3 + dvp] * dp[14]) + (vp[2 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples0() { + + if (vidx == 1) { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + float pcm_sample; + // final float[] dp = d16[i]; + pcm_sample = + (float) (((v1[0 + dvp] * d16[i][0]) + (v1[15 + dvp] * d16[i][1]) + + (v1[14 + dvp] * d16[i][2]) + (v1[13 + dvp] * d16[i][3]) + + (v1[12 + dvp] * d16[i][4]) + (v1[11 + dvp] * d16[i][5]) + + (v1[10 + dvp] * d16[i][6]) + (v1[9 + dvp] * d16[i][7]) + + (v1[8 + dvp] * d16[i][8]) + (v1[7 + dvp] * d16[i][9]) + + (v1[6 + dvp] * d16[i][10]) + (v1[5 + dvp] * d16[i][11]) + + (v1[4 + dvp] * d16[i][12]) + (v1[3 + dvp] * d16[i][13]) + + (v1[2 + dvp] * d16[i][14]) + (v1[1 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + float pcm_sample; + // final float[] dp = d16[i]; + pcm_sample = + (float) (((v2[0 + dvp] * d16[i][0]) + (v2[15 + dvp] * d16[i][1]) + + (v2[14 + dvp] * d16[i][2]) + (v2[13 + dvp] * d16[i][3]) + + (v2[12 + dvp] * d16[i][4]) + (v2[11 + dvp] * d16[i][5]) + + (v2[10 + dvp] * d16[i][6]) + (v2[9 + dvp] * d16[i][7]) + + (v2[8 + dvp] * d16[i][8]) + (v2[7 + dvp] * d16[i][9]) + + (v2[6 + dvp] * d16[i][10]) + (v2[5 + dvp] * d16[i][11]) + + (v2[4 + dvp] * d16[i][12]) + (v2[3 + dvp] * d16[i][13]) + + (v2[2 + dvp] * d16[i][14]) + (v2[1 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples2(Obuffer buffer) { - final float[] vp = actual_v; - - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[2 + dvp] * dp[0]) + (vp[1 + dvp] * dp[1]) + (vp[0 + dvp] * dp[2]) - + (vp[15 + dvp] * dp[3]) + (vp[14 + dvp] * dp[4]) + (vp[13 + dvp] * dp[5]) - + (vp[12 + dvp] * dp[6]) + (vp[11 + dvp] * dp[7]) + (vp[10 + dvp] * dp[8]) - + (vp[9 + dvp] * dp[9]) + (vp[8 + dvp] * dp[10]) + (vp[7 + dvp] * dp[11]) - + (vp[6 + dvp] * dp[12]) + (vp[5 + dvp] * dp[13]) + (vp[4 + dvp] * dp[14]) + (vp[3 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples1() { + + if (vidx == 1) { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[1 + dvp] * d16[i][0]) + (v1[0 + dvp] * d16[i][1]) + + (v1[15 + dvp] * d16[i][2]) + (v1[14 + dvp] * d16[i][3]) + + (v1[13 + dvp] * d16[i][4]) + (v1[12 + dvp] * d16[i][5]) + + (v1[11 + dvp] * d16[i][6]) + (v1[10 + dvp] * d16[i][7]) + + (v1[9 + dvp] * d16[i][8]) + (v1[8 + dvp] * d16[i][9]) + + (v1[7 + dvp] * d16[i][10]) + (v1[6 + dvp] * d16[i][11]) + + (v1[5 + dvp] * d16[i][12]) + (v1[4 + dvp] * d16[i][13]) + + (v1[3 + dvp] * d16[i][14]) + (v1[2 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[1 + dvp] * d16[i][0]) + (v2[0 + dvp] * d16[i][1]) + + (v2[15 + dvp] * d16[i][2]) + (v2[14 + dvp] * d16[i][3]) + + (v2[13 + dvp] * d16[i][4]) + (v2[12 + dvp] * d16[i][5]) + + (v2[11 + dvp] * d16[i][6]) + (v2[10 + dvp] * d16[i][7]) + + (v2[9 + dvp] * d16[i][8]) + (v2[8 + dvp] * d16[i][9]) + + (v2[7 + dvp] * d16[i][10]) + (v2[6 + dvp] * d16[i][11]) + + (v2[5 + dvp] * d16[i][12]) + (v2[4 + dvp] * d16[i][13]) + + (v2[3 + dvp] * d16[i][14]) + (v2[2 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples3(Obuffer buffer) { - final float[] vp = actual_v; - - int idx = 0; - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[3 + dvp] * dp[0]) + (vp[2 + dvp] * dp[1]) + (vp[1 + dvp] * dp[2]) - + (vp[0 + dvp] * dp[3]) + (vp[15 + dvp] * dp[4]) + (vp[14 + dvp] * dp[5]) - + (vp[13 + dvp] * dp[6]) + (vp[12 + dvp] * dp[7]) + (vp[11 + dvp] * dp[8]) - + (vp[10 + dvp] * dp[9]) + (vp[9 + dvp] * dp[10]) + (vp[8 + dvp] * dp[11]) - + (vp[7 + dvp] * dp[12]) + (vp[6 + dvp] * dp[13]) + (vp[5 + dvp] * dp[14]) + (vp[4 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples2() { + + if (vidx == 1) { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[2 + dvp] * d16[i][0]) + (v1[1 + dvp] * d16[i][1]) + + (v1[0 + dvp] * d16[i][2]) + (v1[15 + dvp] * d16[i][3]) + + (v1[14 + dvp] * d16[i][4]) + (v1[13 + dvp] * d16[i][5]) + + (v1[12 + dvp] * d16[i][6]) + (v1[11 + dvp] * d16[i][7]) + + (v1[10 + dvp] * d16[i][8]) + (v1[9 + dvp] * d16[i][9]) + + (v1[8 + dvp] * d16[i][10]) + (v1[7 + dvp] * d16[i][11]) + + (v1[6 + dvp] * d16[i][12]) + (v1[5 + dvp] * d16[i][13]) + + (v1[4 + dvp] * d16[i][14]) + (v1[3 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[2 + dvp] * d16[i][0]) + (v2[1 + dvp] * d16[i][1]) + + (v2[0 + dvp] * d16[i][2]) + (v2[15 + dvp] * d16[i][3]) + + (v2[14 + dvp] * d16[i][4]) + (v2[13 + dvp] * d16[i][5]) + + (v2[12 + dvp] * d16[i][6]) + (v2[11 + dvp] * d16[i][7]) + + (v2[10 + dvp] * d16[i][8]) + (v2[9 + dvp] * d16[i][9]) + + (v2[8 + dvp] * d16[i][10]) + (v2[7 + dvp] * d16[i][11]) + + (v2[6 + dvp] * d16[i][12]) + (v2[5 + dvp] * d16[i][13]) + + (v2[4 + dvp] * d16[i][14]) + (v2[3 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples4(Obuffer buffer) { - final float[] vp = actual_v; - - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[4 + dvp] * dp[0]) + (vp[3 + dvp] * dp[1]) + (vp[2 + dvp] * dp[2]) - + (vp[1 + dvp] * dp[3]) + (vp[0 + dvp] * dp[4]) + (vp[15 + dvp] * dp[5]) - + (vp[14 + dvp] * dp[6]) + (vp[13 + dvp] * dp[7]) + (vp[12 + dvp] * dp[8]) - + (vp[11 + dvp] * dp[9]) + (vp[10 + dvp] * dp[10]) + (vp[9 + dvp] * dp[11]) - + (vp[8 + dvp] * dp[12]) + (vp[7 + dvp] * dp[13]) + (vp[6 + dvp] * dp[14]) + (vp[5 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples3() { + + if (vidx == 1) { + // final float[] vp = actual_v; + + int idx = 0; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[3 + dvp] * d16[i][0]) + (v1[2 + dvp] * d16[i][1]) + + (v1[1 + dvp] * d16[i][2]) + (v1[0 + dvp] * d16[i][3]) + + (v1[15 + dvp] * d16[i][4]) + (v1[14 + dvp] * d16[i][5]) + + (v1[13 + dvp] * d16[i][6]) + (v1[12 + dvp] * d16[i][7]) + + (v1[11 + dvp] * d16[i][8]) + (v1[10 + dvp] * d16[i][9]) + + (v1[9 + dvp] * d16[i][10]) + (v1[8 + dvp] * d16[i][11]) + + (v1[7 + dvp] * d16[i][12]) + (v1[6 + dvp] * d16[i][13]) + + (v1[5 + dvp] * d16[i][14]) + (v1[4 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + int idx = 0; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[3 + dvp] * d16[i][0]) + (v2[2 + dvp] * d16[i][1]) + + (v2[1 + dvp] * d16[i][2]) + (v2[0 + dvp] * d16[i][3]) + + (v2[15 + dvp] * d16[i][4]) + (v2[14 + dvp] * d16[i][5]) + + (v2[13 + dvp] * d16[i][6]) + (v2[12 + dvp] * d16[i][7]) + + (v2[11 + dvp] * d16[i][8]) + (v2[10 + dvp] * d16[i][9]) + + (v2[9 + dvp] * d16[i][10]) + (v2[8 + dvp] * d16[i][11]) + + (v2[7 + dvp] * d16[i][12]) + (v2[6 + dvp] * d16[i][13]) + + (v2[5 + dvp] * d16[i][14]) + (v2[4 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples5(Obuffer buffer) { - final float[] vp = actual_v; - - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[5 + dvp] * dp[0]) + (vp[4 + dvp] * dp[1]) + (vp[3 + dvp] * dp[2]) - + (vp[2 + dvp] * dp[3]) + (vp[1 + dvp] * dp[4]) + (vp[0 + dvp] * dp[5]) - + (vp[15 + dvp] * dp[6]) + (vp[14 + dvp] * dp[7]) + (vp[13 + dvp] * dp[8]) - + (vp[12 + dvp] * dp[9]) + (vp[11 + dvp] * dp[10]) + (vp[10 + dvp] * dp[11]) - + (vp[9 + dvp] * dp[12]) + (vp[8 + dvp] * dp[13]) + (vp[7 + dvp] * dp[14]) + (vp[6 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples4() { + + if (vidx == 1) { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[4 + dvp] * d16[i][0]) + (v1[3 + dvp] * d16[i][1]) + + (v1[2 + dvp] * d16[i][2]) + (v1[1 + dvp] * d16[i][3]) + (v1[0 + dvp] * d16[i][4]) + + (v1[15 + dvp] * d16[i][5]) + (v1[14 + dvp] * d16[i][6]) + + (v1[13 + dvp] * d16[i][7]) + (v1[12 + dvp] * d16[i][8]) + + (v1[11 + dvp] * d16[i][9]) + (v1[10 + dvp] * d16[i][10]) + + (v1[9 + dvp] * d16[i][11]) + (v1[8 + dvp] * d16[i][12]) + + (v1[7 + dvp] * d16[i][13]) + (v1[6 + dvp] * d16[i][14]) + (v1[5 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[4 + dvp] * d16[i][0]) + (v2[3 + dvp] * d16[i][1]) + + (v2[2 + dvp] * d16[i][2]) + (v2[1 + dvp] * d16[i][3]) + (v2[0 + dvp] * d16[i][4]) + + (v2[15 + dvp] * d16[i][5]) + (v2[14 + dvp] * d16[i][6]) + + (v2[13 + dvp] * d16[i][7]) + (v2[12 + dvp] * d16[i][8]) + + (v2[11 + dvp] * d16[i][9]) + (v2[10 + dvp] * d16[i][10]) + + (v2[9 + dvp] * d16[i][11]) + (v2[8 + dvp] * d16[i][12]) + + (v2[7 + dvp] * d16[i][13]) + (v2[6 + dvp] * d16[i][14]) + (v2[5 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples6(Obuffer buffer) { - final float[] vp = actual_v; - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[6 + dvp] * dp[0]) + (vp[5 + dvp] * dp[1]) + (vp[4 + dvp] * dp[2]) - + (vp[3 + dvp] * dp[3]) + (vp[2 + dvp] * dp[4]) + (vp[1 + dvp] * dp[5]) - + (vp[0 + dvp] * dp[6]) + (vp[15 + dvp] * dp[7]) + (vp[14 + dvp] * dp[8]) - + (vp[13 + dvp] * dp[9]) + (vp[12 + dvp] * dp[10]) + (vp[11 + dvp] * dp[11]) - + (vp[10 + dvp] * dp[12]) + (vp[9 + dvp] * dp[13]) + (vp[8 + dvp] * dp[14]) + (vp[7 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples5() { + + if (vidx == 1) { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[5 + dvp] * d16[i][0]) + (v1[4 + dvp] * d16[i][1]) + + (v1[3 + dvp] * d16[i][2]) + (v1[2 + dvp] * d16[i][3]) + (v1[1 + dvp] * d16[i][4]) + + (v1[0 + dvp] * d16[i][5]) + (v1[15 + dvp] * d16[i][6]) + + (v1[14 + dvp] * d16[i][7]) + (v1[13 + dvp] * d16[i][8]) + + (v1[12 + dvp] * d16[i][9]) + (v1[11 + dvp] * d16[i][10]) + + (v1[10 + dvp] * d16[i][11]) + (v1[9 + dvp] * d16[i][12]) + + (v1[8 + dvp] * d16[i][13]) + (v1[7 + dvp] * d16[i][14]) + (v1[6 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[5 + dvp] * d16[i][0]) + (v2[4 + dvp] * d16[i][1]) + + (v2[3 + dvp] * d16[i][2]) + (v2[2 + dvp] * d16[i][3]) + (v2[1 + dvp] * d16[i][4]) + + (v2[0 + dvp] * d16[i][5]) + (v2[15 + dvp] * d16[i][6]) + + (v2[14 + dvp] * d16[i][7]) + (v2[13 + dvp] * d16[i][8]) + + (v2[12 + dvp] * d16[i][9]) + (v2[11 + dvp] * d16[i][10]) + + (v2[10 + dvp] * d16[i][11]) + (v2[9 + dvp] * d16[i][12]) + + (v2[8 + dvp] * d16[i][13]) + (v2[7 + dvp] * d16[i][14]) + (v2[6 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples7(Obuffer buffer) { - final float[] vp = actual_v; - - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[7 + dvp] * dp[0]) + (vp[6 + dvp] * dp[1]) + (vp[5 + dvp] * dp[2]) - + (vp[4 + dvp] * dp[3]) + (vp[3 + dvp] * dp[4]) + (vp[2 + dvp] * dp[5]) - + (vp[1 + dvp] * dp[6]) + (vp[0 + dvp] * dp[7]) + (vp[15 + dvp] * dp[8]) - + (vp[14 + dvp] * dp[9]) + (vp[13 + dvp] * dp[10]) + (vp[12 + dvp] * dp[11]) - + (vp[11 + dvp] * dp[12]) + (vp[10 + dvp] * dp[13]) + (vp[9 + dvp] * dp[14]) + (vp[8 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples6() { + + if (vidx == 1) { + + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[6 + dvp] * d16[i][0]) + (v1[5 + dvp] * d16[i][1]) + + (v1[4 + dvp] * d16[i][2]) + (v1[3 + dvp] * d16[i][3]) + (v1[2 + dvp] * d16[i][4]) + + (v1[1 + dvp] * d16[i][5]) + (v1[0 + dvp] * d16[i][6]) + + (v1[15 + dvp] * d16[i][7]) + (v1[14 + dvp] * d16[i][8]) + + (v1[13 + dvp] * d16[i][9]) + (v1[12 + dvp] * d16[i][10]) + + (v1[11 + dvp] * d16[i][11]) + (v1[10 + dvp] * d16[i][12]) + + (v1[9 + dvp] * d16[i][13]) + (v1[8 + dvp] * d16[i][14]) + (v1[7 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[6 + dvp] * d16[i][0]) + (v2[5 + dvp] * d16[i][1]) + + (v2[4 + dvp] * d16[i][2]) + (v2[3 + dvp] * d16[i][3]) + (v2[2 + dvp] * d16[i][4]) + + (v2[1 + dvp] * d16[i][5]) + (v2[0 + dvp] * d16[i][6]) + + (v2[15 + dvp] * d16[i][7]) + (v2[14 + dvp] * d16[i][8]) + + (v2[13 + dvp] * d16[i][9]) + (v2[12 + dvp] * d16[i][10]) + + (v2[11 + dvp] * d16[i][11]) + (v2[10 + dvp] * d16[i][12]) + + (v2[9 + dvp] * d16[i][13]) + (v2[8 + dvp] * d16[i][14]) + (v2[7 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples8(Obuffer buffer) { - final float[] vp = actual_v; - - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[8 + dvp] * dp[0]) + (vp[7 + dvp] * dp[1]) + (vp[6 + dvp] * dp[2]) - + (vp[5 + dvp] * dp[3]) + (vp[4 + dvp] * dp[4]) + (vp[3 + dvp] * dp[5]) - + (vp[2 + dvp] * dp[6]) + (vp[1 + dvp] * dp[7]) + (vp[0 + dvp] * dp[8]) - + (vp[15 + dvp] * dp[9]) + (vp[14 + dvp] * dp[10]) + (vp[13 + dvp] * dp[11]) - + (vp[12 + dvp] * dp[12]) + (vp[11 + dvp] * dp[13]) + (vp[10 + dvp] * dp[14]) + (vp[9 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples7() { + + if (vidx == 1) { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[7 + dvp] * d16[i][0]) + (v1[6 + dvp] * d16[i][1]) + + (v1[5 + dvp] * d16[i][2]) + (v1[4 + dvp] * d16[i][3]) + (v1[3 + dvp] * d16[i][4]) + + (v1[2 + dvp] * d16[i][5]) + (v1[1 + dvp] * d16[i][6]) + (v1[0 + dvp] * d16[i][7]) + + (v1[15 + dvp] * d16[i][8]) + (v1[14 + dvp] * d16[i][9]) + + (v1[13 + dvp] * d16[i][10]) + (v1[12 + dvp] * d16[i][11]) + + (v1[11 + dvp] * d16[i][12]) + (v1[10 + dvp] * d16[i][13]) + + (v1[9 + dvp] * d16[i][14]) + (v1[8 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[7 + dvp] * d16[i][0]) + (v2[6 + dvp] * d16[i][1]) + + (v2[5 + dvp] * d16[i][2]) + (v2[4 + dvp] * d16[i][3]) + (v2[3 + dvp] * d16[i][4]) + + (v2[2 + dvp] * d16[i][5]) + (v2[1 + dvp] * d16[i][6]) + (v2[0 + dvp] * d16[i][7]) + + (v2[15 + dvp] * d16[i][8]) + (v2[14 + dvp] * d16[i][9]) + + (v2[13 + dvp] * d16[i][10]) + (v2[12 + dvp] * d16[i][11]) + + (v2[11 + dvp] * d16[i][12]) + (v2[10 + dvp] * d16[i][13]) + + (v2[9 + dvp] * d16[i][14]) + (v2[8 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples9(Obuffer buffer) { - final float[] vp = actual_v; - - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; + private void compute_pcm_samples8() { - pcm_sample = - (float) (((vp[9 + dvp] * dp[0]) + (vp[8 + dvp] * dp[1]) + (vp[7 + dvp] * dp[2]) - + (vp[6 + dvp] * dp[3]) + (vp[5 + dvp] * dp[4]) + (vp[4 + dvp] * dp[5]) - + (vp[3 + dvp] * dp[6]) + (vp[2 + dvp] * dp[7]) + (vp[1 + dvp] * dp[8]) - + (vp[0 + dvp] * dp[9]) + (vp[15 + dvp] * dp[10]) + (vp[14 + dvp] * dp[11]) - + (vp[13 + dvp] * dp[12]) + (vp[12 + dvp] * dp[13]) + (vp[11 + dvp] * dp[14]) + (vp[10 + dvp] * dp[15])) * scalefactor); + if (vidx == 1) { - tmpOut[i] = pcm_sample; + // final float[] vp = actual_v; - dvp += 16; - } // for - } + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; - private void compute_pcm_samples10(Obuffer buffer) { - final float[] vp = actual_v; - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; + pcm_sample = + (float) (((v1[8 + dvp] * d16[i][0]) + (v1[7 + dvp] * d16[i][1]) + + (v1[6 + dvp] * d16[i][2]) + (v1[5 + dvp] * d16[i][3]) + (v1[4 + dvp] * d16[i][4]) + + (v1[3 + dvp] * d16[i][5]) + (v1[2 + dvp] * d16[i][6]) + (v1[1 + dvp] * d16[i][7]) + + (v1[0 + dvp] * d16[i][8]) + (v1[15 + dvp] * d16[i][9]) + + (v1[14 + dvp] * d16[i][10]) + (v1[13 + dvp] * d16[i][11]) + + (v1[12 + dvp] * d16[i][12]) + (v1[11 + dvp] * d16[i][13]) + + (v1[10 + dvp] * d16[i][14]) + (v1[9 + dvp] * d16[i][15])) * scalefactor); - pcm_sample = - (float) (((vp[10 + dvp] * dp[0]) + (vp[9 + dvp] * dp[1]) + (vp[8 + dvp] * dp[2]) - + (vp[7 + dvp] * dp[3]) + (vp[6 + dvp] * dp[4]) + (vp[5 + dvp] * dp[5]) - + (vp[4 + dvp] * dp[6]) + (vp[3 + dvp] * dp[7]) + (vp[2 + dvp] * dp[8]) - + (vp[1 + dvp] * dp[9]) + (vp[0 + dvp] * dp[10]) + (vp[15 + dvp] * dp[11]) - + (vp[14 + dvp] * dp[12]) + (vp[13 + dvp] * dp[13]) + (vp[12 + dvp] * dp[14]) + (vp[11 + dvp] * dp[15])) * scalefactor); + _tmpOut[i] = pcm_sample; - tmpOut[i] = pcm_sample; + dvp += 16; + } // for + } else { - dvp += 16; - } // for - } + // final float[] vp = actual_v; - private void compute_pcm_samples11(Obuffer buffer) { - final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; + pcm_sample = + (float) (((v2[8 + dvp] * d16[i][0]) + (v2[7 + dvp] * d16[i][1]) + + (v2[6 + dvp] * d16[i][2]) + (v2[5 + dvp] * d16[i][3]) + (v2[4 + dvp] * d16[i][4]) + + (v2[3 + dvp] * d16[i][5]) + (v2[2 + dvp] * d16[i][6]) + (v2[1 + dvp] * d16[i][7]) + + (v2[0 + dvp] * d16[i][8]) + (v2[15 + dvp] * d16[i][9]) + + (v2[14 + dvp] * d16[i][10]) + (v2[13 + dvp] * d16[i][11]) + + (v2[12 + dvp] * d16[i][12]) + (v2[11 + dvp] * d16[i][13]) + + (v2[10 + dvp] * d16[i][14]) + (v2[9 + dvp] * d16[i][15])) * scalefactor); - pcm_sample = - (float) (((vp[11 + dvp] * dp[0]) + (vp[10 + dvp] * dp[1]) + (vp[9 + dvp] * dp[2]) - + (vp[8 + dvp] * dp[3]) + (vp[7 + dvp] * dp[4]) + (vp[6 + dvp] * dp[5]) - + (vp[5 + dvp] * dp[6]) + (vp[4 + dvp] * dp[7]) + (vp[3 + dvp] * dp[8]) - + (vp[2 + dvp] * dp[9]) + (vp[1 + dvp] * dp[10]) + (vp[0 + dvp] * dp[11]) - + (vp[15 + dvp] * dp[12]) + (vp[14 + dvp] * dp[13]) + (vp[13 + dvp] * dp[14]) + (vp[12 + dvp] * dp[15])) * scalefactor); + _tmpOut[i] = pcm_sample; - tmpOut[i] = pcm_sample; + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples12(Obuffer buffer) { - final float[] vp = actual_v; - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; - - pcm_sample = - (float) (((vp[12 + dvp] * dp[0]) + (vp[11 + dvp] * dp[1]) + (vp[10 + dvp] * dp[2]) - + (vp[9 + dvp] * dp[3]) + (vp[8 + dvp] * dp[4]) + (vp[7 + dvp] * dp[5]) - + (vp[6 + dvp] * dp[6]) + (vp[5 + dvp] * dp[7]) + (vp[4 + dvp] * dp[8]) - + (vp[3 + dvp] * dp[9]) + (vp[2 + dvp] * dp[10]) + (vp[1 + dvp] * dp[11]) - + (vp[0 + dvp] * dp[12]) + (vp[15 + dvp] * dp[13]) + (vp[14 + dvp] * dp[14]) + (vp[13 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; + private void compute_pcm_samples9() { + + if (vidx == 1) { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[9 + dvp] * d16[i][0]) + (v1[8 + dvp] * d16[i][1]) + + (v1[7 + dvp] * d16[i][2]) + (v1[6 + dvp] * d16[i][3]) + (v1[5 + dvp] * d16[i][4]) + + (v1[4 + dvp] * d16[i][5]) + (v1[3 + dvp] * d16[i][6]) + (v1[2 + dvp] * d16[i][7]) + + (v1[1 + dvp] * d16[i][8]) + (v1[0 + dvp] * d16[i][9]) + + (v1[15 + dvp] * d16[i][10]) + (v1[14 + dvp] * d16[i][11]) + + (v1[13 + dvp] * d16[i][12]) + (v1[12 + dvp] * d16[i][13]) + + (v1[11 + dvp] * d16[i][14]) + (v1[10 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[9 + dvp] * d16[i][0]) + (v2[8 + dvp] * d16[i][1]) + + (v2[7 + dvp] * d16[i][2]) + (v2[6 + dvp] * d16[i][3]) + (v2[5 + dvp] * d16[i][4]) + + (v2[4 + dvp] * d16[i][5]) + (v2[3 + dvp] * d16[i][6]) + (v2[2 + dvp] * d16[i][7]) + + (v2[1 + dvp] * d16[i][8]) + (v2[0 + dvp] * d16[i][9]) + + (v2[15 + dvp] * d16[i][10]) + (v2[14 + dvp] * d16[i][11]) + + (v2[13 + dvp] * d16[i][12]) + (v2[12 + dvp] * d16[i][13]) + + (v2[11 + dvp] * d16[i][14]) + (v2[10 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples13(Obuffer buffer) { - final float[] vp = actual_v; - - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; + private void compute_pcm_samples10() { + if (vidx == 1) { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[10 + dvp] * d16[i][0]) + (v1[9 + dvp] * d16[i][1]) + + (v1[8 + dvp] * d16[i][2]) + (v1[7 + dvp] * d16[i][3]) + (v1[6 + dvp] * d16[i][4]) + + (v1[5 + dvp] * d16[i][5]) + (v1[4 + dvp] * d16[i][6]) + (v1[3 + dvp] * d16[i][7]) + + (v1[2 + dvp] * d16[i][8]) + (v1[1 + dvp] * d16[i][9]) + + (v1[0 + dvp] * d16[i][10]) + (v1[15 + dvp] * d16[i][11]) + + (v1[14 + dvp] * d16[i][12]) + (v1[13 + dvp] * d16[i][13]) + + (v1[12 + dvp] * d16[i][14]) + (v1[11 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[10 + dvp] * d16[i][0]) + (v2[9 + dvp] * d16[i][1]) + + (v2[8 + dvp] * d16[i][2]) + (v2[7 + dvp] * d16[i][3]) + (v2[6 + dvp] * d16[i][4]) + + (v2[5 + dvp] * d16[i][5]) + (v2[4 + dvp] * d16[i][6]) + (v2[3 + dvp] * d16[i][7]) + + (v2[2 + dvp] * d16[i][8]) + (v2[1 + dvp] * d16[i][9]) + + (v2[0 + dvp] * d16[i][10]) + (v2[15 + dvp] * d16[i][11]) + + (v2[14 + dvp] * d16[i][12]) + (v2[13 + dvp] * d16[i][13]) + + (v2[12 + dvp] * d16[i][14]) + (v2[11 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - pcm_sample = - (float) (((vp[13 + dvp] * dp[0]) + (vp[12 + dvp] * dp[1]) + (vp[11 + dvp] * dp[2]) - + (vp[10 + dvp] * dp[3]) + (vp[9 + dvp] * dp[4]) + (vp[8 + dvp] * dp[5]) - + (vp[7 + dvp] * dp[6]) + (vp[6 + dvp] * dp[7]) + (vp[5 + dvp] * dp[8]) - + (vp[4 + dvp] * dp[9]) + (vp[3 + dvp] * dp[10]) + (vp[2 + dvp] * dp[11]) - + (vp[1 + dvp] * dp[12]) + (vp[0 + dvp] * dp[13]) + (vp[15 + dvp] * dp[14]) + (vp[14 + dvp] * dp[15])) * scalefactor); + } - tmpOut[i] = pcm_sample; + private void compute_pcm_samples11() { + + if (vidx == 1) { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[11 + dvp] * d16[i][0]) + (v1[10 + dvp] * d16[i][1]) + + (v1[9 + dvp] * d16[i][2]) + (v1[8 + dvp] * d16[i][3]) + (v1[7 + dvp] * d16[i][4]) + + (v1[6 + dvp] * d16[i][5]) + (v1[5 + dvp] * d16[i][6]) + (v1[4 + dvp] * d16[i][7]) + + (v1[3 + dvp] * d16[i][8]) + (v1[2 + dvp] * d16[i][9]) + + (v1[1 + dvp] * d16[i][10]) + (v1[0 + dvp] * d16[i][11]) + + (v1[15 + dvp] * d16[i][12]) + (v1[14 + dvp] * d16[i][13]) + + (v1[13 + dvp] * d16[i][14]) + (v1[12 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[11 + dvp] * d16[i][0]) + (v2[10 + dvp] * d16[i][1]) + + (v2[9 + dvp] * d16[i][2]) + (v2[8 + dvp] * d16[i][3]) + (v2[7 + dvp] * d16[i][4]) + + (v2[6 + dvp] * d16[i][5]) + (v2[5 + dvp] * d16[i][6]) + (v2[4 + dvp] * d16[i][7]) + + (v2[3 + dvp] * d16[i][8]) + (v2[2 + dvp] * d16[i][9]) + + (v2[1 + dvp] * d16[i][10]) + (v2[0 + dvp] * d16[i][11]) + + (v2[15 + dvp] * d16[i][12]) + (v2[14 + dvp] * d16[i][13]) + + (v2[13 + dvp] * d16[i][14]) + (v2[12 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples14(Obuffer buffer) { - final float[] vp = actual_v; + private void compute_pcm_samples12() { + + if (vidx == 1) { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[12 + dvp] * d16[i][0]) + (v1[11 + dvp] * d16[i][1]) + + (v1[10 + dvp] * d16[i][2]) + (v1[9 + dvp] * d16[i][3]) + + (v1[8 + dvp] * d16[i][4]) + (v1[7 + dvp] * d16[i][5]) + (v1[6 + dvp] * d16[i][6]) + + (v1[5 + dvp] * d16[i][7]) + (v1[4 + dvp] * d16[i][8]) + (v1[3 + dvp] * d16[i][9]) + + (v1[2 + dvp] * d16[i][10]) + (v1[1 + dvp] * d16[i][11]) + + (v1[0 + dvp] * d16[i][12]) + (v1[15 + dvp] * d16[i][13]) + + (v1[14 + dvp] * d16[i][14]) + (v1[13 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[12 + dvp] * d16[i][0]) + (v2[11 + dvp] * d16[i][1]) + + (v2[10 + dvp] * d16[i][2]) + (v2[9 + dvp] * d16[i][3]) + + (v2[8 + dvp] * d16[i][4]) + (v2[7 + dvp] * d16[i][5]) + (v2[6 + dvp] * d16[i][6]) + + (v2[5 + dvp] * d16[i][7]) + (v2[4 + dvp] * d16[i][8]) + (v2[3 + dvp] * d16[i][9]) + + (v2[2 + dvp] * d16[i][10]) + (v2[1 + dvp] * d16[i][11]) + + (v2[0 + dvp] * d16[i][12]) + (v2[15 + dvp] * d16[i][13]) + + (v2[14 + dvp] * d16[i][14]) + (v2[13 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; + } - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - final float[] dp = d16[i]; - float pcm_sample; + private void compute_pcm_samples13() { + + if (vidx == 1) { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[13 + dvp] * d16[i][0]) + (v1[12 + dvp] * d16[i][1]) + + (v1[11 + dvp] * d16[i][2]) + (v1[10 + dvp] * d16[i][3]) + + (v1[9 + dvp] * d16[i][4]) + (v1[8 + dvp] * d16[i][5]) + (v1[7 + dvp] * d16[i][6]) + + (v1[6 + dvp] * d16[i][7]) + (v1[5 + dvp] * d16[i][8]) + (v1[4 + dvp] * d16[i][9]) + + (v1[3 + dvp] * d16[i][10]) + (v1[2 + dvp] * d16[i][11]) + + (v1[1 + dvp] * d16[i][12]) + (v1[0 + dvp] * d16[i][13]) + + (v1[15 + dvp] * d16[i][14]) + (v1[14 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[13 + dvp] * d16[i][0]) + (v2[12 + dvp] * d16[i][1]) + + (v2[11 + dvp] * d16[i][2]) + (v2[10 + dvp] * d16[i][3]) + + (v2[9 + dvp] * d16[i][4]) + (v2[8 + dvp] * d16[i][5]) + (v2[7 + dvp] * d16[i][6]) + + (v2[6 + dvp] * d16[i][7]) + (v2[5 + dvp] * d16[i][8]) + (v2[4 + dvp] * d16[i][9]) + + (v2[3 + dvp] * d16[i][10]) + (v2[2 + dvp] * d16[i][11]) + + (v2[1 + dvp] * d16[i][12]) + (v2[0 + dvp] * d16[i][13]) + + (v2[15 + dvp] * d16[i][14]) + (v2[14 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - pcm_sample = - (float) (((vp[14 + dvp] * dp[0]) + (vp[13 + dvp] * dp[1]) + (vp[12 + dvp] * dp[2]) - + (vp[11 + dvp] * dp[3]) + (vp[10 + dvp] * dp[4]) + (vp[9 + dvp] * dp[5]) - + (vp[8 + dvp] * dp[6]) + (vp[7 + dvp] * dp[7]) + (vp[6 + dvp] * dp[8]) - + (vp[5 + dvp] * dp[9]) + (vp[4 + dvp] * dp[10]) + (vp[3 + dvp] * dp[11]) - + (vp[2 + dvp] * dp[12]) + (vp[1 + dvp] * dp[13]) + (vp[0 + dvp] * dp[14]) + (vp[15 + dvp] * dp[15])) * scalefactor); + } - tmpOut[i] = pcm_sample; + private void compute_pcm_samples14() { + + if (vidx == 1) { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v1[14 + dvp] * d16[i][0]) + (v1[13 + dvp] * d16[i][1]) + + (v1[12 + dvp] * d16[i][2]) + (v1[11 + dvp] * d16[i][3]) + + (v1[10 + dvp] * d16[i][4]) + (v1[9 + dvp] * d16[i][5]) + + (v1[8 + dvp] * d16[i][6]) + (v1[7 + dvp] * d16[i][7]) + (v1[6 + dvp] * d16[i][8]) + + (v1[5 + dvp] * d16[i][9]) + (v1[4 + dvp] * d16[i][10]) + + (v1[3 + dvp] * d16[i][11]) + (v1[2 + dvp] * d16[i][12]) + + (v1[1 + dvp] * d16[i][13]) + (v1[0 + dvp] * d16[i][14]) + (v1[15 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + // final float[] dp = d16[i]; + float pcm_sample; + + pcm_sample = + (float) (((v2[14 + dvp] * d16[i][0]) + (v2[13 + dvp] * d16[i][1]) + + (v2[12 + dvp] * d16[i][2]) + (v2[11 + dvp] * d16[i][3]) + + (v2[10 + dvp] * d16[i][4]) + (v2[9 + dvp] * d16[i][5]) + + (v2[8 + dvp] * d16[i][6]) + (v2[7 + dvp] * d16[i][7]) + (v2[6 + dvp] * d16[i][8]) + + (v2[5 + dvp] * d16[i][9]) + (v2[4 + dvp] * d16[i][10]) + + (v2[3 + dvp] * d16[i][11]) + (v2[2 + dvp] * d16[i][12]) + + (v2[1 + dvp] * d16[i][13]) + (v2[0 + dvp] * d16[i][14]) + (v2[15 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + + dvp += 16; + } // for + } - dvp += 16; - } // for } - private void compute_pcm_samples15(Obuffer buffer) { - final float[] vp = actual_v; - - // int inc = v_inc; - final float[] tmpOut = _tmpOut; - int dvp = 0; - - // fat chance of having this loop unroll - for (int i = 0; i < 32; i++) { - float pcm_sample; - final float dp[] = d16[i]; - pcm_sample = - (float) (((vp[15 + dvp] * dp[0]) + (vp[14 + dvp] * dp[1]) + (vp[13 + dvp] * dp[2]) - + (vp[12 + dvp] * dp[3]) + (vp[11 + dvp] * dp[4]) + (vp[10 + dvp] * dp[5]) - + (vp[9 + dvp] * dp[6]) + (vp[8 + dvp] * dp[7]) + (vp[7 + dvp] * dp[8]) - + (vp[6 + dvp] * dp[9]) + (vp[5 + dvp] * dp[10]) + (vp[4 + dvp] * dp[11]) - + (vp[3 + dvp] * dp[12]) + (vp[2 + dvp] * dp[13]) + (vp[1 + dvp] * dp[14]) + (vp[0 + dvp] * dp[15])) * scalefactor); - - tmpOut[i] = pcm_sample; - dvp += 16; - } // for + private void compute_pcm_samples15() { + if (vidx == 1) { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + float pcm_sample; + // final float d16[i][] = d16[i]; + pcm_sample = + (float) (((v1[15 + dvp] * d16[i][0]) + (v1[14 + dvp] * d16[i][1]) + + (v1[13 + dvp] * d16[i][2]) + (v1[12 + dvp] * d16[i][3]) + + (v1[11 + dvp] * d16[i][4]) + (v1[10 + dvp] * d16[i][5]) + + (v1[9 + dvp] * d16[i][6]) + (v1[8 + dvp] * d16[i][7]) + (v1[7 + dvp] * d16[i][8]) + + (v1[6 + dvp] * d16[i][9]) + (v1[5 + dvp] * d16[i][10]) + + (v1[4 + dvp] * d16[i][11]) + (v1[3 + dvp] * d16[i][12]) + + (v1[2 + dvp] * d16[i][13]) + (v1[1 + dvp] * d16[i][14]) + (v1[0 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + dvp += 16; + } // for + } else { + // final float[] vp = actual_v; + + // int inc = v_inc; + // final float[] tmpOut = _tmpOut; + int dvp = 0; + + // fat chance of having this loop unroll + for (int i = 0; i < 32; i++) { + float pcm_sample; + // final float d16[i][] = d16[i]; + pcm_sample = + (float) (((v2[15 + dvp] * d16[i][0]) + (v2[14 + dvp] * d16[i][1]) + + (v2[13 + dvp] * d16[i][2]) + (v2[12 + dvp] * d16[i][3]) + + (v2[11 + dvp] * d16[i][4]) + (v2[10 + dvp] * d16[i][5]) + + (v2[9 + dvp] * d16[i][6]) + (v2[8 + dvp] * d16[i][7]) + (v2[7 + dvp] * d16[i][8]) + + (v2[6 + dvp] * d16[i][9]) + (v2[5 + dvp] * d16[i][10]) + + (v2[4 + dvp] * d16[i][11]) + (v2[3 + dvp] * d16[i][12]) + + (v2[2 + dvp] * d16[i][13]) + (v2[1 + dvp] * d16[i][14]) + (v2[0 + dvp] * d16[i][15])) * scalefactor); + + _tmpOut[i] = pcm_sample; + dvp += 16; + } // for + } + } - private void compute_pcm_samples(Obuffer buffer) { + private void compute_pcm_samples() { switch (actual_write_pos) { case 0: - compute_pcm_samples0(buffer); + compute_pcm_samples0(); break; case 1: - compute_pcm_samples1(buffer); + compute_pcm_samples1(); break; case 2: - compute_pcm_samples2(buffer); + compute_pcm_samples2(); break; case 3: - compute_pcm_samples3(buffer); + compute_pcm_samples3(); break; case 4: - compute_pcm_samples4(buffer); + compute_pcm_samples4(); break; case 5: - compute_pcm_samples5(buffer); + compute_pcm_samples5(); break; case 6: - compute_pcm_samples6(buffer); + compute_pcm_samples6(); break; case 7: - compute_pcm_samples7(buffer); + compute_pcm_samples7(); break; case 8: - compute_pcm_samples8(buffer); + compute_pcm_samples8(); break; case 9: - compute_pcm_samples9(buffer); + compute_pcm_samples9(); break; case 10: - compute_pcm_samples10(buffer); + compute_pcm_samples10(); break; case 11: - compute_pcm_samples11(buffer); + compute_pcm_samples11(); break; case 12: - compute_pcm_samples12(buffer); + compute_pcm_samples12(); break; case 13: - compute_pcm_samples13(buffer); + compute_pcm_samples13(); break; case 14: - compute_pcm_samples14(buffer); + compute_pcm_samples14(); break; case 15: - compute_pcm_samples15(buffer); + compute_pcm_samples15(); break; } - if (buffer != null) { - buffer.appendSamples(channel, _tmpOut); - } + // if (buffer != null) { + // buffer.appendSamples(channel, _tmpOut); + // } + SampleBufferWrapper.getOutput().appendSamples(channel, _tmpOut); /* * // MDM: I was considering putting in quality control for // low-spec @@ -1284,12 +1840,28 @@ final class SynthesisFilter { * Calculate 32 PCM samples and put the into the Obuffer-object. */ - public void calculate_pcm_samples(Obuffer buffer) { - compute_new_v(); - compute_pcm_samples(buffer); + public void calculate_pcm_samples() { + + if (vidx == 1) { + compute_new_v1_v2(); + } else { + compute_new_v2_v1(); + } + + // System.out.println("1.actual_v=" + (actual_v == v1) + " vidx=" + vidx); + // compute_new_v(); + // System.out.println("2.actual_v=" + (actual_v == v1) + " vidx=" + vidx); + compute_pcm_samples(); + // System.out.println("3.actual_v=" + (actual_v == v1) + " vidx=" + vidx); actual_write_pos = (actual_write_pos + 1) & 0xf; - actual_v = (actual_v == v1) ? v2 : v1; + // actual_v = (actual_v == v1) ? v2 : v1; + + if (vidx == 1) { + vidx = 2; + } else { + vidx = 1; + } // initialize samples[]: // for (register float *floatp = samples + 32; floatp > samples; ) diff --git a/Robust/src/Tests/ssJava/mp3decoder/huffcodetab.java b/Robust/src/Tests/ssJava/mp3decoder/huffcodetab.java index 7aec4ccc..054bc4d0 100644 --- a/Robust/src/Tests/ssJava/mp3decoder/huffcodetab.java +++ b/Robust/src/Tests/ssJava/mp3decoder/huffcodetab.java @@ -482,8 +482,8 @@ final class huffcodetab { * Big Constructor : Computes all Huffman Tables. */ private huffcodetab(@LOC("V") String S, @LOC("V") int XLEN, @LOC("V") int YLEN, - @LOC("V") int LINBITS, @LOC("V") int LINMAX, @LOC("V") int REF, @LOC("V") int[] TABLE, - @LOC("V") int[] HLEN, @LOC("V") int[][] VAL, @LOC("V") int TREELEN) { + @LOC("V") int LINBITS, @LOC("V") int LINMAX, @LOC("V") int REF, @DELEGATE @LOC("V") int[] TABLE, + @DELEGATE @LOC("V") int[] HLEN,@DELEGATE @LOC("V") int[][] VAL, @LOC("V") int TREELEN) { tablename0 = S.charAt(0); tablename1 = S.charAt(1); tablename2 = S.charAt(2); @@ -506,11 +506,12 @@ final class huffcodetab { * note! for counta,countb -the 4 bit value is returned in y, * discard x. */ - public static int huffman_decoder(huffcodetab h, int[] x, int[] y, int[] v, int[] w, BitReserve br) + public static int huffman_decoder(int htIdx, int[] x, int[] y, int[] v, int[] w, BitReserve br) { // array of all huffcodtable headers // 0..31 Huffman code table 0..31 // 32,33 count1-tables + int dmask = 1 << ((4 * 8) - 1); int hs = 4 * 8; @@ -519,10 +520,10 @@ final class huffcodetab { int error = 1; level = dmask; - if (h.val == null) return 2; + if (ht[htIdx].val == null) return 2; /* table 0 needs no bits */ - if ( h.treelen == 0) + if ( ht[htIdx].treelen == 0) { x[0] = y[0] = 0; return 0; @@ -536,10 +537,10 @@ final class huffcodetab { int bits[] = bitbuf;*/ do { - if (h.val[point][0]==0) + if (ht[htIdx].val[point][0]==0) { /*end of tree*/ - x[0] = h.val[point][1] >>> 4; - y[0] = h.val[point][1] & 0xf; + x[0] = ht[htIdx].val[point][1] >>> 4; + y[0] = ht[htIdx].val[point][1] & 0xf; error = 0; break; } @@ -556,13 +557,13 @@ final class huffcodetab { //if (bits[bitIndex++]!=0) if (br.hget1bit()!=0) { - while (h.val[point][1] >= MXOFF) point += h.val[point][1]; - point += h.val[point][1]; + while (ht[htIdx].val[point][1] >= MXOFF) point += ht[htIdx].val[point][1]; + point += ht[htIdx].val[point][1]; } else { - while (h.val[point][0] >= MXOFF) point += h.val[point][0]; - point += h.val[point][0]; + while (ht[htIdx].val[point][0] >= MXOFF) point += ht[htIdx].val[point][0]; + point += ht[htIdx].val[point][0]; } level >>>= 1; // MDM: ht[0] is always 0; @@ -575,8 +576,8 @@ final class huffcodetab { br.rewindNbits(unread); */ /* Process sign encodings for quadruples tables. */ - // System.out.println(h.tablename); - if (h.tablename0 == '3' && (h.tablename1 == '2' || h.tablename1 == '3')) + // System.out.println(ht[htIdx].tablename); + if (ht[htIdx].tablename0 == '3' && (ht[htIdx].tablename1 == '2' || ht[htIdx].tablename1 == '3')) { v[0] = (y[0]>>3) & 1; w[0] = (y[0]>>2) & 1; @@ -601,14 +602,14 @@ final class huffcodetab { // x and y are reversed in the test bitstream. // Reverse x and y here to make test bitstream work. - if (h.linbits != 0) - if ((h.xlen-1) == x[0]) - x[0] += br.hgetbits(h.linbits); + if (ht[htIdx].linbits != 0) + if ((ht[htIdx].xlen-1) == x[0]) + x[0] += br.hgetbits(ht[htIdx].linbits); if (x[0] != 0) if (br.hget1bit() != 0) x[0] = -x[0]; - if (h.linbits != 0) - if ((h.ylen-1) == y[0]) - y[0] += br.hgetbits(h.linbits); + if (ht[htIdx].linbits != 0) + if ((ht[htIdx].ylen-1) == y[0]) + y[0] += br.hgetbits(ht[htIdx].linbits); if (y[0] != 0) if (br.hget1bit() != 0) y[0] = -y[0]; }