Introducing new parameters and other changes to implement raw data out.

//         3 - combine in window only

// [20] == 1 - set Bayer shift

// [19:18] Bayer shift

// [17:16] - unused

// WAS: [17:16] - unused

// [17] == 1 - set BE16 mode 

// [16]    0 - BE16 mode (1 - byte stream is little endian 16-bit, file is big endian 16 bits

// [15] == 1 - set single/multi frame mode

// [14]    0 - multiframe (compare frame numbers for 'suspend' output)

//         1 - single frame buffer

//          4 - mono, 4 blocks (but still not actual monochrome JPEG as the blocks are scanned in 2x2 macroblocks)

//          5 - jp4,  4 blocks, dc-improved

//          6 - jp4,  differential

//          7 - 15 - reserved

//          7 - jp4,  4 blocks, differential

//          8 - jp4,  4 blocks, differential, hdr

//          9 - jp4,  4 blocks, differential, divide by 2

//         10 - jp4,  4 blocks, differential, hdr,divide by 2

//         11 - mono JPEG (not yet implemented)

//         12-13 - RESERVED

//         14 - mono 4 blocks

//         15 - uncompressed

// [8:7] == 0,1 - NOP, 2 -   disable, 3 - enable subtracting of average value (DC component), bypassing DCT

// [6] == 1 - enable quantization bank select, 0 - disregard bits [5:3]

// [5:3] = quantization page number (0..7)

//         2 - enable compressor, compress single frame from memory (async)

//         3 - enable compressor, enable synchronous compression mode

// TODO WARNING: Switching to/from raw(uncompressed) mode requires stopping/restarting compressor!

module  cmprs_cmd_decode#(

        // Bit-fields in compressor control word

        parameter CMPRS_CBIT_CMODE_BITS =     4, // number of bits to control compressor color modes

        parameter CMPRS_CBIT_FRAMES =        15, // bit # to control compressor multi/single frame buffer modes

        parameter CMPRS_CBIT_FRAMES_BITS =    1, // number of bits to control compressor multi/single frame buffer modes

        parameter CMPRS_CBIT_BE16 =          17, // bit # to control compressor multi/single frame buffer modes

        parameter CMPRS_CBIT_BE16_BITS =      1, // number of bits to control compressor multi/single frame buffer modes

        parameter CMPRS_CBIT_BAYER =         20, // bit # to control compressor Bayer shift mode

        parameter CMPRS_CBIT_BAYER_BITS =     2, // number of bits to control compressor Bayer shift mode

        parameter CMPRS_CBIT_FOCUS =         23, // bit # to control compressor focus display mode

