/* Ramme for Compressed1100Sound.
   Dette er et utgangspunkt for å arbeide med oppgave 3b i oblig2.
   Strukturen for programmet er gitt, men du må selv fylle inn
   mesteparten av koden.
   For at alt skal fungere greit bør du gi fila di navnet
   Compressed1100Sound.java. Det er dessuten lurt å løse oppgave 3a
   først, eller i det minste å lese tipsene i forslaga.java.
*/

class Compressed1100Sound extends AbstractCompressedSound
{
    /* Klassen må ha data som kan lagre den grove tilnærmingen g
	   og feilfunksjonene e_i. Til det bruker vi arrayene d (endimensjonal)
	   og w (todimensjonal).
	   I tillegg bør vi vite hva samplingsraten er og det er også
	   greit å vite hvor stor toleranse som ble brukt.
	*/
	
	short d[]; //Den grove delen av den dekomponerte lyden
    short w[][]; //Feilfunksjonen(e). Her kan du lagre verdiene til
                 //feilfunksjonen, se under.
    double sampleRate;
    short eps; //Toleranse (brukes ikke i mitt enkle eksempel)

    Compressed1100Sound(MatInf1100Sound f) 
    {
    
	/* Dette er konstruktøren som tar et lydobjekt som representerer f som
     * inngangsparameter og skal gi ut det dekomponerte signalet.
     * Fra kompendiet vet vi at det dekomponerte signalet
     * består av en grov versjon av signalet samt en samling av
     * feilfunksjoner. Alle disse funksjonene kan lagres ved sine koeffisienter,
     * det vil si arrayen d for g og w-arrayene for feilfunksjonene. Alle disse
     * kan være short-arrayer slik jeg har indikert over ved å deklarere d og w.
     * Siden det generelt er mange feilfunksjoner trenger vi en todimensjonal
     * array for å lagre alle w-verdiene.
     */

        super(f); //Kaller konstruktøren til superklassen
                  //(ikke nødvendig å forstå)
		int k;    //Antall dekomposisjoner. Må settes til en konstant,
		 		  // regnes ut eller leses inn fra terminal
		 		  
        sampleRate = f.sampleRate;
        d = f.samples; //Initialiserer d
        
        w = new short[k][]; //Setter av plass til riktig antall w'er
        
        int j, cm, wm;
        short c[];

        for (j=0; j<k; j++) //Gjør k dekomponeringer
        {
            c = d; // c er samplene til lyden som nå skal dekomponeres
            cm = (c.length + 1) / 2; //lengden til det nye grove signalet
            wm =  					 //lengden til den nye w'en
            if ((c.length % 2) == 0) //Hvis lengden til c er et partall skal
                                     //den siste w'en beregnes spesielt,
                                     //se øverst seksjon 10.3.4 i kompendiet
            
            d = new short[cm]; //setter av plass til det grove signalet
            w[j] = new short[wm]; //setter av plass til w'en
            
            //beregner d'ene (samplene til det grove signalet)
            
            //beregner w[j]'ene og setter de små til null
                        
            //Må fikse siste element i w[j] hvis antall sampler
            //er et partall

        }
                
    }
    
    
    
    public MatInf1100Sound decompress()
    {
    
        //Her gjøres dekomposisjonen i revers
        
        short c[];
        short dd[];
        int j;
        dd = (short[]) (d.clone()); // Ønsker ikke å ødelegge d,
                                    //så vi tar en kopi.
        
        //Løper gjennom i motsatt rekkefølge
        for (j=k-1; j>=0; j--)
        {
  			//Gjør det motsatte av compress
        }
        
        d = dd; //Pass på å gi d tilbake sin opprinnelige verdi hvis d
                //er endret inne i løkka.
        
    return new MatInf1100Sound(c,sampleRate); //Returner lydsignal
    }
    
    

    public boolean isLossless()
    {
        return false;
    }
}