From: yeom Date: Tue, 30 Oct 2012 06:10:38 +0000 (+0000) Subject: changes. X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=16c9b68be88b7753b0b2a8b5766983ce06d0c2ad;p=IRC.git changes. --- diff --git a/Robust/src/Analysis/SSJava/BuildLattice.java b/Robust/src/Analysis/SSJava/BuildLattice.java index b306a4fc..931e865d 100644 --- a/Robust/src/Analysis/SSJava/BuildLattice.java +++ b/Robust/src/Analysis/SSJava/BuildLattice.java @@ -8,16 +8,19 @@ import java.util.Set; import IR.Descriptor; import IR.MethodDescriptor; +import IR.NameDescriptor; import Util.Pair; public class BuildLattice { private LocationInference infer; private Map mapSharedNodeToTripleItem; + private Map mapHNodeToHighestIndex; public BuildLattice(LocationInference infer) { this.infer = infer; this.mapSharedNodeToTripleItem = new HashMap(); + this.mapHNodeToHighestIndex = new HashMap(); } public SSJavaLattice buildLattice(Descriptor desc) { @@ -54,13 +57,16 @@ public class BuildLattice { Family family = generateFamily(basisSet); Map, Set>> mapImSucc = coveringGraph(basisSet, family); - SSJavaLattice lattice = buildLattice(basisSet, inputGraph, locSummary, mapImSucc); + SSJavaLattice lattice = buildLattice(desc, basisSet, inputGraph, locSummary, mapImSucc); return lattice; } - private SSJavaLattice buildLattice(BasisSet basisSet, HierarchyGraph inputGraph, - LocationSummary locSummary, Map, Set>> mapImSucc) { + private SSJavaLattice buildLattice(Descriptor desc, BasisSet basisSet, + HierarchyGraph inputGraph, LocationSummary locSummary, + Map, Set>> mapImSucc) { + + HierarchyGraph simpleHierarchyGraph = infer.getSimpleHierarchyGraph(desc); SSJavaLattice lattice = new SSJavaLattice(SSJavaAnalysis.TOP, SSJavaAnalysis.BOTTOM); @@ -74,6 +80,7 @@ public class BuildLattice { String higherName = generateElementName(basisSet, inputGraph, mapFToLocName, higher); HNode higherNode = inputGraph.getHNode(higherName); + if (higherNode != null && higherNode.isSharedNode()) { lattice.addSharedLoc(higherName); } @@ -92,6 +99,7 @@ public class BuildLattice { String lowerName = generateElementName(basisSet, inputGraph, mapFToLocName, lower); HNode lowerNode = inputGraph.getHNode(lowerName); + if (lowerNode != null && lowerNode.isSharedNode()) { lattice.addSharedLoc(lowerName); } @@ -164,7 +172,7 @@ public class BuildLattice { // System.out.println("***nodeSet=" + nodeSet); for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) { HNode node = (HNode) iterator.next(); - // System.out.println("node=" + node); + System.out.println("node=" + node); if (node.isSkeleton() && (!visited.contains(node))) { visited.add(node); @@ -175,7 +183,12 @@ public class BuildLattice { if (!outNode.isSkeleton()) { if (outNode.isCombinationNode()) { - expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode); + if (visited.containsAll(simpleGraph.getIncomingNodeSet(outNode))) { + // if (needToExpandCombinationNode(desc, outNode)) { + expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, + outNode); + // } + } } else { // we have a node that is neither combination or skeleton node // System.out.println("%%%skeleton node=" + node + " outNode=" + outNode); @@ -311,15 +324,44 @@ public class BuildLattice { return aboveSet; } + private boolean needToExpandCombinationNode(Descriptor desc, HNode cnode) { + + System.out.println("needToExpandCombinationNode?=" + cnode); + + HierarchyGraph simpleGraph = infer.getSimpleHierarchyGraph(desc); + // HNode combinationNodeInSCGraph = getCombinationNodeInSCGraph(desc, cnode); + Set combineSkeletonNodeSet = simpleGraph.getCombineSetByCombinationNode(cnode); + Set combinationNodeSetInSimpleGraph = + simpleGraph.getCombinationNodeSetByCombineNodeSet(combineSkeletonNodeSet); + System.out.println("---combinationNodeSetInSimpleGraph=" + combinationNodeSetInSimpleGraph); + Set inNodeSetToCNode = simpleGraph.getIncomingNodeSet(cnode); + System.out.println("------inNodeSetToCNode=" + inNodeSetToCNode); + for (Iterator iterator = combinationNodeSetInSimpleGraph.iterator(); iterator.hasNext();) { + HNode nodeBelongToTheSameCombinationNode = (HNode) iterator.next(); + if (inNodeSetToCNode.contains(nodeBelongToTheSameCombinationNode)) { + // the combination node 'cnode' is not the highest location among the same combination node + return false; + } + } + + return true; + } + private void expandCombinationNode(Descriptor desc, SSJavaLattice lattice, Set visited, Map mapIntermediateLoc, LocationSummary locSummary, HNode cnode) { - // System.out.println("expandCombinationNode=" + cnode); // expand the combination node 'outNode' // here we need to expand the corresponding combination location in the lattice HNode combinationNodeInSCGraph = getCombinationNodeInSCGraph(desc, cnode); + System.out.println("expandCombinationNode=" + cnode + " cnode in scgraph=" + + combinationNodeInSCGraph); + + if (combinationNodeInSCGraph == null) { + return; + } + HierarchyGraph simpleGraph = infer.getSimpleHierarchyGraph(desc); Set combineSkeletonNodeSet = simpleGraph.getCombineSetByCombinationNode(cnode); @@ -501,13 +543,13 @@ public class BuildLattice { } String locName = mapIntermediateLoc.get(item); - HierarchyGraph graph = infer.getSimpleHierarchyGraph(desc); + HierarchyGraph simpleHierarchyGraph = infer.getSimpleHierarchyGraph(desc); if (curNode.isSharedNode()) { // if the current node is shared location, add a shared location to the lattice later mapSharedNodeToTripleItem.put(curNode, item); } else { - Set descSet = graph.getDescSetOfNode(curNode); + Set descSet = simpleHierarchyGraph.getDescSetOfNode(curNode); for (Iterator iterator = descSet.iterator(); iterator.hasNext();) { Descriptor d = (Descriptor) iterator.next(); locSummary.addMapHNodeNameToLocationName(d.getSymbol(), locName); @@ -515,24 +557,36 @@ public class BuildLattice { locSummary.addMapHNodeNameToLocationName(curNode.getName(), locName); } - // System.out.println("-TripleItem=" + item); - // System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode() - // + " locName=" + locName); + System.out.println("-TripleItem normal=" + item); + System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode() + + " locName=" + locName + " isC=" + curNode.isCombinationNode()); - Set outSet = graph.getOutgoingNodeSet(curNode); + Set outSet = simpleHierarchyGraph.getOutgoingNodeSet(curNode); for (Iterator iterator2 = outSet.iterator(); iterator2.hasNext();) { HNode outNode = (HNode) iterator2.next(); - Set inNodeSetToOutNode = graph.getIncomingNodeSet(outNode); + Set incomingHNodeSetToOutNode = simpleHierarchyGraph.getIncomingNodeSet(outNode); + System.out.println("outNode=" + outNode); + System.out.println("---incomingHNodeSetToOutNode=" + incomingHNodeSetToOutNode); - if (visited.containsAll(inNodeSetToOutNode)) { - if (!outNode.isSkeleton() && !outNode.isCombinationNode() && !visited.contains(outNode)) { + if (!outNode.isSkeleton() && !outNode.isCombinationNode() && !visited.contains(outNode)) { + if (visited.containsAll(simpleHierarchyGraph.getIncomingNodeSet(outNode))) { visited.add(outNode); + int newidx = getCurrentHighestIndex(outNode, idx + 1); recurDFSNormalNode(desc, lattice, startNode, endNodeSet, visited, mapIntermediateLoc, - idx + 1, locSummary, outNode); - } else if (!outNode.isSkeleton() && outNode.isCombinationNode() - && !visited.contains(outNode)) { + newidx, locSummary, outNode); + // recurDFSNormalNode(desc, lattice, startNode, endNodeSet, visited, mapIntermediateLoc, + // idx + 1, locSummary, outNode); + } else { + updateHighestIndex(outNode, idx + 1); + System.out.println("NOT RECUR"); + } + } else if (!outNode.isSkeleton() && outNode.isCombinationNode() && !visited.contains(outNode)) { + if (needToExpandCombinationNode(desc, outNode)) { + System.out.println("NEED TO"); expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode); + } else { + System.out.println("NOT NEED TO"); } } @@ -578,13 +632,13 @@ public class BuildLattice { // return; // } - HierarchyGraph graph = infer.getSimpleHierarchyGraph(desc); + HierarchyGraph simpleHierarchyGraph = infer.getSimpleHierarchyGraph(desc); String locName = mapIntermediateLoc.get(item); if (curNode.isSharedNode()) { // if the current node is shared location, add a shared location to the lattice later mapSharedNodeToTripleItem.put(curNode, item); } else { - Set descSet = graph.getDescSetOfNode(curNode); + Set descSet = simpleHierarchyGraph.getDescSetOfNode(curNode); for (Iterator iterator = descSet.iterator(); iterator.hasNext();) { Descriptor d = (Descriptor) iterator.next(); locSummary.addMapHNodeNameToLocationName(d.getSymbol(), locName); @@ -592,40 +646,88 @@ public class BuildLattice { locSummary.addMapHNodeNameToLocationName(curNode.getName(), locName); } - // System.out.println("-TripleItem=" + item); - // System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode() - // + " locName=" + locName); + System.out.println("-TripleItem=" + item); + System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode() + + " locName=" + locName); - Set outSet = graph.getOutgoingNodeSet(curNode); + Set outSet = simpleHierarchyGraph.getOutgoingNodeSet(curNode); for (Iterator iterator2 = outSet.iterator(); iterator2.hasNext();) { HNode outNode = (HNode) iterator2.next(); - // System.out.println("recurDFS outNode=" + outNode); - // System.out.println("---cur combinationNodeInSCGraph=" + combinationNodeInSCGraph); - // System.out.println("---outNode combinationNodeInSCGraph=" - // + getCombinationNodeInSCGraph(desc, outNode)); - - Set inNodeSetToOutNode = graph.getIncomingNodeSet(outNode); - - if (visited.containsAll(inNodeSetToOutNode)) { - if (!outNode.isSkeleton() && !visited.contains(outNode)) { - if (outNode.isCombinationNode()) { - // check whether the next combination node is different from the current node - if (combinationNodeInSCGraph.equals(getCombinationNodeInSCGraph(desc, outNode))) { + System.out.println("---recurDFS outNode=" + outNode); + System.out.println("---cur combinationNodeInSCGraph=" + combinationNodeInSCGraph); + System.out.println("---outNode combinationNodeInSCGraph=" + + getCombinationNodeInSCGraph(desc, outNode)); + + if (!outNode.isSkeleton() && !visited.contains(outNode)) { + if (outNode.isCombinationNode()) { + + Set combineSkeletonNodeSet = + simpleHierarchyGraph.getCombineSetByCombinationNode(outNode); + Set incomingHNodeSetToOutNode = simpleHierarchyGraph.getIncomingNodeSet(outNode); + // extract nodes belong to the same combine node + Set incomingCombinedHNodeSet = new HashSet(); + for (Iterator iterator = incomingHNodeSetToOutNode.iterator(); iterator.hasNext();) { + HNode inNode = (HNode) iterator.next(); + if (combineSkeletonNodeSet.contains(inNode)) { + incomingCombinedHNodeSet.add(inNode); + } + } + System.out.println("-----incomingCombinedHNodeSet=" + incomingCombinedHNodeSet); + + // check whether the next combination node is different from the current node + if (combinationNodeInSCGraph.equals(getCombinationNodeInSCGraph(desc, outNode))) { + if (visited.containsAll(incomingCombinedHNodeSet)) { visited.add(outNode); + System.out.println("-------curIdx=" + (idx + 1)); + int newIdx = getCurrentHighestIndex(outNode, idx + 1); + System.out.println("-------newIdx=" + newIdx); recurDFS(desc, lattice, combinationNodeInSCGraph, endNodeSet, visited, - mapIntermediateLoc, idx + 1, locSummary, outNode); + mapIntermediateLoc, newIdx, locSummary, outNode); + // recurDFS(desc, lattice, combinationNodeInSCGraph, endNodeSet, visited, + // mapIntermediateLoc, idx + 1, locSummary, outNode); } else { + updateHighestIndex(outNode, idx + 1); + System.out.println("-----NOT RECUR!"); + } + } else { + if (needToExpandCombinationNode(desc, outNode)) { + System.out.println("NEED TO"); expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode); + } else { + System.out.println("NOT NEED TO"); } - } + } } } + // } } } + private int getCurrentHighestIndex(HNode node, int curIdx) { + int recordedIdx = getCurrentHighestIndex(node); + if (recordedIdx > curIdx) { + return recordedIdx; + } else { + return curIdx; + } + } + + private int getCurrentHighestIndex(HNode node) { + if (!mapHNodeToHighestIndex.containsKey(node)) { + mapHNodeToHighestIndex.put(node, new Integer(-1)); + } + return mapHNodeToHighestIndex.get(node).intValue(); + } + + private void updateHighestIndex(HNode node, int idx) { + if (idx > getCurrentHighestIndex(node)) { + mapHNodeToHighestIndex.put(node, new Integer(idx)); + } + } + private String generateElementName(BasisSet basisSet, HierarchyGraph inputGraph, Map, String> mapF2LocName, Set F) { diff --git a/Robust/src/Analysis/SSJava/FlowDownCheck.java b/Robust/src/Analysis/SSJava/FlowDownCheck.java index b5f22d32..6d22825d 100644 --- a/Robust/src/Analysis/SSJava/FlowDownCheck.java +++ b/Robust/src/Analysis/SSJava/FlowDownCheck.java @@ -2207,7 +2207,10 @@ public class FlowDownCheck { } SSJavaLattice locOrder = getLatticeByDescriptor(priorityDescriptor); + System.out.println("priorityDescriptor=" + priorityDescriptor); + System.out.println("GLB INPUT=" + priorityLocIdentifierSet); String glbOfPriorityLoc = locOrder.getGLB(priorityLocIdentifierSet); + System.out.println("GLB OUTPUT="+glbOfPriorityLoc); glbCompLoc.addLocation(new Location(priorityDescriptor, glbOfPriorityLoc)); Set compSet = locId2CompLocSet.get(glbOfPriorityLoc); diff --git a/Robust/src/Analysis/SSJava/HierarchyGraph.java b/Robust/src/Analysis/SSJava/HierarchyGraph.java index 8b364b1c..d51e6107 100644 --- a/Robust/src/Analysis/SSJava/HierarchyGraph.java +++ b/Robust/src/Analysis/SSJava/HierarchyGraph.java @@ -401,7 +401,7 @@ public class HierarchyGraph { private void addEdgeWithNoCycleCheck(HNode srcHNode, HNode dstHNode) { getIncomingNodeSet(dstHNode).add(srcHNode); getOutgoingNodeSet(srcHNode).add(dstHNode); -// System.out.println("addEdgeWithNoCycleCheck src=" + srcHNode + " -> " + dstHNode); + // System.out.println("addEdgeWithNoCycleCheck src=" + srcHNode + " -> " + dstHNode); } private HNode mergeNodes(Set set, boolean onlyCombinationNodes) { @@ -777,9 +777,9 @@ public class HierarchyGraph { Set> keySet = simpleHierarchyGraph.getCombineNodeSet(); for (Iterator iterator = keySet.iterator(); iterator.hasNext();) { Set combineSet = (Set) iterator.next(); - System.out.println("--combineSet=" + combineSet); + // System.out.println("--combineSet=" + combineSet); HNode combinationNode = getCombinationNode(combineSet); - System.out.println("--combinationNode=" + combinationNode); + // System.out.println("--combinationNode=" + combinationNode); // add an edge from a skeleton node to a combination node for (Iterator iterator2 = combineSet.iterator(); iterator2.hasNext();) { HNode inSkeletonNode = (HNode) iterator2.next(); @@ -850,10 +850,10 @@ public class HierarchyGraph { Set visited = new HashSet(); recurSkeletonReachTo(node, reachToSet, visited); + // obsolete! // if a node reaches to one of elements in the reachToSet, we do not need to keep it // because the node is not directly connected to the combination node - - removeRedundantReachToNodes(reachToSet); + // removeRedundantReachToNodes(reachToSet); return reachToSet; } @@ -967,6 +967,7 @@ public class HierarchyGraph { HNode node = (HNode) iterator.next(); if (!node.isSkeleton()) { Set reachToSet = getSkeleteNodeSetReachTo(node); + System.out.println("$node=" + node + " reachToNodeSet=" + reachToSet); if (reachToSet.size() > 1) { // if (countSkeletonNodes(reachToSet) > 1) { System.out.println("-node=" + node + " reachToSet=" + reachToSet); @@ -1074,7 +1075,7 @@ public class HierarchyGraph { public void assignUniqueIndexToNode() { int idx = 1; - System.out.println("nodeSet=" + nodeSet); + // System.out.println("nodeSet=" + nodeSet); for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) { HNode node = (HNode) iterator.next(); mapHNodeToUniqueIndex.put(node, idx); @@ -1104,17 +1105,17 @@ public class HierarchyGraph { basis.addAll(BASISTOPELEMENT); Set reachableNodeSet = getReachableNodeSetFrom(node); - System.out.println("node=" + node + " reachableNodeSet=" + reachableNodeSet); - System.out.println("mapHNodeToUniqueIndex.get(node)=" + mapHNodeToUniqueIndex.get(node)); + // System.out.println("node=" + node + " reachableNodeSet=" + reachableNodeSet); + // System.out.println("mapHNodeToUniqueIndex.get(node)=" + mapHNodeToUniqueIndex.get(node)); // if a node is reachable from the current node // need to remove the index of the reachable node from the basis basis.remove(getHNodeIndex(node)); for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) { HNode reachableNode = (HNode) iterator2.next(); - System.out.println("reachableNode=" + reachableNode); - System.out.println("getHNodeIndex(reachableNode))=" - + mapHNodeToUniqueIndex.get(reachableNode)); + // System.out.println("reachableNode=" + reachableNode); + // System.out.println("getHNodeIndex(reachableNode))=" + // + mapHNodeToUniqueIndex.get(reachableNode)); int idx = getHNodeIndex(reachableNode); basis.remove(idx); } diff --git a/Robust/src/Analysis/SSJava/LocationInference.java b/Robust/src/Analysis/SSJava/LocationInference.java index 99a7315f..c3440672 100644 --- a/Robust/src/Analysis/SSJava/LocationInference.java +++ b/Robust/src/Analysis/SSJava/LocationInference.java @@ -1759,9 +1759,21 @@ public class LocationInference { public static boolean isReference(Descriptor desc) { if (desc instanceof FieldDescriptor) { - return ((FieldDescriptor) desc).getType().isPtr(); + + TypeDescriptor type = ((FieldDescriptor) desc).getType(); + if (type.isArray()) { + return false; + } else { + return type.isPtr(); + } + } else if (desc instanceof VarDescriptor) { - return ((VarDescriptor) desc).getType().isPtr(); + TypeDescriptor type = ((VarDescriptor) desc).getType(); + if (type.isArray()) { + return false; + } else { + return type.isPtr(); + } } return false; @@ -3879,8 +3891,10 @@ public class LocationInference { + " idx=" + idx); if (!srcFieldDesc.equals(dstFieldDesc)) { // add a new edge + System.out.println("-ADD EDGE"); getHierarchyGraph(cd).addEdge(srcFieldDesc, dstFieldDesc); } else if (!isReference(srcFieldDesc) && !isReference(dstFieldDesc)) { + System.out.println("-ADD EDGE"); getHierarchyGraph(cd).addEdge(srcFieldDesc, dstFieldDesc); } @@ -5329,10 +5343,10 @@ public class LocationInference { analyzeFlowExpressionNode(md, nametable, an.getSrc(), nodeSetRHS, null, implicitFlowTupleSet, false); - // System.out.println("-analyzeFlowAssignmentNode=" + an.printNode(0)); - // System.out.println("-nodeSetLHS=" + nodeSetLHS); - // System.out.println("-nodeSetRHS=" + nodeSetRHS); - // System.out.println("-implicitFlowTupleSet=" + implicitFlowTupleSet); + System.out.println("-analyzeFlowAssignmentNode=" + an.printNode(0)); + System.out.println("-nodeSetLHS=" + nodeSetLHS); + System.out.println("-nodeSetRHS=" + nodeSetRHS); + System.out.println("-implicitFlowTupleSet=" + implicitFlowTupleSet); // System.out.println("-"); if (an.getOperation().getOp() >= 2 && an.getOperation().getOp() <= 12) { diff --git a/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/LayerIIIDecoder.java b/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/LayerIIIDecoder.java index c022ba06..bd57283d 100644 --- a/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/LayerIIIDecoder.java +++ b/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/LayerIIIDecoder.java @@ -1950,7 +1950,24 @@ final class LayerIIIDecoder implements FrameDecoder { float tmpf_16; float tmpf_17; - tmpf_0 = tmpf_1 = tmpf_2 = tmpf_3 = tmpf_4 = tmpf_5 = tmpf_6 = tmpf_7 = tmpf_8 = tmpf_9 = tmpf_10 = tmpf_11 = tmpf_12 = tmpf_13 = tmpf_14 = tmpf_15 = tmpf_16 = tmpf_17 = 0.0f; + tmpf_0 = 0.0f; + tmpf_1 = 0.0f; + tmpf_2 = 0.0f; + tmpf_3 = 0.0f; + tmpf_4 = 0.0f; + tmpf_5 = 0.0f; + tmpf_6 = 0.0f; + tmpf_7 = 0.0f; + tmpf_8 = 0.0f; + tmpf_9 = 0.0f; + tmpf_10 = 0.0f; + tmpf_11 = 0.0f; + tmpf_12 = 0.0f; + tmpf_13 = 0.0f; + tmpf_14 = 0.0f; + tmpf_15 = 0.0f; + tmpf_16 = 0.0f; + tmpf_17 = 0.0f; if (block_type == 2) { @@ -2382,7 +2399,7 @@ final class LayerIIIDecoder implements FrameDecoder { * 12, 13, 14, 15, 16, 17 }; */ - private static/* final */int reorder_table[][]/* = loadReorderTable() */; // SZD: + private static final int reorder_table[][]/* = loadReorderTable() */; // SZD: // will // be diff --git a/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/Player.java b/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/Player.java index c7ef1c0f..236fd3e6 100644 --- a/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/Player.java +++ b/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/Player.java @@ -120,26 +120,41 @@ public class Player { sampleNumber = 1; System.out.println("Gobble sentinel: +++"); + ret=play2(h); // int count = 0; +// SSJAVA: while (true) { +// if (h == null) { +// break; +// } +// ret = decodeFrame(init, h); +// if (!ret) { +// break; +// } +// h = BitstreamWrapper.readFrame(); +// } + + /* + * if (!ret) { // last frame, ensure all data flushed to the audio device. + * AudioDevice out = audio; if (out!=null) { out.flush(); synchronized + * (this) { complete = (!closed); close(); } } } + */ + return ret; + } + + public boolean play2( Header h){ + boolean ret; SSJAVA: while (true) { if (h == null) { break; } - ret = decodeFrame(init, h); + ret = decodeFrame(true, h); if (!ret) { break; } h = BitstreamWrapper.readFrame(); } - - /* - * if (!ret) { // last frame, ensure all data flushed to the audio device. - * AudioDevice out = audio; if (out!=null) { out.flush(); synchronized - * (this) { complete = (!closed); close(); } } } - */ return ret; } - /** * Cloases this player. Any audio currently playing is stopped immediately. */