//      parameter CMPRS_CBIT_RUN_DISABLE =    2'h1, // disable compression of the new frames, finish any already started

        parameter CMPRS_CBIT_RUN_STANDALONE = 2'h2, // enable compressor, compress single frame from memory (async)

        parameter CMPRS_CBIT_RUN_ENABLE =     2'h3, // enable compressor, enable synchronous compression mode

        parameter CMPRS_CBIT_CMODE_JPEG18 =   4'h0, // color 4:2:0

        parameter CMPRS_CBIT_CMODE_MONO6 =    4'h1, // mono 4:2:0 (6 blocks)

        parameter CMPRS_CBIT_CMODE_JP46 =     4'h2, // jp4, 6 blocks, original

        parameter CMPRS_CBIT_CMODE_JP4DIFFHDRDIV2 = 4'ha, // jp4,  4 blocks, differential, hdr,divide by 2

        parameter CMPRS_CBIT_CMODE_MONO1 =    4'hb, // mono JPEG (not yet implemented)

        parameter CMPRS_CBIT_CMODE_MONO4 =    4'he, // mono 4 blocks

        parameter CMPRS_CBIT_CMODE_RAW =      4'hf, // uncompressed

        parameter CMPRS_CBIT_FRAMES_SINGLE =  0, //1, // use a single-frame buffer for images

        parameter CMPRS_COLOR18 =             0, // JPEG 4:2:0 with 18x18 overlapping tiles for de-bayer

        parameter CMPRS_MONO16 =              2, // JPEG 4:2:0 with 16x16 non-overlapping tiles, color components zeroed

        parameter CMPRS_JP4 =                 3, // JP4 mode with 16x16 macroblocks

        parameter CMPRS_JP4DIFF =             4, // JP4DIFF mode TODO: see if correct

        parameter CMPRS_RAW =                 6, // Not comressed, raw data

        parameter CMPRS_MONO8 =               7, // Regular JPEG monochrome with 8x8 macroblocks (not yet implemented)

        parameter CMPRS_FRMT_MBCM1 =           0, // bit # of number of macroblock columns minus 1 field in format word

        parameter CMPRS_CSAT_CR_BITS =        10, // number of bits in red scale field in color saturation word

        parameter CMPRS_CORING_BITS =          3 // number of bits in coring mode

        //parameter CMPRS_STUFFER_NEG =          1  // stuffer runs @ negedge xclk2x

)(

//    input                         rst,

    input                         xclk,               // global clock input, compressor single clock rate

    input                         mclk,               // global system/memory clock

    input                         mrst,      // @posedge mclk, sync reset

    input                         color_sat_we,       // input - @mclk write color saturation values

    input                         coring_we,          // input - @mclk write coring values

//                    rs,      // 0 - bit modes,

//                           // 1 - write ntiles;

    input                  [31:0] di,     // [15:0] data from CPU (sync to negedge sclk)

//                    cr_w,   // data written to cr (1 cycle long) - just to reset legacy IRQ

//                    ntiles,//[17:0] - number of tiles in a frame to process

    input                         frame_start,        // @mclk

    output                        frame_start_xclk,   // frame start, parameters are copied at this pulse

    output reg                    sigle_frame_buf,    // memory controller uses a single frame buffer (frame_number_* == 0), use other sync

                                  //  outputs sync @ posedge xclk:

    output reg                    cmprs_en_xclk,      // enable compressor, turn off immedaitely

    output reg                    cmprs_en_late_xclk, // enable stuffer, extends control fields for graceful shutdown

//                    cmprs_start, // single cycle when single or constant compression is turned on

//                    cmprs_repeat,// high in repetitive mode

    output reg                    cmprs_en_xclk_jp,      // enable compressor, turn off immedaitely

    output reg                    cmprs_en_xclk_raw,      // enable compressor, turn off immedaitely

    output reg                    cmprs_en_late_xclk, // enable stuffer, extends control fields for graceful shutdown (should be for raw also?)

                                  // outputs @posedge xclk, frozen when the new frame is requested

    output reg             [ 2:0] cmprs_qpage, // [2:0] - quantizator page number (0..7)

    output reg                    cmprs_dcsub, // subtract dc level before DCT, restore later

//    output reg             [ 3:0] cmprs_mode,  // [3:0] - compressor mode

//                    cmprs_shift, // tile shift from top left corner

    output reg             [ 1:0] cmprs_fmode, //[1:0] - focus mode

    output reg             [ 1:0] bayer_shift, // additional shift to bayer mosaic

    output reg [CMPRS_CSAT_CB_BITS-1:0] color_sat_cb,    // scale for Cb color component (color saturation)

    output reg [CMPRS_CSAT_CR_BITS-1:0] color_sat_cr,    // scale for Cr color component (color saturation)

    output reg [CMPRS_CORING_BITS-1:0]  coring           // scale for Cb color component (color saturation)

    output reg [CMPRS_CORING_BITS-1:0]  coring,           // scale for Cb color component (color saturation)

    output reg                    uncompressed,

    output reg                    be16

    );

//    input                         is_compressing, // high from start of compressing till EOT (sync to posedge clk)

//                    abort_compress,

 //   input                         stuffer_done_mclk,

