Subversion Repositories djpeg

//---------------------------------------------------------------------------
// File Name   : jpeg_decode.v
// Module Name : jpeg_decode
// Description : JPEG Deocder top module
// Project     : JPEG Decoder
// Belong to   : 
// Author      : H.Ishihara
// E-Mail      : hidemi@sweetcafe.jp
// HomePage    : http://www.sweetcafe.jp/
// Date        : 2008/03/05
// Rev.        : 2.00
//---------------------------------------------------------------------------
// Rev. Date       Description
//---------------------------------------------------------------------------
// 1.01 2006/10/01 1st Release
// 1.02 2006/10/04 add ProcessIdle register
// 1.99 2007/04/11 
// 2.00 2008/03/05 New Verion
//---------------------------------------------------------------------------
`timescale 1ps / 1ps
 
module jpeg_decode(
    rst,
    clk,
 
    // From FIFO
    DataIn,
    DataInEnable,
    DataInRead,
 
    JpegDecodeIdle,  // Deocdeer Process Idle(1:Idle, 0:Run)
 
    OutEnable,
    OutWidth,
    OutHeight,
    OutPixelX,
    OutPixelY,
    OutR,
    OutG,
    OutB
);
 
    input           rst;
    input           clk;
 
    input [31:0]    DataIn;
    input           DataInEnable;
    output          DataInRead;
 
    output          JpegDecodeIdle;
 
    output          OutEnable;
    output [15:0]   OutWidth;
    output [15:0]   OutHeight;
    output [15:0]   OutPixelX;
    output [15:0]   OutPixelY;
    output [7:0]    OutR;
    output [7:0]    OutG;
    output [7:0]    OutB;
 
    wire [31:0]     JpegData;
    wire            JpegDataEnable;
    wire            JpegDecodeIdle;
 
    wire            UseBit;
    wire [6:0]      UseWidth;
    wire            UseByte;
    wire            UseWord;
 
    wire            ImageEnable;
    wire            EnableFF00;
 
    //reg             ProcessIdle;
 
    //--------------------------------------------------------------------------
    // Read JPEG Data from FIFO
    //--------------------------------------------------------------------------
    jpeg_regdata u_jpeg_regdata(
        .rst(rst),
        .clk(clk),
 
        // Read Data
        .DataIn         ( DataIn            ),
        .DataInEnable   ( DataInEnable      ),
        .DataInRead     ( DataInRead        ),
 
        // DataOut
        .DataOut        ( JpegData          ),
        .DataOutEnable  ( JpegDataEnable    ),
 
        //
        .ImageEnable    ( ImageEnable       ),
        .ProcessIdle    ( JpegDecodeIdle    ),
 
        // UseData
        .UseBit         ( UseBit            ),
        .UseWidth       ( UseWidth          ),
        .UseByte        ( UseByte           ),
        .UseWord        ( UseWord           )
        );
 
    //--------------------------------------------------------------------------
    // Read Maker from Jpeg Data
    //--------------------------------------------------------------------------
    wire            DqtEnable;
    wire            DqtTable;
    wire [5:0]      DqtCount;
    wire [7:0]      DqtData;
 
    wire            DhtEnable;
    wire [1:0]      DhtTable;
    wire [7:0]      DhtCount;
    wire [7:0]      DhtData;
 
    //
    wire            HuffmanEnable;
    wire [1:0]      HuffmanTable;
    wire [3:0]      HuffmanCount;
    wire [15:0]     HuffmanData;
    wire [7:0]      HuffmanStart;
 
    wire [11:0]     JpegBlockWidth;
 
    jpeg_decode_fsm u_jpeg_decode_fsm(
        .rst            ( rst               ),
        .clk            ( clk               ),
 
        // From FIFO
        .DataInEnable   ( JpegDataEnable    ),
        .DataIn         ( JpegData          ),
 
        .JpegDecodeIdle ( JpegDecodeIdle    ),
 
        .OutWidth       ( OutWidth          ),
        .OutHeight      ( OutHeight         ),
        .OutBlockWidth  ( JpegBlockWidth    ),
        .OutEnable      ( OutEnable         ),
        .OutPixelX      ( OutPixelX         ),
        .OutPixelY      ( OutPixelY         ),
 
        //
        .DqtEnable      ( DqtEnable         ),
        .DqtTable       ( DqtTable          ),
        .DqtCount       ( DqtCount          ),
        .DqtData        ( DqtData           ),
 
        //
        .DhtEnable      ( DhtEnable         ),
        .DhtTable       ( DhtTable          ),
        .DhtCount       ( DhtCount          ),
        .DhtData        ( DhtData           ),
 
        //
        .HuffmanEnable  ( HuffmanEnable     ),
        .HuffmanTable   ( HuffmanTable      ),
        .HuffmanCount   ( HuffmanCount      ),
        .HuffmanData    ( HuffmanData       ),
        .HuffmanStart   ( HuffmanStart      ),
 
        //
        .ImageEnable    ( ImageEnable       ),
 
        //
        .UseByte        ( UseByte           ),
        .UseWord        ( UseWord           )
        );
 
 
    wire            HmDecEnable;
    wire [2:0]      HmDecColor;
    wire            HmRead;
    wire [4:0]      HmAddress;
 
    wire [15:0]     HmDataA, HmDataB;
 
 
    jpeg_huffman u_jpeg_huffman(
        .rst                ( rst               ),
        .clk                ( clk               ),
 
        .ProcessInit        ( JpegDecodeIdle    ),
 
        // DQT Table
        .DqtInEnable        ( DqtEnable         ),
        .DqtInColor         ( DqtTable          ),
        .DqtInCount         ( DqtCount[5:0]     ),
        .DqtInData          ( DqtData           ),
 
        // DHT Table
        .DhtInEnable        ( DhtEnable         ),
        .DhtInColor         ( DhtTable          ),
        .DhtInCount         ( DhtCount          ),
        .DhtInData          ( DhtData           ),
 
        // Huffman Table   
        .HuffmanTableEnable ( HuffmanEnable     ),
        .HuffmanTableColor  ( HuffmanTable      ),
        .HuffmanTableCount  ( HuffmanCount      ),
        .HuffmanTableCode   ( HuffmanData       ),
        .HuffmanTableStart  ( HuffmanStart      ),
 
        // Huffman Decode
        .DataInRun          ( ImageEnable       ),
        .DataInEnable       ( JpegDataEnable    ),
        .DataIn             ( JpegData          ),
 
        // Output decode data   
        .DecodeUseBit       ( UseBit            ),
        .DecodeUseWidth     ( UseWidth          ),
 
        // Data Out
        .DataOutEnable      ( HmDecEnable       ),
        .DataOutRead        ( HmRead            ),
        .DataOutAddress     ( HmAddress         ),
        .DataOutColor       ( HmDecColor        ),
        .DataOutA           ( HmDataA           ),
        .DataOutB           ( HmDataB           )
        );
 
    wire            DctEnable;
    wire [2:0]      DctColor;
    wire [2:0]      DctPage;
    wire [1:0]      DctCount;
    wire [8:0]      Dct0Data, Dct1Data;
 
    wire [15:0]     DctWidth, DctHeight;
    wire [11:0]     DctBlockX, DctBlockY;
 
    wire            YCbCrIdle;
 
    jpeg_idct u_jpeg_idct(
        .rst            ( rst           ),
        .clk            ( clk           ),
 
        .ProcessInit    ( JpegDecodeIdle    ),
 
        .DataInEnable   ( HmDecEnable   ),
        .DataInRead     ( HmRead        ),
        .DataInAddress  ( HmAddress     ),
        .DataInA        ( HmDataA       ),
        .DataInB        ( HmDataB       ),
 
        .DataOutEnable  ( DctEnable     ),
        .DataOutPage    ( DctPage       ),
        .DataOutCount   ( DctCount      ),
        .Data0Out       ( Dct0Data      ),
        .Data1Out       ( Dct1Data      )
        );
 
    wire            ColorEnable;
    wire [15:0]     ColorPixelX, ColorPixelY;
    wire [7:0]      ColorR, ColorG, ColorB;
    jpeg_ycbcr u_jpeg_ycbcr(
        .rst                ( rst               ),
        .clk                ( clk               ),
 
        .ProcessInit        ( JpegDecodeIdle    ),
 
        .DataInEnable       ( DctEnable         ),
        .DataInPage         ( DctPage           ),
        .DataInCount        ( DctCount          ),
        .DataInIdle         ( YCbCrIdle         ),
        .Data0In            ( Dct0Data          ),
        .Data1In            ( Dct1Data          ),
        .DataInBlockWidth   ( JpegBlockWidth    ),
 
        .OutEnable          ( ColorEnable       ),
        .OutPixelX          ( ColorPixelX       ),
        .OutPixelY          ( ColorPixelY       ),
        .OutR               ( ColorR            ),
        .OutG               ( ColorG            ),
        .OutB               ( ColorB            )
        );
    // OutData
    assign OutEnable = (ImageEnable)?ColorEnable:1'b0;
    assign OutPixelX = (ImageEnable)?ColorPixelX:16'd0;
    assign OutPixelY = (ImageEnable)?ColorPixelY:16'd0;
    assign OutR      = (ImageEnable)?ColorR:8'd0;
    assign OutG      = (ImageEnable)?ColorG:8'd0;
    assign OutB      = (ImageEnable)?ColorB:8'd0;
 
endmodule