Subversion Repositories bluespec-h264

// The MIT License

// Copyright (c) 2006-2007 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.

//**********************************************************************

// Inverse Quantizer and Inverse Transformer implementation

//----------------------------------------------------------------------

//

//

package mkInverseTrans;

import H264Types::*;

import IInverseTrans::*;

import FIFO::*;

import Vector::*;

import Connectable::*;

import GetPut::*;

import ClientServer::*;

//-----------------------------------------------------------

// Local Datatypes

//-----------------------------------------------------------

typedef union tagged

{

 void     Start;            //not working on anything in particular

 void     Intra16x16DC;

 void     Intra16x16;

 void     ChromaDC;

 void     Chroma;

 void     Regular4x4;

}

State deriving(Eq,Bits);

typedef union tagged

{

 void     Passing;          //not working on anything in particular

 void     LoadingDC;

 void     Scaling;          //does not include scaling for DC (just loading in that case)

 void     TransformingDC;

 void     ScalingDC;

}

Process deriving(Eq,Bits);

typedef union tagged

{

 void     Invalid;

 void     Zeros;

 Vector#(16,Bit#(16)) Values;

}

PipeType deriving(Eq,Bits);

//-----------------------------------------------------------

// Helper functions

function Bit#(6) qpi_to_qpc( Bit#(6) qpi );//mapping from qpi to qpc

   case ( qpi )

      30: return 29;

      31: return 30;

      32: return 31;

      33: return 32;

      34: return 32;

      35: return 33;

      36: return 34;

      37: return 34;

      38: return 35;

      39: return 35;

      40: return 36;

      41: return 36;

      42: return 37;

      43: return 37;

      44: return 37;

      45: return 38;

      46: return 38;

      47: return 38;

      48: return 39;

      49: return 39;

      50: return 39;

      51: return 39;

      default: return qpi;

   endcase

endfunction

function Bit#(4) reverseInverseZigZagScan( Bit#(4) idx );

   case ( idx )

      0: return 15;

      1: return 14;

      2: return 11;

      3: return 7;

      4: return 10;

      5: return 13;

      6: return 12;

      7: return 9;

      8: return 6;

      9: return 3;

      10: return 2;

      11: return 5;

      12: return 8;

      13: return 4;

      14: return 1;

      15: return 0;

   endcase

endfunction