//    output reg                    force_flush); // abort compress - generate flush pulse, force end of image over DMA, update counter

    reg   [30:0]  di_r;

    reg           ctrl_we_r;

    reg   [23:0] color_sat_xclk; // color saturation values (only 10 LSB in each 12 are used

    reg   [ 2:0] coring_xclk; // color saturation values (only 10 LSB in each 12 are used

//    wire         frame_start_xclk;

    wire         uncompressed_mclk;

    assign cmprs_en_mclk = cmprs_en_mclk_r;

    assign uncompressed_mclk = cmprs_mode_mclk[3:0] == CMPRS_CBIT_CMODE_RAW;

    always @ (posedge mclk) begin

        if (mrst) ctrl_we_r <= 0;

        else if (ctrl_we_r && di_r[CMPRS_CBIT_RUN]) cmprs_run_mclk <= (di_r[CMPRS_CBIT_RUN-1 -:CMPRS_CBIT_RUN_BITS] == CMPRS_CBIT_RUN_ENABLE);

        if      (mrst)      cmprs_standalone <= 0;

//        else if (ctrl_we_r) cmprs_standalone <=  ctrl_we_r && di_r[CMPRS_CBIT_RUN] && (di_r[CMPRS_CBIT_RUN-1 -:CMPRS_CBIT_RUN_BITS] == CMPRS_CBIT_RUN_STANDALONE);

        else cmprs_standalone <=  ctrl_we_r && di_r[CMPRS_CBIT_RUN] && (di_r[CMPRS_CBIT_RUN-1 -:CMPRS_CBIT_RUN_BITS] == CMPRS_CBIT_RUN_STANDALONE);

        if      (mrst)                                 sigle_frame_buf <= 0;

        else if (ctrl_we_r && di_r[CMPRS_CBIT_FRAMES]) sigle_frame_buf <= (di_r[CMPRS_CBIT_FRAMES-1 -:CMPRS_CBIT_FRAMES_BITS] == CMPRS_CBIT_FRAMES_SINGLE);

        if      (mrst)                                 be16 <= 0;

        else if (ctrl_we_r && di_r[CMPRS_CBIT_BE16])   be16 <= (di_r[CMPRS_CBIT_BE16-1 -:CMPRS_CBIT_BE16_BITS] == 1);

        if      (mrst)                                 cmprs_qpage_mclk <= 0;

        else if (ctrl_we_r && di_r[CMPRS_CBIT_QBANK])  cmprs_qpage_mclk <= di_r[CMPRS_CBIT_QBANK-1 -:CMPRS_CBIT_QBANK_BITS];

    always @ (posedge xclk)  begin

        cmprs_en_xclk   <=      cmprs_en_mclk_r;

        cmprs_en_late_xclk  <=  cmprs_en_mclk_r || cmprs_en_extend;

        if      (!cmprs_en_mclk_r) cmprs_en_xclk_jp <= 0;

        else if (ctrl_we_xclk)     cmprs_en_xclk_jp <= cmprs_en_mclk_r && !uncompressed_mclk;

        if      (!cmprs_en_mclk_r) cmprs_en_xclk_raw <= 0;

        else if (ctrl_we_xclk)     cmprs_en_xclk_raw <= cmprs_en_mclk_r && uncompressed_mclk;

    end    

    always @ (posedge xclk) if (ctrl_we_xclk) begin

