URL https://opencores.org/ocsvn/djpeg/djpeg/trunk

Subversion Repositories djpeg

[/] [djpeg/] [trunk/] [src/] [jpeg_decode_fsm.v] - Blame information for rev 6

Go to most recent revision | Details | Compare with Previous | View Log


//---------------------------------------------------------------------------
// File Name    : jpeg_decode_fsm.v
// Module Name  : jpeg_decode_fsm
// Description  : Decode Maker
// Project              : JPEG Decoder
// Belong to    : 
// Author               : H.Ishihara
// E-Mail               : hidemi@sweetcafe.jp
// HomePage             : http://www.sweetcafe.jp/
// Date                 : 2007/04/11
// Rev.                 : 1.03
//---------------------------------------------------------------------------
// Rev. Date             Description
//---------------------------------------------------------------------------
// 1.01 2006/10/01 1st Release
// 1.02 2006/10/04 Remove a HmOldData register.
//                                              When reset, clear a ReadDqtTable register.
// 1.03 2007/04/11 Remove JpegDecodeStart
//                 Exchange StateMachine(Add ImageData)
//                 Remove JpegDecodeStart
//---------------------------------------------------------------------------
// $Id: 
//---------------------------------------------------------------------------
`timescale 1ps / 1ps
 
module jpeg_decode_fsm
        (
        rst,
        clk,
 
        // From FIFO
        DataInEnable,
        DataIn,
 
        JpegDecodeIdle,         // Deocdeer Process Idle(1:Idle, 0:Run)
 
        OutWidth,
        OutHeight,
        OutBlockWidth,
        OutEnable,
        OutPixelX,
        OutPixelY,
 
        //
        DqtEnable,
        DqtTable,
        DqtCount,
        DqtData,
 
        //
        DhtEnable,
        DhtTable,
        DhtCount,
        DhtData,
 
        //
        HaffumanEnable,
        HaffumanTable,
        HaffumanCount,
        HaffumanData,
        HaffumanStart,
 
        //
        ImageEnable,
        ImageEnd,
        EnableFF00,
 
        //
        UseByte,
        UseWord
        );
 
        input                    rst;
        input                    clk;
 
        input                   DataInEnable;
        input [31:0]     DataIn;
 
        output                  JpegDecodeIdle;
 
        output [15:0]    OutWidth;
        output [15:0]    OutHeight;
        output [11:0]    OutBlockWidth;
        input                   OutEnable;
        input [15:0]     OutPixelX;
        input [15:0]     OutPixelY;
 
        output                  DqtEnable;
        output                  DqtTable;
        output [5:0]     DqtCount;
        output [7:0]     DqtData;
 
        output                  DhtEnable;
        output [1:0]     DhtTable;
        output [7:0]     DhtCount;
        output [7:0]     DhtData;
 
        //
        output                  HaffumanEnable;
        output [1:0]     HaffumanTable;
        output [3:0]     HaffumanCount;
        output [15:0]    HaffumanData;
        output [7:0]     HaffumanStart;
 
        //
        output                  ImageEnable;
        input                   ImageEnd;
        output                  EnableFF00;
 
        //
        output                  UseByte;
        output                  UseWord;
 
 
        //--------------------------------------------------------------------------
        // Read Maker from Jpeg Data
        //--------------------------------------------------------------------------
        reg [1:0]                State;
        reg [3:0]                Process;
        wire                    StateReadByte;
        wire                    StateReadWord;
        wire                    ImageEnable;
 
        wire                    ReadSegmentEnd;
 
        parameter               Idle            = 2'b00;
        parameter               GetMarker       = 2'b01;
        parameter               ReadSegment     = 2'b10;
        parameter               ImageData       = 2'b11;
 
        parameter               NoProcess       = 4'h0;
        parameter               SegSOI          = 4'h1;
        parameter               SegAPP          = 4'h2;
        parameter               SegDQT          = 4'h3;
        parameter               SegDHT          = 4'h4;
        parameter               SegSOF0         = 4'h5;
        parameter               SegSOS          = 4'h6;
        parameter               SegDRI          = 4'h7;
        parameter               SegRST          = 4'h8;
        parameter               SegEOI          = 4'h9;
 
        reg [15:0]               JpegWidth;
        reg [15:0]               JpegHeight;
 
        always @(posedge clk or negedge rst) begin
                if(!rst) begin
                        State           <= Idle;
                        Process         <= NoProcess;
                end else begin
                        case(State)
                                Idle: begin
                                        if(DataInEnable == 1'b1) begin
                                                State   <= GetMarker;
                                        end
                                        Process         <= NoProcess;
                                end
                                GetMarker: begin
                                        if(DataInEnable == 1'b1) begin
                                                State   <= ReadSegment;
                                                case(DataIn[31:16])
                                                16'hFFD8: begin         // SOI Segment
                                                        Process <= SegSOI;
                                                end
                                                16'hFFE0: begin         // APP0 Segment
                                                        Process <= SegAPP;
                                                end
                                                16'hFFDB: begin         // DQT Segment
                                                        Process <= SegDQT;
                                                end
                                                16'hFFC4: begin         // DHT Segment
                                                        Process <= SegDHT;
                                                end
                                                16'hFFC0: begin         // SOF0 Segment
                                                        Process <= SegSOF0;
                                                end
                                                16'hFFDA: begin         // SOS Segment
                                                        Process <= SegSOS;
                                                end
                                                //16'hFFDD: begin       // DRI Segment
                                                //      Process <= SegDRI;
                                                //end
                                                //16'hFFDx: begin       // RSTn Segment
                                                //      Process <= SegRST;
                                                //end
                                                //16'hFFD9: begin       // EOI Segment
                                                //      Process <= SegEOI;
                                                //end
                                                default: begin
                                                        Process <= SegAPP;
                                                end
                                                endcase
                                        end
                                end
                                ReadSegment: begin
                                        if(ReadSegmentEnd == 1'b1) begin
                                                Process <= NoProcess;
                                                if(Process == SegSOS) begin
                                                        State   <= ImageData;
                                                end else begin
                                                        State   <= GetMarker;
                                                end
                                        end
                                end
                                ImageData: begin
                                        if(OutEnable & (JpegWidth == OutPixelX +1) & (JpegHeight == OutPixelY +1)) begin
                                                State    <= Idle;
                                        end
                                end
                        endcase
                end
        end
 
        assign JpegDecodeIdle   = (State == Idle);
        assign StateReadByte    = 1'b0;
        assign StateReadWord    = ((State == GetMarker) & (DataInEnable == 1'b1));
        assign ImageEnable              = (State == ImageData);
 
        wire    ReadNopEnd;
 
        assign  ReadNopEnd = ((Process == SegSOI) | (Process == SegRST));
 
        //--------------------------------------------------------------------------
        // APP Segment
        // Skip read data!
        //--------------------------------------------------------------------------
 
        reg [1:0]        StateAPP;
        reg [15:0]       ReadAppCount;
        wire            ReadAppByte;
        wire            ReadAppWord;
        wire            ReadAppEnd;
 
        parameter       AppIdle         = 2'd0;
        parameter       AppLength       = 2'd1;
        parameter       AppRead         = 2'd2;
 
        always @(posedge clk or negedge rst) begin
                if(!rst) begin
                        StateAPP                <= AppIdle;
                        ReadAppCount    <= 16'd0;
                end else begin
                        case(StateAPP)
                                AppIdle: begin
                                        if(Process == SegAPP) StateAPP <= AppLength;
                                        ReadAppCount <= 16'd0;
                                end
                                AppLength: begin
                                        if(DataInEnable == 1'b1) begin
                                                ReadAppCount    <= DataIn[31:16] -2;
                                                StateAPP                <= AppRead;
                                        end
                                end
                                AppRead: begin
                                        if(DataInEnable == 1'b1) begin
                                                if(ReadAppCount == 1) begin
                                                        StateAPP                <= AppIdle;
                                                end else begin
                                                        ReadAppCount    <= ReadAppCount -1;
                                                end
                                        end
                                end
                        endcase
                end
        end
        assign ReadAppByte      = (StateAPP == AppRead);
        assign ReadAppWord      = (StateAPP == AppLength);
        assign ReadAppEnd       = ((StateAPP == AppRead) & (DataInEnable == 1'b1) & (ReadAppCount == 1));
 
        //--------------------------------------------------------------------------
        // DQT Segment
        //--------------------------------------------------------------------------
 
        reg [1:0]         StateDQT;
        reg [15:0]       ReadDqtCount;
        wire                    ReadDqtByte;
        wire                    ReadDqtWord;
        wire                    ReadDqtEnd;
        wire                    ReadDqtEnable;
        wire [7:0]       ReadDqtData;
        reg                      ReadDqtTable;
 
        parameter        DQTIdle        = 2'b00;
        parameter        DQTLength = 2'b01;
        parameter        DQTTable       = 2'b10;
        parameter        DQTRead        = 2'b11;
 
        always @(posedge clk or negedge rst) begin
                if(!rst) begin
                        StateDQT                <= DQTIdle;
                        ReadDqtCount    <= 16'h0000;
         ReadDqtTable   <= 1'b0;
                end else begin
                        case(StateDQT)
                                DQTIdle: begin
                                        if(Process == SegDQT) begin
                                                StateDQT <= DQTLength;
                                        end
                                        ReadDqtCount    <= 16'h0000;
                                end
                                DQTLength: begin
                                        if(DataInEnable == 1'b1) begin
                                                StateDQT                <= DQTTable;
                                                ReadDqtCount <= DataIn[31:16] -2;
                                        end
                                end
                                DQTTable: begin
                                        if(DataInEnable == 1'b1) begin
                                                StateDQT                <= DQTRead;
                                                ReadDqtTable <= DataIn[24];
                                                ReadDqtCount <= 16'd0;
                                        end
                                end
                                DQTRead: begin
                                        if(DataInEnable == 1'b1) begin
                                                if(ReadDqtCount ==63) begin
                                                        StateDQT                <= DQTIdle;
                                                end
                                                ReadDqtCount    <= ReadDqtCount +1;
                                        end
                                end
                        endcase
                end
        end
 
        assign ReadDqtEnable = StateDQT == DQTRead;
        assign ReadDqtData      = DataIn[31:24];
 
        assign ReadDqtByte = StateDQT == DQTRead | StateDQT == DQTTable;
        assign ReadDqtWord = StateDQT == DQTLength;
        assign ReadDqtEnd       = StateDQT == DQTRead & DataInEnable == 1'b1 & ReadDqtCount ==63;
 
        //--------------------------------------------------------------------------
        // DHT Segment
        //--------------------------------------------------------------------------
        reg [2:0]                StateDHT;
        reg [15:0]        ReadDhtCount;
        wire                     ReadDhtByte;
        wire                     ReadDhtWord;
        wire                     ReadDhtEnd;
        wire                     ReadDhtEnable;
        wire [7:0]        ReadDhtData;
        reg [1:0]                ReadDhtTable;
 
        reg [15:0]        HmShift;
        reg [15:0]        HmData;
        reg [7:0]                HmMax;
        reg [7:0]                HmCount;
        reg                             HmEnable;
 
        parameter               DHTIdle = 3'h0;
        parameter               DHTLength = 3'h1;
        parameter               DHTTable = 3'h2;
        parameter               DHTMakeHm0 = 3'h3;
        parameter               DHTMakeHm1 = 3'h4;
        parameter               DHTMakeHm2 = 3'h5;
        parameter               DHTReadTable = 3'h6;
 
        always @(posedge clk or negedge rst)
                begin
                        if(!rst) begin
                                StateDHT <= DHTIdle;
                                ReadDhtCount    <= 16'h0000;
                                ReadDhtTable    <= 2'b00;
                                HmEnable                <= 1'b0;
                                HmShift          <= 16'h8000;
                                HmData                  <= 16'h0000;
                                HmMax                   <= 8'h00;
                                HmCount          <= 8'h00;
                        end else begin // if (!rst)
                                case(StateDHT)
                                 DHTIdle: begin
                                         if(Process == SegDHT) begin
                                                 StateDHT <= DHTLength;
                                         end
                                         HmEnable               <= 1'b0;
                                 end
                                 DHTLength: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateDHT               <= DHTTable;
                                                 ReadDhtCount <= DataIn[31:16];
                                         end
                                 end
                                 DHTTable: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateDHT <= DHTMakeHm0;
                                                 case(DataIn[31:24])
                                                        8'h00: ReadDhtTable <= 2'b00;
                                                        8'h10: ReadDhtTable <= 2'b01;
                                                        8'h01: ReadDhtTable <= 2'b10;
                                                        8'h11: ReadDhtTable <= 2'b11;
                                                 endcase
                                         end
                                         HmShift <= 16'h8000;
                                         HmData <= 16'h0000;
                                         HmMax  <= 8'h00;
                                         ReadDhtCount <= 0;
                                 end // case: DHTTable
                                 DHTMakeHm0: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateDHT               <= DHTMakeHm1;
                                                 HmCount                <= DataIn[31:24];
                                         end
                                         HmEnable               <= 1'b0;
                                 end
                                 DHTMakeHm1: begin
                                         StateDHT <= DHTMakeHm2;
                                         HmMax   <= HmMax + HmCount;
                                 end
                                 DHTMakeHm2: begin
                                         if(HmCount != 0) begin
                                                 HmData <= HmData + HmShift;
                                                 HmCount <= HmCount -1;
                                         end else begin
                                                 if(ReadDhtCount == 15) begin
                                                         StateDHT <= DHTReadTable;
                                                         HmCount        <= 8'h00;
                                                         //HmMax         <= HmMax -1;
                                                 end else begin
                                                         HmEnable               <= 1'b1;
                                                         StateDHT               <= DHTMakeHm0;
                                                         ReadDhtCount <= ReadDhtCount +1;
                                                 end
                                                 HmShift <= HmShift >> 1;
                                         end
                                 end
                                 DHTReadTable: begin
                                         HmEnable               <= 1'b0;
                                         if(DataInEnable == 1'b1) begin
                                                 if(HmMax == HmCount +1) begin
                                                         StateDHT <= DHTIdle;
                                                 end
                                                 HmCount                                <= HmCount +1;
                                         end
                                 end
                                endcase
                        end
                end
 
        assign ReadDhtEnable = StateDHT == DHTReadTable;
        assign ReadDhtData      = DataIn[31:24];
 
        assign ReadDhtByte = StateDHT == DHTTable | StateDHT == DHTMakeHm0 |
                                                                StateDHT == DHTReadTable;
        assign ReadDhtWord = StateDHT == DHTLength;
        assign ReadDhtEnd       = StateDHT == DHTReadTable & DataInEnable == 1'b1 & HmMax == HmCount +1;
 
        //--------------------------------------------------------------------------
        // SOS Segment
        //--------------------------------------------------------------------------
        reg [3:0] StateSOS;
        reg [15:0] ReadSosCount;
        wire             ReadSosByte;
        wire             ReadSosWord;
        wire             ReadSosEnd;
 
        parameter       SOSIdle          = 4'h0;
        parameter       SOSLength               = 4'h1;
        parameter       SOSRead0                = 4'h2;
        parameter       SOSRead1                = 4'h3;
        parameter       SOSRead2                = 4'h4;
        parameter       SOSRead3                = 4'h5;
        parameter       SOSRead4                = 4'h6;
 
        reg                     EnableFF00;
 
        always @(posedge clk or negedge rst)
                begin
                        if(!rst) begin
                                StateSOS                        <= SOSIdle;
                                ReadSosCount     <= 16'h0000;
                EnableFF00              <= 1'b0;
                        end else begin
                                case(StateSOS)
                                 SOSIdle: begin
                                         if(Process == SegSOS) begin
                                                 StateSOS <= SOSLength;
                        EnableFF00 <= 1'b1;
                                         end
                                 end
                                 SOSLength: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOS               <= SOSRead0;
                                                 ReadSosCount <= DataIn[31:16];
                                         end
                                 end
                                 SOSRead0: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOS               <= SOSRead1;
                                                 ReadSosCount <= {8'h00,DataIn[31:24]};
                                         end
                                 end
                                 SOSRead1: begin
                                         if(DataInEnable == 1'b1) begin
                                                 if(ReadSosCount == 1) begin
                                                         StateSOS               <= SOSRead2;
                                                 end else begin
                                                         ReadSosCount <= ReadSosCount -1;
                                                 end
                                         end
                                 end
                                 SOSRead2: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOS                       <= SOSRead3;
                                         end
                                 end
                                 SOSRead3: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOS                       <= SOSRead4;
                                         end
                                 end
                                 SOSRead4: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOS                       <= SOSIdle;
                                         end
                                 end
                                endcase
                        end
                end
        assign ReadSosByte = StateSOS == SOSRead0 | StateSOS == SOSRead2 | StateSOS == SOSRead3 | StateSOS == SOSRead4;
        assign ReadSosWord = StateSOS == SOSLength | StateSOS == SOSRead1;
        assign ReadSosEnd       = DataInEnable == 1'b1 & StateSOS == SOSRead4;
 
        //--------------------------------------------------------------------------
        // SOF0 Segment
        //--------------------------------------------------------------------------
        reg [3:0] StateSOF;
        reg [15:0] ReadSofCount;
        wire             ReadSofByte;
        wire             ReadSofWord;
        wire             ReadSofEnd;
 
        reg [15:0] JpegBlockWidth;
        reg [15:0] JpegBlockHeight;
 
        parameter       SOFIdle          = 4'h0;
        parameter       SOFLength               = 4'h1;
        parameter       SOFRead0                = 4'h2;
        parameter       SOFReadY                = 4'h3;
        parameter       SOFReadX                = 4'h4;
        parameter       SOFReadComp     = 4'h5;
        parameter       SOFMakeBlock0 = 4'H6;
        parameter       SOFMakeBlock1 = 4'h7;
 
        always @(posedge clk or negedge rst)
                begin
                        if(!rst) begin
                                StateSOF                        <= SOFIdle;
                                ReadSofCount     <= 16'h0000;
                                JpegWidth                <= 16'h0000;
                                JpegHeight              <= 16'h0000;
                                JpegBlockWidth  <= 16'h0000;
                                JpegBlockHeight <= 16'h0000;
                        end else begin
                                case(StateSOF)
                                 SOFIdle: begin
                                         if(Process == SegSOF0) begin
                                                 StateSOF <= SOFLength;
                                         end
                                 end
                                 SOFLength: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOF               <= SOFRead0;
                                                 ReadSofCount <= DataIn[31:16];
                                         end
                                 end
                                 SOFRead0: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOF <= SOFReadY;
                                         end
                                 end
                                 SOFReadY: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOF                <= SOFReadX;
                                                 JpegHeight             <= DataIn[31:16];
                                                 JpegBlockHeight <= DataIn[31:16];
                                         end
                                 end
                                 SOFReadX: begin
                                         if(DataInEnable == 1'b1) begin
                                                 StateSOF                       <= SOFReadComp;
                                                 JpegWidth              <= DataIn[31:16];
                                                 JpegBlockWidth <= DataIn[31:16];
                                                 ReadSofCount    <= 16'h0000;
                                         end
                                 end
                                 SOFReadComp: begin
                                         if(DataInEnable == 1'b1) begin
                                                 if(ReadSofCount == 9) begin
                                                         StateSOF <= SOFMakeBlock0;
                                                 end else begin
                                                         ReadSofCount <= ReadSofCount +1;
                                                 end
                                         end
                                 end
                                 SOFMakeBlock0:begin
                                         StateSOF                       <= SOFMakeBlock1;
                                         JpegBlockWidth <= JpegBlockWidth       +15;
                                         JpegBlockHeight <= JpegBlockHeight +15;
                                 end
                                 SOFMakeBlock1:begin
                                         StateSOF                       <= SOFIdle;
                                         JpegBlockWidth <= JpegBlockWidth       >> 4;
                                         JpegBlockHeight <= JpegBlockHeight >> 4;
                                 end
                                endcase
                        end
                end
        assign ReadSofByte = StateSOF == SOFRead0 | StateSOF == SOFReadComp;
        assign ReadSofWord = StateSOF == SOFLength | StateSOF == SOFReadX | StateSOF == SOFReadY ;
        assign ReadSofEnd       = StateSOF == SOFMakeBlock1;
 
        assign OutWidth = JpegWidth;
        assign OutHeight = JpegHeight;
        assign          OutBlockWidth = JpegBlockWidth[11:0];
 
        //
        assign                  UseByte = DataInEnable == 1'b1 & (StateReadByte | ReadAppByte | ReadDqtByte | ReadDhtByte | ReadSosByte | ReadSofByte) ;
        assign                  UseWord = DataInEnable == 1'b1 & (StateReadWord | ReadAppWord | ReadDqtWord | ReadDhtWord | ReadSosWord | ReadSofWord) ;
        assign                  ReadSegmentEnd = ReadNopEnd | ReadAppEnd | ReadDqtEnd | ReadDhtEnd | ReadSosEnd | ReadSofEnd ;
 
        //
        assign          DqtEnable = ReadDqtEnable;
        assign          DqtTable        = ReadDqtTable;
        assign          DqtCount        = ReadDqtCount[5:0];
        assign          DqtData = ReadDqtData;
 
        //
        assign          DhtEnable = ReadDhtEnable;
        assign          DhtTable        = ReadDhtTable;
        assign          DhtCount        = HmCount;
        assign          DhtData = ReadDhtData;
 
        //
        assign          HaffumanEnable = HmEnable;
        assign          HaffumanTable   = ReadDhtTable;
        assign          HaffumanCount   = ReadDhtCount[3:0];
        assign          HaffumanData    = HmData;
        assign          HaffumanStart   = HmMax;
 
endmodule

Line No.	Rev	Author	Line
1	3	hidemi	`//---------------------------------------------------------------------------`
2	5	hidemi	`// File Name : jpeg_decode_fsm.v`
3			`// Module Name : jpeg_decode_fsm`
4			`// Description : Decode Maker`
5			`// Project : JPEG Decoder`
6			`// Belong to :`
7			`// Author : H.Ishihara`
8			`// E-Mail : hidemi@sweetcafe.jp`
9			`// HomePage : http://www.sweetcafe.jp/`
10			`// Date : 2007/04/11`
11			`// Rev. : 1.03`
12	3	hidemi	`//---------------------------------------------------------------------------`
13	5	hidemi	`// Rev. Date Description`
14	3	hidemi	`//---------------------------------------------------------------------------`
15			`// 1.01 2006/10/01 1st Release`
16			`// 1.02 2006/10/04 Remove a HmOldData register.`
17	5	hidemi	`// When reset, clear a ReadDqtTable register.`
18			`// 1.03 2007/04/11 Remove JpegDecodeStart`
19			`// Exchange StateMachine(Add ImageData)`
20			`// Remove JpegDecodeStart`
21	3	hidemi	`//---------------------------------------------------------------------------`
22			`// $Id:`
23			`//---------------------------------------------------------------------------`
24			`timescale 1ps / 1ps
25	5	hidemi
26	3	hidemi	`module jpeg_decode_fsm`
27	5	hidemi	`(`
28			`rst,`
29			`clk,`
30	3	hidemi
31	5	hidemi	`// From FIFO`
32			`DataInEnable,`
33			`DataIn,`
34	3	hidemi
35	5	hidemi	`JpegDecodeIdle, // Deocdeer Process Idle(1:Idle, 0:Run)`
36	3	hidemi
37	5	hidemi	`OutWidth,`
38			`OutHeight,`
39			`OutBlockWidth,`
40			`OutEnable,`
41			`OutPixelX,`
42			`OutPixelY,`
43
44			`//`
45			`DqtEnable,`
46			`DqtTable,`
47			`DqtCount,`
48			`DqtData,`
49	3	hidemi
50	5	hidemi	`//`
51			`DhtEnable,`
52			`DhtTable,`
53			`DhtCount,`
54			`DhtData,`
55	3	hidemi
56	5	hidemi	`//`
57			`HaffumanEnable,`
58			`HaffumanTable,`
59			`HaffumanCount,`
60			`HaffumanData,`
61			`HaffumanStart,`
62	3	hidemi
63	5	hidemi	`//`
64			`ImageEnable,`
65			`ImageEnd,`
66			`EnableFF00,`
67
68			`//`
69			`UseByte,`
70			`UseWord`
71			`);`
72	3	hidemi
73	5	hidemi	`input rst;`
74			`input clk;`
75	3	hidemi
76	5	hidemi	`input DataInEnable;`
77			`input [31:0] DataIn;`
78
79			`output JpegDecodeIdle;`
80	3	hidemi
81	5	hidemi	`output [15:0] OutWidth;`
82			`output [15:0] OutHeight;`
83			`output [11:0] OutBlockWidth;`
84			`input OutEnable;`
85			`input [15:0] OutPixelX;`
86			`input [15:0] OutPixelY;`
87
88			`output DqtEnable;`
89			`output DqtTable;`
90			`output [5:0] DqtCount;`
91			`output [7:0] DqtData;`
92	3	hidemi
93	5	hidemi	`output DhtEnable;`
94			`output [1:0] DhtTable;`
95			`output [7:0] DhtCount;`
96			`output [7:0] DhtData;`
97	3	hidemi
98	5	hidemi	`//`
99			`output HaffumanEnable;`
100			`output [1:0] HaffumanTable;`
101			`output [3:0] HaffumanCount;`
102			`output [15:0] HaffumanData;`
103			`output [7:0] HaffumanStart;`
104
105			`//`
106			`output ImageEnable;`
107			`input ImageEnd;`
108			`output EnableFF00;`
109
110			`//`
111			`output UseByte;`
112			`output UseWord;`
113	3	hidemi
114
115	5	hidemi	`//--------------------------------------------------------------------------`
116			`// Read Maker from Jpeg Data`
117			`//--------------------------------------------------------------------------`
118			`reg [1:0] State;`
119			`reg [3:0] Process;`
120			`wire StateReadByte;`
121			`wire StateReadWord;`
122			`wire ImageEnable;`
123	3	hidemi
124	5	hidemi	`wire ReadSegmentEnd;`
125	3	hidemi
126	5	hidemi	`parameter Idle = 2'b00;`
127			`parameter GetMarker = 2'b01;`
128			`parameter ReadSegment = 2'b10;`
129			`parameter ImageData = 2'b11;`
130	3	hidemi
131	5	hidemi	`parameter NoProcess = 4'h0;`
132			`parameter SegSOI = 4'h1;`
133			`parameter SegAPP = 4'h2;`
134			`parameter SegDQT = 4'h3;`
135			`parameter SegDHT = 4'h4;`
136			`parameter SegSOF0 = 4'h5;`
137			`parameter SegSOS = 4'h6;`
138			`parameter SegDRI = 4'h7;`
139			`parameter SegRST = 4'h8;`
140			`parameter SegEOI = 4'h9;`
141
142			`reg [15:0] JpegWidth;`
143			`reg [15:0] JpegHeight;`
144	3	hidemi
145	5	hidemi	`always @(posedge clk or negedge rst) begin`
146			`if(!rst) begin`
147			`State <= Idle;`
148			`Process <= NoProcess;`
149			`end else begin`
150			`case(State)`
151			`Idle: begin`
152			`if(DataInEnable == 1'b1) begin`
153			`State <= GetMarker;`
154			`end`
155			`Process <= NoProcess;`
156			`end`
157			`GetMarker: begin`
158			`if(DataInEnable == 1'b1) begin`
159			`State <= ReadSegment;`
160			`case(DataIn[31:16])`
161			`16'hFFD8: begin // SOI Segment`
162			`Process <= SegSOI;`
163			`end`
164			`16'hFFE0: begin // APP0 Segment`
165			`Process <= SegAPP;`
166			`end`
167			`16'hFFDB: begin // DQT Segment`
168			`Process <= SegDQT;`
169			`end`
170			`16'hFFC4: begin // DHT Segment`
171			`Process <= SegDHT;`
172			`end`
173			`16'hFFC0: begin // SOF0 Segment`
174			`Process <= SegSOF0;`
175			`end`
176			`16'hFFDA: begin // SOS Segment`
177			`Process <= SegSOS;`
178			`end`
179			`//16'hFFDD: begin // DRI Segment`
180			`// Process <= SegDRI;`
181			`//end`
182			`//16'hFFDx: begin // RSTn Segment`
183			`// Process <= SegRST;`
184			`//end`
185			`//16'hFFD9: begin // EOI Segment`
186			`// Process <= SegEOI;`
187			`//end`
188			`default: begin`
189			`Process <= SegAPP;`
190			`end`
191			`endcase`
192			`end`
193			`end`
194			`ReadSegment: begin`
195			`if(ReadSegmentEnd == 1'b1) begin`
196			`Process <= NoProcess;`
197			`if(Process == SegSOS) begin`
198			`State <= ImageData;`
199			`end else begin`
200			`State <= GetMarker;`
201			`end`
202			`end`
203			`end`
204			`ImageData: begin`
205			`if(OutEnable & (JpegWidth == OutPixelX +1) & (JpegHeight == OutPixelY +1)) begin`
206			`State <= Idle;`
207			`end`
208			`end`
209			`endcase`
210			`end`
211			`end`
212	3	hidemi
213	5	hidemi	`assign JpegDecodeIdle = (State == Idle);`
214			`assign StateReadByte = 1'b0;`
215			`assign StateReadWord = ((State == GetMarker) & (DataInEnable == 1'b1));`
216			`assign ImageEnable = (State == ImageData);`
217	3	hidemi
218	5	hidemi	`wire ReadNopEnd;`
219	3	hidemi
220	5	hidemi	`assign ReadNopEnd = ((Process == SegSOI) \| (Process == SegRST));`
221
222			`//--------------------------------------------------------------------------`
223			`// APP Segment`
224			`// Skip read data!`
225			`//--------------------------------------------------------------------------`
226	3	hidemi
227	5	hidemi	`reg [1:0] StateAPP;`
228			`reg [15:0] ReadAppCount;`
229			`wire ReadAppByte;`
230			`wire ReadAppWord;`
231			`wire ReadAppEnd;`
232	3	hidemi
233	5	hidemi	`parameter AppIdle = 2'd0;`
234			`parameter AppLength = 2'd1;`
235			`parameter AppRead = 2'd2;`
236
237			`always @(posedge clk or negedge rst) begin`
238			`if(!rst) begin`
239			`StateAPP <= AppIdle;`
240			`ReadAppCount <= 16'd0;`
241			`end else begin`
242			`case(StateAPP)`
243			`AppIdle: begin`
244			`if(Process == SegAPP) StateAPP <= AppLength;`
245			`ReadAppCount <= 16'd0;`
246			`end`
247			`AppLength: begin`
248			`if(DataInEnable == 1'b1) begin`
249			`ReadAppCount <= DataIn[31:16] -2;`
250			`StateAPP <= AppRead;`
251			`end`
252			`end`
253			`AppRead: begin`
254			`if(DataInEnable == 1'b1) begin`
255			`if(ReadAppCount == 1) begin`
256			`StateAPP <= AppIdle;`
257			`end else begin`
258			`ReadAppCount <= ReadAppCount -1;`
259			`end`
260			`end`
261			`end`
262			`endcase`
263			`end`
264			`end`
265			`assign ReadAppByte = (StateAPP == AppRead);`
266			`assign ReadAppWord = (StateAPP == AppLength);`
267			`assign ReadAppEnd = ((StateAPP == AppRead) & (DataInEnable == 1'b1) & (ReadAppCount == 1));`
268
269			`//--------------------------------------------------------------------------`
270			`// DQT Segment`
271			`//--------------------------------------------------------------------------`
272	3	hidemi
273	5	hidemi	`reg [1:0] StateDQT;`
274			`reg [15:0] ReadDqtCount;`
275			`wire ReadDqtByte;`
276			`wire ReadDqtWord;`
277			`wire ReadDqtEnd;`
278			`wire ReadDqtEnable;`
279			`wire [7:0] ReadDqtData;`
280			`reg ReadDqtTable;`
281	3	hidemi
282	5	hidemi	`parameter DQTIdle = 2'b00;`
283			`parameter DQTLength = 2'b01;`
284			`parameter DQTTable = 2'b10;`
285			`parameter DQTRead = 2'b11;`
286
287			`always @(posedge clk or negedge rst) begin`
288			`if(!rst) begin`
289			`StateDQT <= DQTIdle;`
290			`ReadDqtCount <= 16'h0000;`
291			`ReadDqtTable <= 1'b0;`
292			`end else begin`
293			`case(StateDQT)`
294			`DQTIdle: begin`
295			`if(Process == SegDQT) begin`
296			`StateDQT <= DQTLength;`
297			`end`
298			`ReadDqtCount <= 16'h0000;`
299			`end`
300			`DQTLength: begin`
301			`if(DataInEnable == 1'b1) begin`
302			`StateDQT <= DQTTable;`
303			`ReadDqtCount <= DataIn[31:16] -2;`
304			`end`
305			`end`
306			`DQTTable: begin`
307			`if(DataInEnable == 1'b1) begin`
308			`StateDQT <= DQTRead;`
309			`ReadDqtTable <= DataIn[24];`
310			`ReadDqtCount <= 16'd0;`
311			`end`
312			`end`
313			`DQTRead: begin`
314			`if(DataInEnable == 1'b1) begin`
315			`if(ReadDqtCount ==63) begin`
316			`StateDQT <= DQTIdle;`
317			`end`
318			`ReadDqtCount <= ReadDqtCount +1;`
319			`end`
320			`end`
321			`endcase`
322			`end`
323			`end`
324	3	hidemi
325	5	hidemi	`assign ReadDqtEnable = StateDQT == DQTRead;`
326			`assign ReadDqtData = DataIn[31:24];`
327
328			`assign ReadDqtByte = StateDQT == DQTRead \| StateDQT == DQTTable;`
329			`assign ReadDqtWord = StateDQT == DQTLength;`
330			`assign ReadDqtEnd = StateDQT == DQTRead & DataInEnable == 1'b1 & ReadDqtCount ==63;`
331	3	hidemi
332	5	hidemi	`//--------------------------------------------------------------------------`
333			`// DHT Segment`
334			`//--------------------------------------------------------------------------`
335			`reg [2:0] StateDHT;`
336			`reg [15:0] ReadDhtCount;`
337			`wire ReadDhtByte;`
338			`wire ReadDhtWord;`
339			`wire ReadDhtEnd;`
340			`wire ReadDhtEnable;`
341			`wire [7:0] ReadDhtData;`
342			`reg [1:0] ReadDhtTable;`
343	3	hidemi
344	5	hidemi	`reg [15:0] HmShift;`
345			`reg [15:0] HmData;`
346			`reg [7:0] HmMax;`
347			`reg [7:0] HmCount;`
348			`reg HmEnable;`
349	3	hidemi
350	5	hidemi	`parameter DHTIdle = 3'h0;`
351			`parameter DHTLength = 3'h1;`
352			`parameter DHTTable = 3'h2;`
353			`parameter DHTMakeHm0 = 3'h3;`
354			`parameter DHTMakeHm1 = 3'h4;`
355			`parameter DHTMakeHm2 = 3'h5;`
356			`parameter DHTReadTable = 3'h6;`
357
358			`always @(posedge clk or negedge rst)`
359			`begin`
360			`if(!rst) begin`
361			`StateDHT <= DHTIdle;`
362			`ReadDhtCount <= 16'h0000;`
363			`ReadDhtTable <= 2'b00;`
364			`HmEnable <= 1'b0;`
365			`HmShift <= 16'h8000;`
366			`HmData <= 16'h0000;`
367			`HmMax <= 8'h00;`
368			`HmCount <= 8'h00;`
369			`end else begin // if (!rst)`
370			`case(StateDHT)`
371			`DHTIdle: begin`
372			`if(Process == SegDHT) begin`
373			`StateDHT <= DHTLength;`
374			`end`
375			`HmEnable <= 1'b0;`
376			`end`
377			`DHTLength: begin`
378			`if(DataInEnable == 1'b1) begin`
379			`StateDHT <= DHTTable;`
380			`ReadDhtCount <= DataIn[31:16];`
381			`end`
382			`end`
383			`DHTTable: begin`
384			`if(DataInEnable == 1'b1) begin`
385			`StateDHT <= DHTMakeHm0;`
386			`case(DataIn[31:24])`
387			`8'h00: ReadDhtTable <= 2'b00;`
388			`8'h10: ReadDhtTable <= 2'b01;`
389			`8'h01: ReadDhtTable <= 2'b10;`
390			`8'h11: ReadDhtTable <= 2'b11;`
391			`endcase`
392			`end`
393			`HmShift <= 16'h8000;`
394			`HmData <= 16'h0000;`
395			`HmMax <= 8'h00;`
396			`ReadDhtCount <= 0;`
397			`end // case: DHTTable`
398			`DHTMakeHm0: begin`
399			`if(DataInEnable == 1'b1) begin`
400			`StateDHT <= DHTMakeHm1;`
401			`HmCount <= DataIn[31:24];`
402			`end`
403			`HmEnable <= 1'b0;`
404			`end`
405			`DHTMakeHm1: begin`
406			`StateDHT <= DHTMakeHm2;`
407			`HmMax <= HmMax + HmCount;`
408			`end`
409			`DHTMakeHm2: begin`
410			`if(HmCount != 0) begin`
411			`HmData <= HmData + HmShift;`
412			`HmCount <= HmCount -1;`
413			`end else begin`
414			`if(ReadDhtCount == 15) begin`
415			`StateDHT <= DHTReadTable;`
416			`HmCount <= 8'h00;`
417			`//HmMax <= HmMax -1;`
418			`end else begin`
419			`HmEnable <= 1'b1;`
420			`StateDHT <= DHTMakeHm0;`
421			`ReadDhtCount <= ReadDhtCount +1;`
422			`end`
423			`HmShift <= HmShift >> 1;`
424			`end`
425			`end`
426			`DHTReadTable: begin`
427			`HmEnable <= 1'b0;`
428			`if(DataInEnable == 1'b1) begin`
429			`if(HmMax == HmCount +1) begin`
430			`StateDHT <= DHTIdle;`
431			`end`
432			`HmCount <= HmCount +1;`
433			`end`
434			`end`
435			`endcase`
436			`end`
437			`end`
438	3	hidemi
439	5	hidemi	`assign ReadDhtEnable = StateDHT == DHTReadTable;`
440			`assign ReadDhtData = DataIn[31:24];`
441
442			`assign ReadDhtByte = StateDHT == DHTTable \| StateDHT == DHTMakeHm0 \|`
443			`StateDHT == DHTReadTable;`
444			`assign ReadDhtWord = StateDHT == DHTLength;`
445			`assign ReadDhtEnd = StateDHT == DHTReadTable & DataInEnable == 1'b1 & HmMax == HmCount +1;`
446	3	hidemi
447	5	hidemi	`//--------------------------------------------------------------------------`
448			`// SOS Segment`
449			`//--------------------------------------------------------------------------`
450			`reg [3:0] StateSOS;`
451			`reg [15:0] ReadSosCount;`
452			`wire ReadSosByte;`
453			`wire ReadSosWord;`
454			`wire ReadSosEnd;`
455	3	hidemi
456	5	hidemi	`parameter SOSIdle = 4'h0;`
457			`parameter SOSLength = 4'h1;`
458			`parameter SOSRead0 = 4'h2;`
459			`parameter SOSRead1 = 4'h3;`
460			`parameter SOSRead2 = 4'h4;`
461			`parameter SOSRead3 = 4'h5;`
462			`parameter SOSRead4 = 4'h6;`
463	3	hidemi
464	5	hidemi	`reg EnableFF00;`
465
466			`always @(posedge clk or negedge rst)`
467			`begin`
468			`if(!rst) begin`
469			`StateSOS <= SOSIdle;`
470			`ReadSosCount <= 16'h0000;`
471			`EnableFF00 <= 1'b0;`
472			`end else begin`
473			`case(StateSOS)`
474			`SOSIdle: begin`
475			`if(Process == SegSOS) begin`
476			`StateSOS <= SOSLength;`
477			`EnableFF00 <= 1'b1;`
478			`end`
479			`end`
480			`SOSLength: begin`
481			`if(DataInEnable == 1'b1) begin`
482			`StateSOS <= SOSRead0;`
483			`ReadSosCount <= DataIn[31:16];`
484			`end`
485			`end`
486			`SOSRead0: begin`
487			`if(DataInEnable == 1'b1) begin`
488			`StateSOS <= SOSRead1;`
489			`ReadSosCount <= {8'h00,DataIn[31:24]};`
490			`end`
491			`end`
492			`SOSRead1: begin`
493			`if(DataInEnable == 1'b1) begin`
494			`if(ReadSosCount == 1) begin`
495			`StateSOS <= SOSRead2;`
496			`end else begin`
497			`ReadSosCount <= ReadSosCount -1;`
498			`end`
499			`end`
500			`end`

Browse

Tools

Subversion Repositories djpeg

[/] [djpeg/] [trunk/] [src/] [jpeg_decode_fsm.v] - Blame information for rev 6