function Tuple2#(Bit#(4),Bit#(3)) qpdivmod6( Bit#(6) qp );

   Bit#(6) tempqp = qp;

   Bit#(4) tempdiv = 0;

   for(Integer ii=5; ii>=2; ii=ii-1)

      begin

         if(tempqp >= (6'b000011 << (fromInteger(ii)-1)))

            begin

               tempqp = tempqp - (6'b000011 << (fromInteger(ii)-1));

               tempdiv = tempdiv | (4'b0001 << (fromInteger(ii)-2));

            end

      end

   return tuple2(tempdiv,truncate(tempqp));

endfunction

function Vector#(4,Bit#(16)) dcTransFunc( Bit#(16) in0, Bit#(16) in1, Bit#(16) in2, Bit#(16) in3 );

   Vector#(4,Bit#(16)) resultVector = replicate(0);

   resultVector[0] = in0 + in1 + in2 + in3;

   resultVector[1] = in0 + in1 - in2 - in3;

   resultVector[2] = in0 - in1 - in2 + in3;

   resultVector[3] = in0 - in1 + in2 - in3;

   return resultVector;

endfunction

function Vector#(4,Bit#(16)) transFunc( Bit#(16) in0, Bit#(16) in1, Bit#(16) in2, Bit#(16) in3 );

   Vector#(4,Bit#(16)) resultVector = replicate(0);

   Bit#(16) workValue0 = in0 + in2;

   Bit#(16) workValue1 = in0 - in2;

   Bit#(16) workValue2 = signedShiftRight(in1,1) - in3;

   Bit#(16) workValue3 = in1 + signedShiftRight(in3,1);

   resultVector[0] = workValue0 + workValue3;

   resultVector[1] = workValue1 + workValue2;

   resultVector[2] = workValue1 - workValue2;

   resultVector[3] = workValue0 - workValue3;

   return resultVector;

endfunction

//-----------------------------------------------------------

// Inverse Quantizer and Inverse Transformer Module

//-----------------------------------------------------------

(* synthesize *)

module mkInverseTrans( IInverseTrans );

   FIFO#(EntropyDecOT_InverseTrans) infifo  <- mkSizedFIFO(inverseTrans_infifo_size);

   FIFO#(InverseTransOT)            outfifo <- mkFIFO;

   Reg#(Bit#(4))       blockNum <- mkReg(0);

   Reg#(Bit#(4))       pixelNum <- mkReg(0);//also used as a regular counter during inverse transformation

   Reg#(State)         state    <- mkReg(Start);

   Reg#(Process)       process  <- mkReg(Passing);

   Reg#(Bit#(5))        chroma_qp_index_offset <- mkReg(0);

   Reg#(Bit#(6))        ppspic_init_qp <- mkReg(0);

   Reg#(Bit#(6))        slice_qp       <- mkReg(0);

   Reg#(Bit#(6))        qpy            <- mkReg(0);//Calculating it requires 8 bits, but value only 0 to 51

   Reg#(Bit#(6))        qpc            <- mkReg(0);

   Reg#(Bit#(3))        qpymod6        <- mkReg(0);

   Reg#(Bit#(3))        qpcmod6        <- mkReg(0);

   Reg#(Bit#(4))        qpydiv6        <- mkReg(0);

   Reg#(Bit#(4))        qpcdiv6        <- mkReg(0);

   Reg#(Vector#(16,Bit#(16))) storeVector <- mkRegU();

   Reg#(Vector#(16,Bit#(16))) workVector  <- mkRegU();

   Reg#(PipeType)             work2Vector <- mkReg(Invalid);

   Reg#(PipeType)             work3Vector <- mkReg(Invalid);

   Reg#(Bool)                 stage1Zeros <- mkReg(False);

   Reg#(Bool)                 stage1Done  <- mkReg(False);

   Reg#(Bool)                 stage2Done  <- mkReg(False);

   Reg#(Bool)                 stage3Done  <- mkReg(False);

   Reg#(Bit#(3))              stage2Step  <- mkReg(0);

   Reg#(Bit#(2))              stage3Step  <- mkReg(0);

   //-----------------------------------------------------------

   // Rules

   rule passing (process==Passing && work2Vector==Invalid && (stage3Done || work3Vector==Invalid) );

      //$display( "Trace Inverse Trans: passing infifo packed %h", pack(infifo.first()));

      case (infifo.first()) matches

         tagged NewUnit . xdata :

            begin

               infifo.deq();

               $display("ccl3newunit");

               $display("ccl3rbspbyte %h", xdata);

            end

         tagged SDMmbtype .xdata :

            begin

               infifo.deq();

               $display( "INFO InverseTrans: SDMmbtype %0d", xdata);

               if(mbPartPredMode(xdata,0) == Intra_16x16)

                  state <= Intra16x16DC;

               else

                  state <= Regular4x4;

            end

         tagged PPSpic_init_qp .xdata :

            begin

               infifo.deq();

               ppspic_init_qp <= truncate(xdata);

            end

         tagged SHslice_qp_delta .xdata :

            begin

               infifo.deq();

               slice_qp <= ppspic_init_qp+truncate(xdata);

               Bit#(6) qpynext = ppspic_init_qp+truncate(xdata);

               qpy <= qpynext;

               Bit#(7) qpitemp = zeroExtend(chroma_qp_index_offset+12) + zeroExtend(qpynext);

               Bit#(6) qpi;

               if(qpitemp < 12)

                  qpi = 0;

               else if(qpitemp > 63)

                  qpi = 51;

               else

                  qpi = truncate(qpitemp-12);

               qpc <= qpi_to_qpc(qpi);

               outfifo.enq(IBTmb_qp {qpy:qpynext,qpc:qpi_to_qpc(qpi)});

            end

         tagged SDMmb_qp_delta .xdata :

            begin

               infifo.deq();

               Bit#(8) qpytemp = zeroExtend(qpy) + zeroExtend(xdata+52);

               Bit#(6) qpynext;

               if(qpytemp >= 104)

                  qpynext = truncate(qpytemp - 104);

               else if(qpytemp >= 52)

                  qpynext = truncate(qpytemp - 52);

               else

                  qpynext = truncate(qpytemp);

               qpy <= qpynext;

               //$display( "TRACE InverseTrans: qpy %0d", qpynext );

               //$display( "TRACE InverseTrans: qpy %0d", qpynext );

               Tuple2#(Bit#(4),Bit#(3)) temptuple = qpdivmod6(qpynext);

               qpydiv6 <= tpl_1(temptuple);

               qpymod6 <= tpl_2(temptuple);

               //$display( "TRACE InverseTrans: qpydiv6 %0d", tpl_1(temptuple) );

               //$display( "TRACE InverseTrans: qpymod6 %0d", tpl_2(temptuple) );

               Bit#(7) qpitemp = zeroExtend(chroma_qp_index_offset+12) + zeroExtend(qpynext);

               Bit#(6) qpi;

               if(qpitemp < 12)

                  qpi = 0;

               else if(qpitemp > 63)

                  qpi = 51;

               else

                  qpi = truncate(qpitemp-12);

               qpc <= qpi_to_qpc(qpi);

               outfifo.enq(IBTmb_qp {qpy:qpynext,qpc:qpi_to_qpc(qpi)});

            end

         tagged PPSchroma_qp_index_offset .xdata :

            begin

               infifo.deq();

               chroma_qp_index_offset <= xdata;

            end

         tagged SDMRcoeffLevelPlusZeros .xdata :

            begin

               blockNum <= 0;

               pixelNum <= 0;

               if(state == Intra16x16DC)

                  begin

                     $display( "INFO InverseTrans: 16x16 MB" );

                     process <= LoadingDC;

                  end

               else

                  begin

                     $display( "INFO InverseTrans: Non-16x16 MB" );

                     process <= Scaling;

                  end

               workVector <= replicate(0);

               Tuple2#(Bit#(4),Bit#(3)) temptuple = qpdivmod6(qpc);

               qpcdiv6 <= tpl_1(temptuple);

               qpcmod6 <= tpl_2(temptuple);

            end

         tagged SDMRcoeffLevelZeros .xdata :

            begin

               blockNum <= 0;

               pixelNum <= 0;

               if(state == Intra16x16DC)

                  begin

                     $display( "INFO InverseTrans: 16x16 MB" );

                     process <= LoadingDC;

                  end

               else

                  begin

                     $display( "INFO InverseTrans: Non-16x16 MB" );

                     process <= Scaling;

                  end

               workVector <= replicate(0);

               Tuple2#(Bit#(4),Bit#(3)) temptuple = qpdivmod6(qpc);

               qpcdiv6 <= tpl_1(temptuple);

               qpcmod6 <= tpl_2(temptuple);

            end

         default: infifo.deq();

      endcase

   endrule

   rule loadingDC (process matches LoadingDC);

      Vector#(16,Bit#(16)) workVectorTemp = workVector;

      case (infifo.first()) matches

         tagged SDMRcoeffLevelZeros .xdata :

            begin

               infifo.deq();

               pixelNum <= pixelNum+truncate(xdata);

               if((state==ChromaDC && zeroExtend(pixelNum)+xdata==8) || zeroExtend(pixelNum)+xdata==16)

                  process <= TransformingDC;

               else if((state==ChromaDC && zeroExtend(pixelNum)+xdata>8) || zeroExtend(pixelNum)+xdata>16)

                  $display( "ERROR InverseTrans: loadingDC index overflow" );

            end

         tagged SDMRcoeffLevelPlusZeros .xdata :

            begin

               infifo.deq();

               Bit#(16) workValue = signExtend(xdata.level);

               if(state==ChromaDC)

                  begin

                     if(pixelNum<4)

                        workVector <= update(workVectorTemp, 3-pixelNum, workValue);

                     else

                        workVector <= update(workVectorTemp, 11-pixelNum, workValue);

                  end

               else

                  workVector <= update(workVectorTemp, reverseInverseZigZagScan(pixelNum), workValue);

               pixelNum <= pixelNum+1+truncate(xdata.zeros);

               if((state==ChromaDC && zeroExtend(pixelNum)+1+xdata.zeros==8) || zeroExtend(pixelNum)+1+xdata.zeros==16)

                  process <= TransformingDC;

               else if((state==ChromaDC && zeroExtend(pixelNum)+1+xdata.zeros>8) || zeroExtend(pixelNum)+1+xdata.zeros>16)

                  $display( "ERROR InverseTrans: loadingDC index overflow" );

            end

         default: process <= Passing;

      endcase

   endrule

   rule transformingDC (process matches TransformingDC);

      Vector#(16,Bit#(16)) workVectorTemp = workVector;

      Vector#(16,Bit#(16)) workVectorNew = workVector;

      Vector#(16,Bit#(16)) storeVectorTemp = storeVector;

      if(state == ChromaDC)

         begin

            case ( pixelNum )

               8:

               begin

                  workVectorNew[0] = workVectorTemp[0] + workVectorTemp[2];

                  workVectorNew[1] = workVectorTemp[1] + workVectorTemp[3];

                  workVectorNew[2] = workVectorTemp[0] - workVectorTemp[2];

                  workVectorNew[3] = workVectorTemp[1] - workVectorTemp[3];

                  pixelNum <= pixelNum+1;

               end

               9:

               begin

                  workVectorNew[0] = workVectorTemp[0] + workVectorTemp[1];

                  workVectorNew[1] = workVectorTemp[0] - workVectorTemp[1];

                  workVectorNew[2] = workVectorTemp[2] + workVectorTemp[3];

                  workVectorNew[3] = workVectorTemp[2] - workVectorTemp[3];

                  pixelNum <= pixelNum+1;

               end

               10:

               begin

                  workVectorNew[4] = workVectorTemp[4] + workVectorTemp[6];

                  workVectorNew[5] = workVectorTemp[5] + workVectorTemp[7];

                  workVectorNew[6] = workVectorTemp[4] - workVectorTemp[6];

                  workVectorNew[7] = workVectorTemp[5] - workVectorTemp[7];

                  pixelNum <= pixelNum+1;

               end

               11:

               begin

                  workVectorNew[4] = workVectorTemp[4] + workVectorTemp[5];

                  workVectorNew[5] = workVectorTemp[4] - workVectorTemp[5];

                  workVectorNew[6] = workVectorTemp[6] + workVectorTemp[7];

                  workVectorNew[7] = workVectorTemp[6] - workVectorTemp[7];

                  pixelNum <= 0;

                  process <= ScalingDC;

               end

               default:

                  $display( "ERROR InverseTrans: transformingDC ChromaDC unexpected pixelNum" );

            endcase

            workVector <= workVectorNew;

         end

      else if(state == Intra16x16DC)

         begin

            Vector#(4,Bit#(16)) resultVector = replicate(0);

            if(pixelNum < 4)

               begin

                  Bit#(4) tempIndex = zeroExtend(pixelNum[1:0]);

                  resultVector = dcTransFunc( workVectorTemp[tempIndex], workVectorTemp[tempIndex+4], workVectorTemp[tempIndex+8], workVectorTemp[tempIndex+12] );

                  for(Integer ii=0; ii<4; ii=ii+1)

                     workVectorNew[tempIndex+fromInteger(ii*4)] = resultVector[ii];

               end

            else if(pixelNum < 8)

               begin

                  Bit#(4) tempIndex = {pixelNum[1:0],2'b00};

                  resultVector = dcTransFunc( workVectorTemp[tempIndex], workVectorTemp[tempIndex+1], workVectorTemp[tempIndex+2], workVectorTemp[tempIndex+3] );

                  for(Integer ii=0; ii<4; ii=ii+1)

                     workVectorNew[tempIndex+fromInteger(ii)] = resultVector[ii];

               end

            else

               $display( "ERROR InverseTrans: transforming Intra16x16DC unexpected pixelNum" );

            workVector <= workVectorNew;

            if(pixelNum == 7)

               begin

                  pixelNum <= 0;

                  process <= ScalingDC;

               end

            else

               pixelNum <= pixelNum+1;

         end

      else

         $display( "ERROR InverseTrans: transformingDC unexpected state" );

   endrule

   rule scalingDC (process matches ScalingDC);

      Bit#(6)  qp;

      Bit#(4)  qpdiv6;

      Bit#(3)  qpmod6;

      Bit#(6)  workOne = 1;

      Bit#(16) workValue;

      Bit#(22) storeValueTemp;

      Bit#(16) storeValue;

      Vector#(16,Bit#(16)) workVectorTemp = workVector;

      Vector#(16,Bit#(16)) storeVectorTemp = storeVector;

      if(state==ChromaDC)

         begin

            qp = qpc;

            qpdiv6 = qpcdiv6;

            qpmod6 = qpcmod6;

         end

      else

         begin

            qp = qpy;

            qpdiv6 = qpydiv6;

            qpmod6 = qpymod6;

         end

      workValue = select(workVectorTemp, pixelNum);

      Bit#(5) levelScaleValue=0;

      case(qpmod6)

         0: levelScaleValue = 10;

         1: levelScaleValue = 11;

         2: levelScaleValue = 13;

         3: levelScaleValue = 14;

         4: levelScaleValue = 16;

         5: levelScaleValue = 18;

         default: $display( "ERROR InverseTrans: scalingDC levelScaleGen case default" );

      endcase

      storeValueTemp = zeroExtend(levelScaleValue)*signExtend(workValue);

      if(state==ChromaDC)

         storeValue = truncate( (storeValueTemp << zeroExtend(qpdiv6)) >> 1 );

      else

         begin

            if(qp >= 36)

               storeValue = truncate( storeValueTemp << zeroExtend(qpdiv6 - 2) );

            else

               storeValue = truncate( ((storeValueTemp << 4) + zeroExtend(workOne << zeroExtend(5-qpdiv6))) >> zeroExtend(6 - qpdiv6) );

         end

      storeVector <= update(storeVectorTemp, pixelNum, storeValue);

      if((state==ChromaDC && pixelNum==7) || pixelNum==15)

         begin

            blockNum <= 0;

            pixelNum <= 0;

            workVector <= replicate(0);

            if(state==ChromaDC)

               state <= Chroma;

            else

               state <= Intra16x16;

            process <= Scaling;

         end

      else if((state==ChromaDC && pixelNum>7) || pixelNum>15)

         $display( "ERROR InverseTrans: scalingDC index overflow" );

      else

         pixelNum <= pixelNum+1;

   endrule

   rule switching ( (stage1Done && work2Vector==Invalid) || (stage2Done && (stage3Done || work3Vector==Invalid)) );

      Bool switch2to3 = False;

      if(stage2Done && (stage3Done || work3Vector==Invalid))

         begin

            switch2to3 = True;

            work3Vector <= work2Vector;

            stage3Done <= False;

         end

      if(stage1Done && (switch2to3 || work2Vector==Invalid))

         begin

            Vector#(16,Bit#(16)) workVectorTemp = workVector;

            if(state==Intra16x16)

               workVectorTemp[0] = storeVector[{blockNum[3],blockNum[1],blockNum[2],blockNum[0]}];

            else if(state==Chroma)

               workVectorTemp[0] = storeVector[blockNum];

            if(stage1Zeros)

               work2Vector <= Zeros;

            else

               work2Vector <= (tagged Values workVectorTemp);

            stage1Zeros <= False;

            stage1Done <= False;

            workVector <= replicate(0);

            if(state==Chroma)

               begin

                  if(blockNum<7)

                     blockNum <= blockNum+1;

                  else if (blockNum==7)

                     begin

                        blockNum <= 0;

                        process <= Passing;

                     end

                  else

                     $display( "ERROR InverseTrans: switching chroma unexpected blockNum" );

               end

            else

               begin

                  blockNum <= blockNum+1;

                  if(blockNum==15)

                     begin

                        state <= ChromaDC;

                        process <= LoadingDC;

                     end

                  else

                     process <= Scaling;

               end

         end

      else //switch2to3==True

         work2Vector <= Invalid;

      stage2Done <= False;

   endrule

   rule scaling (process==Scaling && !stage1Done );

      Vector#(16,Bit#(16)) workVectorTemp = workVector;

      Vector#(16,Bit#(16)) storeVectorTemp = storeVector;

      case (infifo.first()) matches

         tagged SDMRcoeffLevelZeros .xdata :

            begin

               infifo.deq();

               if(zeroExtend(pixelNum)+xdata==16 || (zeroExtend(pixelNum)+xdata==15 && (state==Chroma || state==Intra16x16)))

                  begin

                     Bit#(16) prevValue0=0;

                     if(state==Intra16x16)

                        prevValue0 = select(storeVectorTemp, {blockNum[3],blockNum[1],blockNum[2],blockNum[0]});

                     else if(state==Chroma)

                        prevValue0 = select(storeVectorTemp, blockNum);

                     if(xdata==16 || (xdata==15 && (state==Chroma || state==Intra16x16) && prevValue0==0))

                        stage1Zeros <= True;

                     stage1Done <= True;

                     pixelNum <= 0;

                  end

               else if(zeroExtend(pixelNum)+xdata>16 || (zeroExtend(pixelNum)+xdata>15 && (state==Chroma || state==Intra16x16)))

                  $display( "ERROR InverseTrans: scaling index overflow" );

               else

                  pixelNum <= pixelNum+truncate(xdata);

               //$display( "TRACE InverseTrans: coeff zeros %0d", xdata );

            end

         tagged SDMRcoeffLevelPlusZeros .xdata :

            begin

               infifo.deq();

               Bit#(6)  qp;

               Bit#(4)  qpdiv6;

               Bit#(3)  qpmod6;

               if(state==Chroma)

                  begin

                     qp = qpc;

                     qpdiv6 = qpcdiv6;

                     qpmod6 = qpcmod6;

                  end

               else

                  begin

                     qp = qpy;

                     qpdiv6 = qpydiv6;

                     qpmod6 = qpymod6;

                  end

               Bit#(5) levelScaleValue=0;

               if(pixelNum==15 || pixelNum==12 || pixelNum==10 || pixelNum==4)

                  begin

                     case(qpmod6)

                        0: levelScaleValue = 10;

                        1: levelScaleValue = 11;

                        2: levelScaleValue = 13;

                        3: levelScaleValue = 14;

                        4: levelScaleValue = 16;

                        5: levelScaleValue = 18;

                        default: $display( "ERROR InverseTrans: levelScaleGen case default" );

                     endcase

                  end

               else if(pixelNum==11 || pixelNum==5 || pixelNum==3 || pixelNum==0)

                  begin

                     case(qpmod6)

                        0: levelScaleValue = 16;

                        1: levelScaleValue = 18;

                        2: levelScaleValue = 20;

                        3: levelScaleValue = 23;

                        4: levelScaleValue = 25;

                        5: levelScaleValue = 29;

                        default: $display( "ERROR InverseTrans: levelScaleGen case default" );

                     endcase

                  end

               else

                  begin

                     case(qpmod6)

                        0: levelScaleValue = 13;

                        1: levelScaleValue = 14;

                        2: levelScaleValue = 16;

                        3: levelScaleValue = 18;

                        4: levelScaleValue = 20;

                        5: levelScaleValue = 23;

                        default: $display( "ERROR InverseTrans: levelScaleGen case default" );

                     endcase

                  end

               Bit#(16) workValueTemp = zeroExtend(levelScaleValue)*signExtend(xdata.level);

               Bit#(16) workValue;

               workValue = workValueTemp << zeroExtend(qpdiv6);

               workVector <= update(workVectorTemp, reverseInverseZigZagScan(pixelNum), workValue);

               if(zeroExtend(pixelNum)+1+xdata.zeros==16 || (zeroExtend(pixelNum)+1+xdata.zeros==15 && (state==Chroma || state==Intra16x16)))

                  begin

                     stage1Done <= True;

                     pixelNum <= 0;

                  end

               else if(zeroExtend(pixelNum)+1+xdata.zeros>16 || (zeroExtend(pixelNum)+1+xdata.zeros>15 && (state==Chroma || state==Intra16x16)))

                  $display( "ERROR InverseTrans: scaling index overflow" );

               else

                  pixelNum <= pixelNum+1+truncate(xdata.zeros);

            end

         default: process <= Passing;

      endcase

   endrule

   rule transforming ( work2Vector!=Invalid && !stage2Done );

      if(work2Vector matches tagged Values .xdata)

         begin

            Vector#(16,Bit#(16)) work2VectorNew = xdata;

            if(stage2Step < 4)

               begin

                  Bit#(4) tempIndex = {stage2Step[1:0],2'b00};

                  Vector#(4,Bit#(16)) resultVector = transFunc( xdata[tempIndex], xdata[tempIndex+1], xdata[tempIndex+2], xdata[tempIndex+3] );

                  for(Integer ii=0; ii<4; ii=ii+1)

                     work2VectorNew[tempIndex+fromInteger(ii)] = resultVector[ii];

               end

            else

               begin

                  Bit#(4) tempIndex = zeroExtend(stage2Step[1:0]);

                  Vector#(4,Bit#(16)) resultVector = transFunc( xdata[tempIndex], xdata[tempIndex+4], xdata[tempIndex+8], xdata[tempIndex+12] );

                  for(Integer ii=0; ii<4; ii=ii+1)

                     work2VectorNew[tempIndex+fromInteger(ii*4)] = resultVector[ii];

               end

            work2Vector <= (tagged Values work2VectorNew);

            if(stage2Step == 7)

               stage2Done <= True;

            stage2Step <= stage2Step+1;

         end

      else //All Zeros

         stage2Done <= True;

   endrule

   rule outputing ( work3Vector!=Invalid && !stage3Done );

      if(work3Vector matches tagged Values .xdata)

         begin

            Vector#(4,Bit#(10)) outputVector = replicate(0);

            for(Integer ii=0; ii<4; ii=ii+1)

               outputVector[ii] = truncate((xdata[{stage3Step,2'b00}+fromInteger(ii)]+32) >> 6);

            outfifo.enq(tagged ITBresidual outputVector);

            Int#(10) tempint = unpack(outputVector[0]);

            $display("ccl3IBTresidual %0d", tempint);

            tempint = unpack(outputVector[1]);

            $display("ccl3IBTresidual %0d", tempint);

            tempint = unpack(outputVector[2]);

            $display("ccl3IBTresidual %0d", tempint);

            tempint = unpack(outputVector[3]);

            $display("ccl3IBTresidual %0d", tempint);

            if(stage3Step == 3)

               stage3Done <= True;

            stage3Step <= stage3Step+1;

         end

      else

         begin

            outfifo.enq(ITBcoeffLevelZeros);

            stage3Done <= True;

         end

   endrule

   interface Put ioin  = fifoToPut(infifo);

   interface Get ioout = fifoToGet(outfifo);

endmodule

endpackage