//        cmprs_en_late_xclk  <=  cmprs_en_mclk_r || cmprs_en_extend;

        cmprs_qpage_xclk <=     cmprs_qpage_mclk;

        cmprs_dcsub_xclk <=     cmprs_dcsub_mclk;

        cmprs_mode_xclk <=      cmprs_mode_mclk;

                jp4_dc_improved  <= 0;

                converter_type[2:0] <= CMPRS_MONO8; // 0 - color18, 1 - color20, 2 - mono, 3 - jp4, 4 - jp4-diff

              end

            CMPRS_CBIT_CMODE_RAW:   begin // uncompressed

                converter_type[2:0] <= CMPRS_RAW;   // 0 - color18, 1 - color20, 2 - mono, 3 - jp4, 4 - jp4-diff

              end

            default: begin // 

                ignore_color     <=    'bx;

                four_blocks      <=    'bx;

                converter_type[2:0] <= 'bx;

              end

       endcase

       uncompressed <= cmprs_mode_xclk[3:0] == CMPRS_CBIT_CMODE_RAW;

    end

    parameter CMPRS_TIMEOUT=                   1000   // mclk cycles

)(

//    input                         rst,

    input                         xclk,               // global clock input, compressor single clock rate

    input                         mclk,               // global system/memory clock

    input                         mrst,               // @posedge mclk, sync reset

    output reg                    force_flush_long,    // force flush (abort frame), can be any clock and may last until stuffer_done_mclk

                                                      // stuffer will re-clock and extract 0->1 transition

    output                        stuffer_running_mclk,

    output                        reading_frame,

    output                        reading_frame,      // @mclk

    output                        frame_started_mclk  // use to store frame number

);

/*

 TODO: Simplify logic: instead of frame_start_pend_r - copy frame_number_srtc @ vsync_late, and start frame if it is not reading,

 in "run" mode, and frame_number_differ (in multi-frame mode)

*/

//    wire   vsync_late_mclk; // single mclk cycle, reclocked from vsync_late

//    wire   frame_started_mclk; 

    reg        bonded_mode;

    reg  [5:0] frame_start_dst_r;

    reg        frame_start_pend_r; // postpone frame_start_dst if previous frame was still being read during vsync_late 

    reg        line_numbers_sync;      // src unfinished line number is > this unfinished line number

    reg        reading_frame_r;         // compressor is reading frame data (make sure input is done before starting next frame, otherwise make it a broken frame

//  reg        broken_frame;

    reg        aborted_frame;

    reg        stuffer_running_mclk_r;

    reg [CMPRS_TIMEOUT_BITS-1:0] timeout;

    reg        cmprs_en_extend_r=0;

    reg        cmprs_en_d;

    reg        suspend_end; // suspend at the end of the current frame until frame number changes

//    reg    cmprs_en_xclk;

    wire      last_mb_started_mclk;

    assign frame_start_dst = frame_start_dst_r[0];

    assign cmprs_en_extend = cmprs_en_extend_r;

    assign stuffer_running_mclk = stuffer_running_mclk_r;

    assign reading_frame =        reading_frame_r;

//    always @ (posedge xclk) begin

//        cmprs_en_xclk <=cmprs_en;

//    end

    always @ (posedge mclk) begin

        if       (mrst)                                       cmprs_en_extend_r <= 0;

        else if  (cmprs_en)                                   cmprs_en_extend_r <= 1;

        cmprs_en_d <= cmprs_en;

//     broken_frame <=  cmprs_en && cmprs_run && vsync_late && reading_frame_r; // single xclk pulse

        aborted_frame <= cmprs_en_d && !cmprs_en && stuffer_running_mclk_r;

        if      (!stuffer_running_mclk_r ||!cmprs_en_extend_r) force_flush_long <= 0;

//     else if (broken_frame || aborted_frame)                force_flush_long <= 1;

        else if (aborted_frame)                                force_flush_long <= 1;

//     if (!cmprs_en || frame_done || (cmprs_run && vsync_late)) reading_frame_r <= 0;

//     last_mb_start[2] is used as emergency turn off reading_frame if memory channel did not generate frame_done (i.e. wrong frame height)

// TODO: Consider the opposite - frame_done, but not got the last MB?

        if (!cmprs_en || frame_done || last_mb_started_mclk)      reading_frame_r <= 0;

        else if (frame_started_mclk)                              reading_frame_r <= 1;

