Feedback comments from reddit implemented

Author: sahaRatul

src/main/java/org/sela/Player.java

@@ -14,12 +14,13 @@
 import org.sela.data.WavFrame;
 import org.sela.exception.FileException;
 
-public class Player extends Decoder {
+public class Player {
     private List<WavFrame> wavFrames;
+    private Decoder decoder;
 
     public Player(final File inputFile) throws IOException, FileException {
-        super(inputFile, null);
-        wavFrames = super.processFrames();
+        decoder = new Decoder(inputFile, null);
+        wavFrames = decoder.processFrames();
     }
 
     private static void printProgress(final long current, final long total) {
@@ -34,13 +35,13 @@ private static void printProgress(final long current, final long total) {
 
     public void play() throws LineUnavailableException {
         // Select audio format parameters
-        final AudioFormat af = new AudioFormat(super.selaFile.getSampleRate(), super.selaFile.getBitsPerSample(),
-                super.selaFile.getChannels(), true, false);
+        final AudioFormat af = new AudioFormat(decoder.selaFile.getSampleRate(), decoder.selaFile.getBitsPerSample(),
+                decoder.selaFile.getChannels(), true, false);
         final DataLine.Info info = new DataLine.Info(SourceDataLine.class, af);
         final SourceDataLine line = (SourceDataLine) AudioSystem.getLine(info);
 
         // Prepare audio output
-        line.open(af, 2048 * super.selaFile.getChannels());
+        line.open(af, 2048 * decoder.selaFile.getChannels());
         line.start();
 
         // Output wave form repeatedly

…a/org/sela/lpc/LinearPredictionBase.java …n/java/org/sela/lpc/LinearPredictor.javasrc/main/java/org/sela/lpc/LinearPredictionBase.java renamed to src/main/java/org/sela/lpc/LinearPredictor.java src/main/java/org/sela/lpc/LinearPredictionBase.java renamed to src/main/java/org/sela/lpc/LinearPredictor.java

@@ -1,6 +1,6 @@
 package org.sela.lpc;
 
-public class LinearPredictionBase {
+public class LinearPredictor {
     protected double[] reflectionCoefficients;
     protected int[] quantizedReflectionCoefficients;
     protected long[] linearPredictionCoefficients;
@@ -10,12 +10,12 @@ public class LinearPredictionBase {
     protected final int maxLpcOrder = 100;
     protected final int correctionFactor = 35;
 
-    public LinearPredictionBase() {
+    public LinearPredictor() {
         this.reflectionCoefficients = new double[maxLpcOrder];
         optimalLpcOrder = 1;
     }
 
-    public LinearPredictionBase(final int[] quantizedReflectionCoefficients, final byte optimalLpcOrder) {
+    public LinearPredictor(final int[] quantizedReflectionCoefficients, final byte optimalLpcOrder) {
         this.reflectionCoefficients = new double[maxLpcOrder];
         this.quantizedReflectionCoefficients = quantizedReflectionCoefficients;
         this.optimalLpcOrder = optimalLpcOrder;

src/main/java/org/sela/lpc/ResidueGenerator.java

@@ -3,19 +3,21 @@
 import org.sela.data.LpcDecodedData;
 import org.sela.data.LpcEncodedData;
 
-public final class ResidueGenerator extends LinearPredictionBase {
+public final class ResidueGenerator {
     private final int[] samples;
     private final int[] residues;
     private final double[] quantizedSamples;
     private final double[] autocorrelationFactors;
+    private final LinearPredictor linearPredictor;
 
     private final int maxShort = 32767;
     private final double sqrt2 = 1.4142135623730950488016887242096;
 
     public ResidueGenerator(final LpcDecodedData data) {
+        this.linearPredictor = new LinearPredictor();
         this.samples = data.samples;
         this.quantizedSamples = new double[samples.length];
-        this.autocorrelationFactors = new double[super.maxLpcOrder + 1];
+        this.autocorrelationFactors = new double[linearPredictor.maxLpcOrder + 1];
         this.residues = new int[samples.length];
     }
 
@@ -35,86 +37,86 @@ private void generateAutoCorrelation() {
         mean = sum / quantizedSamples.length;
 
         // Generate autocorrelation coefficients
-        for (int i = 0; i <= super.maxLpcOrder; i++) {
+        for (int i = 0; i <= linearPredictor.maxLpcOrder; i++) {
             autocorrelationFactors[i] = 0.0;
             for (int j = i; j < quantizedSamples.length; j++) {
                 autocorrelationFactors[i] += (quantizedSamples[j] - mean) * (quantizedSamples[j - i] - mean);
             }
         }
 
         // Normalise the coefficients
-        for (int i = 1; i <= super.maxLpcOrder; i++) {
+        for (int i = 1; i <= linearPredictor.maxLpcOrder; i++) {
             autocorrelationFactors[i] /= autocorrelationFactors[0];
         }
         autocorrelationFactors[0] = 1.0;
     }
 
     private void generateReflectionCoefficients() {
         double error;
-        final double[][] gen = new double[2][super.maxLpcOrder];
+        final double[][] gen = new double[2][linearPredictor.maxLpcOrder];
 
-        for (int i = 0; i < super.maxLpcOrder; i++) {
+        for (int i = 0; i < linearPredictor.maxLpcOrder; i++) {
             gen[0][i] = gen[1][i] = autocorrelationFactors[i + 1];
         }
 
         error = autocorrelationFactors[0];
-        super.reflectionCoefficients[0] = -gen[1][0] / error;
-        error += gen[1][0] * super.reflectionCoefficients[0];
+        linearPredictor.reflectionCoefficients[0] = -gen[1][0] / error;
+        error += gen[1][0] * linearPredictor.reflectionCoefficients[0];
 
-        for (int i = 1; i < super.maxLpcOrder; i++) {
-            for (int j = 0; j < super.maxLpcOrder - i; j++) {
-                gen[1][j] = gen[1][j + 1] + super.reflectionCoefficients[i - 1] * gen[0][j];
-                gen[0][j] = gen[1][j + 1] * super.reflectionCoefficients[i - 1] + gen[0][j];
+        for (int i = 1; i < linearPredictor.maxLpcOrder; i++) {
+            for (int j = 0; j < linearPredictor.maxLpcOrder - i; j++) {
+                gen[1][j] = gen[1][j + 1] + linearPredictor.reflectionCoefficients[i - 1] * gen[0][j];
+                gen[0][j] = gen[1][j + 1] * linearPredictor.reflectionCoefficients[i - 1] + gen[0][j];
             }
-            super.reflectionCoefficients[i] = -gen[1][0] / error;
-            error += gen[1][0] * super.reflectionCoefficients[i];
+            linearPredictor.reflectionCoefficients[i] = -gen[1][0] / error;
+            error += gen[1][0] * linearPredictor.reflectionCoefficients[i];
         }
     }
 
     private void generateoptimalLpcOrder() {
-        for (int i = super.maxLpcOrder - 1; i >= 0; i--) {
-            if (Math.abs(super.reflectionCoefficients[i]) > 0.05) {
-                super.optimalLpcOrder = (byte) (i + 1);
+        for (int i = linearPredictor.maxLpcOrder - 1; i >= 0; i--) {
+            if (Math.abs(linearPredictor.reflectionCoefficients[i]) > 0.05) {
+                linearPredictor.optimalLpcOrder = (byte) (i + 1);
                 break;
             }
         }
     }
 
     private void quantizeReflectionCoefficients() {
-        super.quantizedReflectionCoefficients = new int[super.optimalLpcOrder];
+        linearPredictor.quantizedReflectionCoefficients = new int[linearPredictor.optimalLpcOrder];
 
-        if (super.quantizedReflectionCoefficients.length > 0) {
-            super.quantizedReflectionCoefficients[0] = (int) Math
-                    .floor(64 * (-1 + (sqrt2 * Math.sqrt(super.reflectionCoefficients[0] + 1))));
+        if (linearPredictor.quantizedReflectionCoefficients.length > 0) {
+            linearPredictor.quantizedReflectionCoefficients[0] = (int) Math
+                    .floor(64 * (-1 + (sqrt2 * Math.sqrt(linearPredictor.reflectionCoefficients[0] + 1))));
         }
-        if (super.quantizedReflectionCoefficients.length > 1) {
-            super.quantizedReflectionCoefficients[1] = (int) Math
-                    .floor(64 * (-1 + (sqrt2 * Math.sqrt(-super.reflectionCoefficients[1] + 1))));
+        if (linearPredictor.quantizedReflectionCoefficients.length > 1) {
+            linearPredictor.quantizedReflectionCoefficients[1] = (int) Math
+                    .floor(64 * (-1 + (sqrt2 * Math.sqrt(-linearPredictor.reflectionCoefficients[1] + 1))));
         }
-        for (int i = 2; i < super.optimalLpcOrder; i++) {
-            super.quantizedReflectionCoefficients[i] = (int) Math.floor(64 * super.reflectionCoefficients[i]);
+        for (int i = 2; i < linearPredictor.optimalLpcOrder; i++) {
+            linearPredictor.quantizedReflectionCoefficients[i] = (int) Math.floor(64 * linearPredictor.reflectionCoefficients[i]);
         }
     }
 
     private void generateResidues() {
-        final long correction = (long) 1 << (super.correctionFactor - 1);
+        final long correction = (long) 1 << (linearPredictor.correctionFactor - 1);
 
         residues[0] = samples[0];
 
-        for (int i = 1; i <= super.optimalLpcOrder; i++) {
+        for (int i = 1; i <= linearPredictor.optimalLpcOrder; i++) {
             long temp = correction;
             for (int j = 1; j <= i; j++) {
-                temp += super.linearPredictionCoefficients[j] * samples[i - j];
+                temp += linearPredictor.linearPredictionCoefficients[j] * samples[i - j];
             }
-            residues[i] = samples[i] - (int) (temp >> super.correctionFactor);
+            residues[i] = samples[i] - (int) (temp >> linearPredictor.correctionFactor);
         }
 
-        for (int i = super.optimalLpcOrder + 1; i < samples.length; i++) {
+        for (int i = linearPredictor.optimalLpcOrder + 1; i < samples.length; i++) {
             long temp = correction;
-            for (int j = 0; j <= super.optimalLpcOrder; j++) {
-                temp += (super.linearPredictionCoefficients[j] * samples[i - j]);
+            for (int j = 0; j <= linearPredictor.optimalLpcOrder; j++) {
+                temp += (linearPredictor.linearPredictionCoefficients[j] * samples[i - j]);
             }
-            residues[i] = samples[i] - (int) (temp >> super.correctionFactor);
+            residues[i] = samples[i] - (int) (temp >> linearPredictor.correctionFactor);
         }
     }
 
@@ -124,9 +126,9 @@ public LpcEncodedData process() {
         generateReflectionCoefficients();
         generateoptimalLpcOrder();
         quantizeReflectionCoefficients();
-        super.dequantizeReflectionCoefficients();
-        super.generatelinearPredictionCoefficients();
+        linearPredictor.dequantizeReflectionCoefficients();
+        linearPredictor.generatelinearPredictionCoefficients();
         generateResidues();
-        return new LpcEncodedData(optimalLpcOrder, quantizedReflectionCoefficients, residues);
+        return new LpcEncodedData(linearPredictor.optimalLpcOrder, linearPredictor.quantizedReflectionCoefficients, residues);
     }
 }

src/main/java/org/sela/lpc/SampleGenerator.java

@@ -2,40 +2,41 @@
 
 import org.sela.data.*;
 
-public final class SampleGenerator extends LinearPredictionBase {
+public final class SampleGenerator {
     private final int[] residues;
     private final int[] samples;
+    private final LinearPredictor linearPredictor;
 
     public SampleGenerator(final LpcEncodedData encodedData) {
-        super(encodedData.quantizedReflectionCoefficients, encodedData.optimalLpcOrder);
+        this.linearPredictor = new LinearPredictor(encodedData.quantizedReflectionCoefficients, encodedData.optimalLpcOrder);
         this.residues = encodedData.residues;
         this.samples = new int[residues.length];
     }
 
     private void generateSamples() {
-        final long correction = (long) 1 << (super.correctionFactor - 1);
+        final long correction = (long) 1 << (linearPredictor.correctionFactor - 1);
 
         samples[0] = residues[0];
 
-        for (int i = 1; i <= super.optimalLpcOrder; i++) {
+        for (int i = 1; i <= linearPredictor.optimalLpcOrder; i++) {
             long temp = correction;
             for (int j = 1; j <= i; j++) {
-                temp -= super.linearPredictionCoefficients[j] * samples[i - j];
+                temp -= linearPredictor.linearPredictionCoefficients[j] * samples[i - j];
             }
-            samples[i] = residues[i] - (int) (temp >> super.correctionFactor);
+            samples[i] = residues[i] - (int) (temp >> linearPredictor.correctionFactor);
         }
 
-        for (int i = super.optimalLpcOrder + 1; i < residues.length; i++) {
+        for (int i = linearPredictor.optimalLpcOrder + 1; i < residues.length; i++) {
             long temp = correction;
-            for (int j = 0; j <= super.optimalLpcOrder; j++)
-                temp -= (super.linearPredictionCoefficients[j] * samples[i - j]);
-            samples[i] = residues[i] - (int) (temp >> super.correctionFactor);
+            for (int j = 0; j <= linearPredictor.optimalLpcOrder; j++)
+                temp -= (linearPredictor.linearPredictionCoefficients[j] * samples[i - j]);
+            samples[i] = residues[i] - (int) (temp >> linearPredictor.correctionFactor);
         }
     }
 
     public LpcDecodedData process() {
-        super.dequantizeReflectionCoefficients();
-        super.generatelinearPredictionCoefficients();
+        linearPredictor.dequantizeReflectionCoefficients();
+        linearPredictor.generatelinearPredictionCoefficients();
         generateSamples();
         return new LpcDecodedData(samples);
     }