// The MIT License

 

 // Copyright (c) 2009 Massachusetts Institute of Technology

 

 // Permission is hereby granted, free of charge, to any person obtaining a copy

 // of this software and associated documentation files (the "Software"), to deal

 // in the Software without restriction, including without limitation the rights

 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 // copies of the Software, and to permit persons to whom the Software is

 // furnished to do so, subject to the following conditions:

 

 // The above copyright notice and this permission notice shall be included in

 // all copies or substantial portions of the Software.

 

 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 // THE SOFTWARE.

 

 // Author: Kermin Fleming kfleming@mit.edu

 

 import Connectable::*;

 import GetPut::*;

 import ClientServer::*;

 import FIFO::*;

 import FixedPoint::*;

 import Vector::*;

 

 //AWB includes.   These import the structure whcih allow us to communicate

 // with the outside world, and are part of the AWB library code

 

 `include "asim/provides/soft_connections.bsh"

 `include "asim/provides/common_services.bsh"

 

 // Local includes. Look for the correspondingly named .awb files

 // workspace/labs/src/mit-6.375/modules/bluespec/mit-6.375/common/

 // to find the actual Bluespec files which are used to generate

 // these includes.  These files are specific to this audio processing

 // pipeline

 

 `include "asim/provides/audio_pipeline_types.bsh"

 `include "asim/provides/audio_processor_types.bsh"

 

 typedef 8 Taps;

 

 module [Connected_Module] mkFIRFilter (FIRFilter);

 

 

   // instantiate an input FIFO and an Output FIFO

   // mkFIFO returns a fifo of length 2 (by default)  

   // AudioProcessorUnit is the name given to the packets

   // of DATA processed by our audio pipeline.  For their 

   // definition, look in the file

   // workspace/labs/src/mit-6.375/modules/bluespec/mit-6.375/common/AudioProcessorTypes.bsv

 

   FIFO#(AudioProcessorUnit) infifo <- mkFIFO;

   FIFO#(AudioProcessorUnit) outfifo <- mkFIFO;

 

 

   // an alternate syntax for instantiating the samples vector

   // would have been as follows:

   //

   // Vector#(Taps,Reg#(Sample)) samples <- replicateM(mkReg(0));

   // 

   // we have used an explicit loop here, to demonstrate how

   // vectors can be instantiated during the static elaboration 

   // phase, even though replicateM is far more concise.

 

   Vector#(Taps,Reg#(Sample)) samples = newVector();

   for(Integer i = 0; i < valueof(Taps); i=i+1)

      samples[i] <- mkReg(0);

 

   Vector#(9,Reg#(FixedPoint#(16,16))) pr <- replicateM(mkReg(0));

   

 

   // fromReal takes a Real number and converts it to a FixedPoint

   // representation.   The compiler is smart enough to infer the 

   // type (bit width) of the fixed point (in this case, we have 16 

   // bits of integer, and 16 bits of fraction.

 

   FixedPoint#(16,16) firCoefs [9] = {fromReal(-0.0124),

                                      fromReal(0.0),

                                      fromReal(-0.0133),

                                      fromReal(0.0),

                                      fromReal(0.8181),

                                      fromReal(0.0),

                                      fromReal(-0.0133),

                                      fromReal(0.0),

                                      fromReal(-0.0124)};

 

 

   // This rule implements a fir filter.  We do the fir computations in

   // 16.16 fixed point.  This preserves the magnitude of the input

   // pcm.  This code was implemented using for loops so as to be more

   // clear. Using the functions map, fold, readVReg, and writeVReg

   // would have been more concise.

 

   rule process (infifo.first matches tagged Sample .sample);

 

     // Advance the fir filter, by shifting all the elements

     // down the Vector of registers (like a shift register)

 

     samples[0] <= sample;

     for(Integer i = 0; i < valueof(Taps) - 1; i = i + 1)

        begin

          samples[i+1] <= samples[i];           

        end

 

     // Filter the values, using an inefficient adder chain.  You will

     // need to shorten the combinatorial path, by pipelining this logic.

 

     FixedPoint#(16,16) accumulate= firCoefs[0] * fromInt(sample);  

     for(Integer i = 0; i < valueof(Taps); i = i + 1)

       begin

         accumulate = accumulate + firCoefs[1+i] * fromInt(samples[i]);  

       end 

 

     outfifo.enq(tagged Sample fxptGetInt(accumulate));

     

     infifo.deq;

   endrule

   

   // Handle the end of stream condition.  Look at the two rule guards,

   // these are obviously mutually exclusive.  The definition of

   // AudioProcessorUnit shows that it can be tagged only as a Sample, or

   // EndOfFile; nothing else!

 

   rule endOfFile (infifo.first matches tagged EndOfFile);

 

     $display("FIR got end of file");

 

     // Reset state for next invocation

     for(Integer i = 0; i < valueof(Taps); i = i + 1)

       begin

         samples[i] <= 0;

         pr[i] <= 0;

       end

 

     // pass the end-of-file token down the pipeline, eventually this will

     // make it back to the software side, to notify it that the stream

     // has been processed completely

 

     outfifo.enq(infifo.first);

     infifo.deq;

   endrule

 

 

   // this section connects the fifos instantiated internally to the 

   // externally visible interface

 

   interface sampleInput = fifoToPut(infifo);

   interface sampleOutput = fifoToGet(outfifo);

 

 endmodule