//        if      (!cmprs_run || frame_start_dst_r[0])                             frame_start_pend_r <= 0;

        if      (!cmprs_run || frame_start_conf)                                 frame_start_pend_r <= 0;

        else if ((cmprs_run && vsync_late && reading_frame_r) ||

                 (frame_start_dst_r[5] && bonded_mode && frames_numbers_differ)) frame_start_pend_r <= 1;

  //      else if (frame_start_dst_r[0])                        frame_start_pend_r <= 0;

        // If started frame differs from tghe source one, needs to comrfess next frame after this is done, without vsync_late

//        else if (frame_start_dst_r[5] )                        frame_start_pend_r <= bonded_mode && frames_numbers_differ;

//        if      (!cmprs_en)            suspend_end <= 0;

        if      (!cmprs_run)           suspend_end <= 0;

        else if (frame_done)           suspend_end <= 1;

        else if (frame_start_dst_r[3]) suspend_end <= 0;

                                             cmprs_standalone);

        // modified - now bit 0 is disconnected from 1..5, 1 gets from memory channel controller, may be delayed                                             

        if      (!cmprs_en)   frame_start_dst_r[5:1] <=0;

//        else                  frame_start_dst_r[5:1] <= frame_start_dst_r[4:0];                                             

        else                  frame_start_dst_r[5:1] <= {frame_start_dst_r[4:1],frame_start_conf};                                             

        if      (!cmprs_en)        bonded_mode <= 0;

        frames_numbers_differ <= !suspend_end && (frame_number_src != frame_number); // during end of frame, before frame number is incremented

///        line_numbers_sync <= (line_unfinished_src > line_unfinished);

        line_numbers_sync <= (line_unfinished_src >= line_unfinished);

        suspend <= bonded_mode && (!frames_in_sync || !((sigle_frame_buf ? frames_differ : frames_numbers_differ) || line_numbers_sync));

    end

//    pulse_cross_clock vsync_late_mclk_i (.rst(xrst), .src_clk(xclk), .dst_clk(mclk), .in_pulse(cmprs_en_xclk && vsync_late), .out_pulse(vsync_late_mclk),.busy());

    pulse_cross_clock frame_started_i   (.rst(xrst), .src_clk(xclk), .dst_clk(mclk), .in_pulse(frame_started), .out_pulse(frame_started_mclk),.busy());

    pulse_cross_clock last_mb_started_i (.rst(xrst), .src_clk(xclk), .dst_clk(mclk), .in_pulse(last_mb_started), .out_pulse(last_mb_started_mclk),.busy());

    reg    [ 2:0] mb_col_number; // number of tile column where macrobloc starts - valid 2 cycles before mb_pre_start

    wire   [ 9:0] extra_start_addr_w = mb_col_number * mb_h_m1; //added to mb_start_addr when non-zero column

    reg    [ 5:0] extra_start_addr_r;

//    reg    [ 5:0] mb_h;          // macroblock height (lost MSB - OK)

    reg    [ 9:0] mb_start_addr; // was macroblock_x, noccrected for multi-column. valid with mb_pre_start

    assign buf_ra = bufa_r;

    assign mb_pre_end =        mb_pre_end_r;

    assign mb_release_buf =    mb_release_buf_r;

    assign buf_rd =            buf_re[1:0];

//    assign data_out =          do_r;

    assign pre_first_out =     pre_first_out_r[0];

    assign pre2_first_out =    pre_first_out_r[1];

`ifdef DEBUG_COMPRESSOR_SCRAMBLE

`endif

    always @(posedge xclk) begin

//        mb_h <= mb_h_m1+1;     // macroblock height

        mb_col_number <= {macroblock_x[6:5],tile_col_width?1'b0:macroblock_x[4]};

        extra_start_addr_r <= extra_start_addr_w[5:0];

        mb_start_addr <= {3'b0,macroblock_x} + {extra_start_addr_r,4'b0};

//mb_pre_start        

        if (!frame_en) pre_first_out_r <= 0;

        else           pre_first_out_r <= {mb_pre_start, pre_first_out_r[CMPRS_BUF_EXTRA_LATENCY + 2 : 1]}; 

//        else pre_first_out_r <= buf_re[CMPRS_BUF_EXTRA_LATENCY+1] && ! buf_re[CMPRS_BUF_EXTRA_LATENCY+2];

//        if (!frame_en) pre2_first_out <= 0;

//        else           pre2_first_out <= buf_re[CMPRS_BUF_EXTRA_LATENCY + 0] && ! buf_re[CMPRS_BUF_EXTRA_LATENCY + 1];

        if      (mb_pre_start) rows_left <= mb_h_m1;

        else if (last_col)     rows_left <= rows_left - 1;

        if      (!frame_en)     buf_re[CMPRS_BUF_EXTRA_LATENCY+2:1] <= 0;

//        if (buf_re[0]) last_col <= 0; // ????

        if (!buf_re[0]) last_col <= 0;

        else            last_col <= (cols_left == 1);

//        if     (buf_re[0]) last_row <= 0;

        if    (!buf_re[0]) last_row <= 0;

        else if (last_col) last_row <= (rows_left == 1);

        first_col <= (mb_pre_start || (last_col && !last_row));

//        if   (mb_pre_start) row_sa <= {start_page,3'b0,mb_start_addr}; // macroblock_x};

        if   (mb_pre_start) row_sa <= {start_page,mb_start_addr}; // macroblock_x};

        else if (first_col) row_sa <= row_sa + (tile_col_width ? 12'h20:12'h10);

        else if (last_in_tile)          bufa_r[11:10] <= bufa_r[11:10] + 1;

        // Most time critical - calculation of the buffer address

//        if  (mb_pre_start)              bufa_r[9:0] <= {3'b0,mb_start_addr}; // macroblock_x};

        if  (mb_pre_start)              bufa_r[9:0] <= {mb_start_addr}; // macroblock_x};

        else if (last_col)              bufa_r[9:0] <= row_sa[9:0]; // 'bx next cycle after AFTER mb_pre_start

        else if (last_in_tile)          bufa_r[9:0] <= tile_sa;

        parameter CMPRS_CBIT_CMODE_BITS =      4, // number of bits to control compressor color modes

        parameter CMPRS_CBIT_FRAMES =         15, // bit # to control compressor multi/single frame buffer modes

        parameter CMPRS_CBIT_FRAMES_BITS =     1, // number of bits to control compressor multi/single frame buffer modes

        parameter CMPRS_CBIT_BE16 =           17, // bit # to control compressor multi/single frame buffer modes

        parameter CMPRS_CBIT_BE16_BITS =       1, // number of bits to control compressor multi/single frame buffer modes

        parameter CMPRS_CBIT_BAYER =          20, // bit # to control compressor Bayer shift mode

        parameter CMPRS_CBIT_BAYER_BITS =      2, // number of bits to control compressor Bayer shift mode

        parameter CMPRS_CBIT_FOCUS =          23, // bit # to control compressor focus display mode

        parameter CMPRS_CBIT_CMODE_JP4DIFFHDRDIV2 = 4'ha, // jp4,  4 blocks, differential, hdr,divide by 2

        parameter CMPRS_CBIT_CMODE_MONO1 =     4'hb, // mono JPEG (not yet implemented)

        parameter CMPRS_CBIT_CMODE_MONO4 =     4'he, // mono 4 blocks

        parameter CMPRS_CBIT_CMODE_RAW =       4'hf, // uncompressed

        parameter CMPRS_CBIT_FRAMES_SINGLE =   0, //1, // use a single-frame buffer for images

        parameter CMPRS_COLOR18 =              0, // JPEG 4:2:0 with 18x18 overlapping tiles for de-bayer

        parameter CMPRS_MONO16 =               2, // JPEG 4:2:0 with 16x16 non-overlapping tiles, color components zeroed

        parameter CMPRS_JP4 =                  3, // JP4 mode with 16x16 macroblocks

        parameter CMPRS_JP4DIFF =              4, // JP4DIFF mode TODO: see if correct

        parameter CMPRS_RAW =                  6, // Not comressed, raw data

        parameter CMPRS_MONO8 =                7, // Regular JPEG monochrome with 8x8 macroblocks (not yet implemented)

        parameter CMPRS_FRMT_MBCM1 =           0, // bit # of number of macroblock columns minus 1 field in format word

                .CMPRS_CBIT_CMODE_BITS           (CMPRS_CBIT_CMODE_BITS),

                .CMPRS_CBIT_FRAMES               (CMPRS_CBIT_FRAMES),

                .CMPRS_CBIT_FRAMES_BITS          (CMPRS_CBIT_FRAMES_BITS),

                .CMPRS_CBIT_BE16                 (CMPRS_CBIT_BE16),

                .CMPRS_CBIT_BE16_BITS            (CMPRS_CBIT_BE16_BITS),        

                .CMPRS_CBIT_BAYER                (CMPRS_CBIT_BAYER),

                .CMPRS_CBIT_BAYER_BITS           (CMPRS_CBIT_BAYER_BITS),

                .CMPRS_CBIT_FOCUS                (CMPRS_CBIT_FOCUS),

                .CMPRS_CBIT_CMODE_JP4DIFFHDRDIV2 (CMPRS_CBIT_CMODE_JP4DIFFHDRDIV2),

                .CMPRS_CBIT_CMODE_MONO1          (CMPRS_CBIT_CMODE_MONO1),

                .CMPRS_CBIT_CMODE_MONO4          (CMPRS_CBIT_CMODE_MONO4),

                .CMPRS_CBIT_CMODE_RAW            (CMPRS_CBIT_CMODE_RAW),

                .CMPRS_CBIT_FRAMES_SINGLE        (CMPRS_CBIT_FRAMES_SINGLE),

                .CMPRS_COLOR18                   (CMPRS_COLOR18),

                .CMPRS_COLOR20                   (CMPRS_COLOR20),

                .CMPRS_MONO16                    (CMPRS_MONO16),

                .CMPRS_JP4                       (CMPRS_JP4),

                .CMPRS_JP4DIFF                   (CMPRS_JP4DIFF),

                .CMPRS_RAW                       (CMPRS_RAW),

                .CMPRS_MONO8                     (CMPRS_MONO8),

                .CMPRS_FRMT_MBCM1                (CMPRS_FRMT_MBCM1),

                .CMPRS_FRMT_MBCM1_BITS           (CMPRS_FRMT_MBCM1_BITS),

 * @date 2015-10-26  

 * @author Andrey Filippov     

 *

 * @brief Wrapper fior several JPEG/JP4 compression modules. It includes

 * @brief Wrapper for several JPEG/JP4 compression modules. It includes

 * - Huffman encoder (huffman_snglclk),

 * - bit stuffer (bit_stuffer_27_32),

 * - escapes 0xff with 0x00 (bit_stuffer_escape)

// and before the data is needed for output 

    input              ts_pre_stb,  // @mclk - 1 cycle before receiving 8 bytes of timestamp data

    input        [7:0] ts_data,     // timestamp data (s0,s1,s2,s3,us0,us1,us2,us3==0)

//TODO: Should be generated fro raw also    

    input              color_first, // @fradv_clk only used for timestamp 

    // outputs @ negedge clk

    output      [31:0] data_out,      // [31:0] output data

        .flush_out    (escape_flush_out)   // output reg 

    );

    bit_stuffer_metadata bit_stuffer_metadata_i (

// TODO: Insert raw data here, always 4x bytes (actually 16*16*(1..2))

    bit_stuffer_raw_metadata bit_stuffer_metadata_i (

        .mclk           (mclk),               // input

        .mrst           (mrst),               // input

        .xclk           (xclk),               // input