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

Subversion Repositories mdct

[/] [mdct/] [trunk/] [source/] [testbench/] [INPIMAGE.VHD] - Blame information for rev 24

Details | Compare with Previous | View Log


--------------------------------------------------------------------------------
--                                                                            --
--                          V H D L    F I L E                                --
--                          COPYRIGHT (C) 2006                                --
--                                                                            --
--------------------------------------------------------------------------------
--
-- Title       : INPIMAGE
-- Design      : MDCT Core
-- Author      : Michal Krepa
--
--------------------------------------------------------------------------------
-- File        : INPIMAGE.VHD
-- Created     : Sat Mar 12 2006
--
--------------------------------------------------------------------------------
--
--  Description : 1D Discrete Cosine Transform TB stimulator and results compare
--
--------------------------------------------------------------------------------
library IEEE;
  use IEEE.STD_LOGIC_1164.all;
  use ieee.numeric_std.all;
  use IEEE.STD_LOGIC_TEXTIO.all;
 
library STD;
  use STD.TEXTIO.all;
 
library WORK;
  use WORK.MDCT_PKG.all;
  use WORK.MDCTTB_PKG.all;
  use WORK.RNG.all;
 
entity INPIMAGE is
  port (
        clk               : in STD_LOGIC;
        odv1              : in STD_LOGIC;
        dcto1             : in STD_LOGIC_VECTOR(OP_W-1 downto 0);
        odv               : in STD_LOGIC;
        dcto              : in STD_LOGIC_VECTOR(COE_W-1 downto 0);
 
        rst               : out STD_LOGIC;
        imageo            : out STD_LOGIC_VECTOR(IP_W-1 downto 0);
        dv                : out STD_LOGIC;
        testend           : out BOOLEAN
       );
end INPIMAGE;
 
--**************************************************************************--
 
architecture SIM of INPIMAGE is
 
  constant PERIOD             : TIME := 1 us /(CLK_FREQ_C);
 
  signal rst_s                : STD_LOGIC;
  signal test_inp             : INTEGER;
  signal test_stim            : INTEGER;
  signal test_out             : INTEGER;
  signal xcon_s               : INTEGER;
  signal ycon_s               : INTEGER;
  signal error_dct_matrix_s   : I_MATRIX_TYPE;
  signal error_dcto1_matrix_s : I_MATRIX_TYPE;
  signal imageo_s             : STD_LOGIC_VECTOR(IP_W-1 downto 0);
  signal dv_s                 : STD_LOGIC;
 
begin
 
  rst  <= rst_s after HOLD_TIME;
 
  imageo <= imageo_s after HOLD_TIME;
  dv     <= dv_s after HOLD_TIME;
 
 --------------------------
 -- input image stimuli
 --------------------------
 INPIMAGE_PROC: process
   variable i : INTEGER   := 0;
   variable j : INTEGER   := 0;
   variable INSERT_DELAYS : BOOLEAN := FALSE;
   variable unf:        Uniform  := InitUniform(7, 0.0, 2.0);
        variable rnd:   real     := 0.0;
        variable xi            : INTEGER := 0;
 
  -------------------------------------
  -- wait for defined number of clock cycles
  -------------------------------------
  procedure waitposedge(clocks : in INTEGER) is
  begin
    for i in 1 to clocks loop
      wait until clk='1' and clk'event;
    end loop;
  end waitposedge;
 
  -------------------------------------
  -- wait on clock rising edge
  -------------------------------------
  procedure waitposedge is
  begin
    wait until clk='1' and clk'event;
  end waitposedge;
 
  --------------------------------------
  -- read text image data
  --------------------------------------
  procedure read_image is
    file infile          : TEXT open read_mode is FILEIN_NAME_C;
    variable inline      : LINE;
    variable tmp_int     : INTEGER := 0;
    variable y_size      : INTEGER := 0;
    variable x_size      : INTEGER := 0;
    variable x_blocks8   : INTEGER := 0;
    variable y_blocks8   : INTEGER := 0;
    variable matrix      : I_MATRIX_TYPE;
    variable x_blk_cnt   : INTEGER := 0;
    variable y_blk_cnt   : INTEGER := 0;
    variable n_lines_arr : N_LINES_TYPE;
    variable line_n      : INTEGER := 0;
    variable pix_n       : INTEGER := 0;
    variable x_n         : INTEGER := 0;
    variable y_n         : INTEGER := 0;
  begin
    READLINE(infile,inline);
    READ(inline,y_size);
    READLINE(infile,inline);
    READ(inline,x_size);
 
    y_blocks8 := y_size / N;
    x_blocks8 := x_size / N;
 
    assert MAX_IMAGE_SIZE_X > x_size
      report "E02: Input image x size exceeds maximum value!"
      severity Failure;
 
    if y_size rem N > 0 then
      assert false
        report "E03: Image height dimension is not multiply of N!"
        severity Failure;
    end if;
    if x_size rem N > 0 then
      assert false
        report "E03: Image width dimension is not multiply of N!"
        severity Failure;
    end if;
 
    for y_blk_cnt in 0 to y_blocks8-1 loop
 
      -- read N input lines and store them to buffer
      for y_n in 0 to N-1 loop
        READLINE(infile,inline);
        HREAD(inline,n_lines_arr(y_n)(0 to x_size*IP_W-1));
      end loop;
      y_n := 0;
 
      for x_blk_cnt in 0 to x_blocks8-1 loop
        for y_n in 0 to N-1 loop
          for x_n in 0 to N-1 loop
            matrix(y_n,x_n) := TO_INTEGER(UNSIGNED(
                n_lines_arr(y_n)
                    ((x_blk_cnt*N+x_n)*IP_W to (x_blk_cnt*N+(x_n+1))*IP_W-1)));
          end loop;
        end loop;
 
        for i in 0 to N-1 loop
          for j in 0 to N-1 loop
            dv_s      <= '1';
            imageo_s  <= STD_LOGIC_VECTOR(
                         TO_UNSIGNED(INTEGER(matrix(i,j)),IP_W));
            xcon_s <= x_blk_cnt*N+j;
            ycon_s <= y_blk_cnt*N+i;
            waitposedge;
            if INSERT_DELAYS = TRUE then
              dv_s    <= '0';
              waitposedge(40);
            end if;
          end loop;
        end loop;
 
      end loop;
 
    end loop;
 
  end read_image;
 
   ---------------------------
   -- process begin
   ---------------------------
   begin
     test_stim <= 0;
     dv_s      <= '0';
     imageo_s  <= (others => '0');
     rst_s <= '1';
     waitposedge(20);
     rst_s <= '0';
 
     -------------------------
     -- test 1
     -------------------------
     test_stim <= 1;
     for i in 0 to 7 loop
       for j in 0 to 7 loop
         dv_s      <= '1';
         imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));
         waitposedge;
       end loop;
 
     end loop;
 
     dv_s <= '0';
     waitposedge;
     -------------------------
 
     -------------------------
     -- test 2
     -------------------------
     test_stim <= 2;
     for i in 0 to 7 loop
       for j in 0 to 7 loop
         dv_s      <= '1';
         imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data1(i,j)),IP_W));
         waitposedge;
       end loop;
 
     end loop;
 
     dv_s <= '0';
     waitposedge;
     ------------------------
 
     -------------------------
     -- test 3
     -------------------------
     test_stim <= 3;
     for i in 0 to 7 loop
       for j in 0 to 7 loop
         dv_s      <= '1';
         imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data2(i,j)),IP_W));
         waitposedge;
       end loop;
 
     end loop;
 
     dv_s <= '0';
     waitposedge;
     ------------------------
 
     -------------------------
     -- test 4
     -------------------------
     test_stim <= 4;
     for i in 0 to 7 loop
       for j in 0 to 7 loop
         dv_s      <= '1';
         imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));
         waitposedge;
         dv_s      <= '0';
         waitposedge;
       end loop;
 
     end loop;
 
     dv_s <= '0';
     waitposedge;
     ------------------------
 
     -------------------------
     -- test 5
     -------------------------
     test_stim <= 5;
     for i in 0 to 7 loop
       for j in 0 to 7 loop
         dv_s      <= '1';
         imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data1(i,j)),IP_W));
         waitposedge;
         dv_s      <= '0';
         waitposedge(25);
       end loop;
 
     end loop;
 
     dv_s <= '0';
     waitposedge;
     ------------------------
 
     -------------------------
     -- test 6-16
     -------------------------
 
     for x in 0 to 10 loop
       test_stim <= test_stim+1;
       for i in 0 to 7 loop
         for j in 0 to 7 loop
           dv_s      <= '1';
           if x rem 2 = 0 then
             imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));
           else
             imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data3(i,j)),IP_W));
           end if;
           waitposedge;
         end loop;
       end loop;
     end loop;
 
     dv_s <= '0';
     waitposedge;
     ------------------------
 
     -------------------------
     -- test 17-33
     -------------------------
 
     for x in 0 to 16 loop
       test_stim <= test_stim+1;
       if xi < 4 then
         xi := xi + 1;
       else
         xi := 0;
       end if;
       for i in 0 to 7 loop
         for j in 0 to 7 loop
           dv_s      <= '1';
 
           case xi is
             when 0 =>
               imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data1(i,j)),IP_W));
             when 1 =>
               imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));
             when 2 =>
               imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data3(i,j)),IP_W));
             when 3 =>
               imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data4(i,j)),IP_W));
             when others =>
               imageo_s  <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));
           end case;
           waitposedge;
           dv_s      <= '0';
           GenRnd(unf);
                rnd := unf.rnd;
                waitposedge(INTEGER(rnd));
         end loop;
       end loop;
     end loop;
 
     dv_s <= '0';
     waitposedge;
     ------------------------
 
     -------------------------
     -- test 6
     -------------------------
     if RUN_FULL_IMAGE = TRUE then
       read_image;
     end if;
 
     -------------------------
     -- test 7
     -------------------------
     --INSERT_DELAYS := TRUE;
     --read_image;
 
     dv_s <= '0';
     waitposedge;
     ------------------------
 
     wait;
 end process;
 
 --------------------------
 -- output coeffs comparison (after 1st stage)
 --------------------------
 OUTIMAGE_PROC: process
   variable i : INTEGER  := 0;
   variable j : INTEGER  := 0;
   variable error_matrix : I_MATRIX_TYPE;
   variable error_cnt    : INTEGER := 0;
   variable raport_str   : STRING(1 to 255);
   variable ref_matrix   : I_MATRIX_TYPE;
   variable dcto_matrix  : I_MATRIX_TYPE;
   variable xi           : INTEGER := 0;
  -------------------------------------
  -- wait for defined number of clock cycles
  -------------------------------------
  procedure waitposedge(clocks : in INTEGER) is
  begin
    for i in 1 to clocks loop
      wait until clk='1' and clk'event;
    end loop;
  end waitposedge;
 
  -------------------------------------
  -- wait on clock rising edge
  -------------------------------------
  procedure waitposedge is
  begin
    wait until clk='1' and clk'event;
  end waitposedge;
 
  --------------------------------------
  -- read text image data 1D DCT
  --------------------------------------
  procedure read_image_for1dct(error_cnt_i : inout INTEGER) is
    file infile          : TEXT open read_mode is FILEIN_NAME_C;
    variable inline      : LINE;
    variable tmp_int     : INTEGER := 0;
    variable y_size      : INTEGER := 0;
    variable x_size      : INTEGER := 0;
    variable x_blocks8   : INTEGER := 0;
    variable y_blocks8   : INTEGER := 0;
    variable matrix      : I_MATRIX_TYPE;
    variable x_blk_cnt   : INTEGER := 0;
    variable y_blk_cnt   : INTEGER := 0;
    variable n_lines_arr : N_LINES_TYPE;
    variable line_n      : INTEGER := 0;
    variable pix_n       : INTEGER := 0;
    variable x_n         : INTEGER := 0;
    variable y_n         : INTEGER := 0;
    variable i           : INTEGER := 0;
    variable j           : INTEGER := 0;
    variable dcto_matrix_v : I_MATRIX_TYPE;
    variable ref_matrix_v  : I_MATRIX_TYPE;
    variable error_dcto1_matrix_v : I_MATRIX_TYPE;
  begin
    READLINE(infile,inline);
    READ(inline,y_size);
    READLINE(infile,inline);
    READ(inline,x_size);
 
    y_blocks8 := y_size / N;
    x_blocks8 := x_size / N;
 
    assert MAX_IMAGE_SIZE_X > x_size
      report "E02: Input image x size exceeds maximum value!"
      severity Failure;
 
    if y_size rem N > 0 then
      assert false
        report "E03: Image height dimension is not multiply of N!"
        severity Failure;
    end if;
    if x_size rem N > 0 then
      assert false
        report "E03: Image width dimension is not multiply of N!"
        severity Failure;
    end if;
 
    for y_blk_cnt in 0 to y_blocks8-1 loop
 
      -- read N input lines and store them to buffer
      for y_n in 0 to N-1 loop
        READLINE(infile,inline);
        HREAD(inline,n_lines_arr(y_n)(0 to x_size*IP_W-1));
      end loop;
      y_n := 0;
 
      for x_blk_cnt in 0 to x_blocks8-1 loop
        for y_n in 0 to N-1 loop
          for x_n in 0 to N-1 loop
            matrix(y_n,x_n) := TO_INTEGER(UNSIGNED(
                n_lines_arr(y_n)
                    ((x_blk_cnt*N+x_n)*IP_W to (x_blk_cnt*N+(x_n+1))*IP_W-1)));
          end loop;
        end loop;
 
        for i in 0 to N-1 loop
          j := 0;
          while(true) loop
            waitposedge;
            if odv1 = '1' then
              dcto_matrix_v(j,i) := TO_INTEGER(SIGNED( dcto1 ));
              j := j + 1;
            end if;
 
            if j = N then
              exit;
            end if;
          end loop;
        end loop;
 
        -- compute reference coefficients
        ref_matrix_v := COMPUTE_REF_DCT1D(matrix,TRUE);
        CMP_MATRIX(ref_matrix_v,dcto_matrix_v,
                                    MAX_ERROR_1D,error_dcto1_matrix_v,error_cnt_i);
        error_dcto1_matrix_s <= error_dcto1_matrix_v;
      end loop;
    end loop;
  end read_image_for1dct;
 
  begin
     test_inp <= 0;
 
     -------------------------
     -- test 1
     -------------------------
     test_inp <= 1;
     -- compute reference coefficients
     ref_matrix := COMPUTE_REF_DCT1D(input_data0,TRUE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv1 = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto1 ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     CMP_MATRIX(ref_matrix,dcto_matrix,MAX_ERROR_1D,error_matrix,error_cnt);
     -------------------------
 
     -------------------------
     -- test 2
     -------------------------
     test_inp <= 2;
     -- compute reference coefficients
     ref_matrix := COMPUTE_REF_DCT1D(input_data1,TRUE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv1 = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto1 ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     CMP_MATRIX(ref_matrix,dcto_matrix,MAX_ERROR_1D,error_matrix,error_cnt);
     -------------------------
 
     -------------------------
     -- test 3
     -------------------------
     test_inp <= 3;
     -- compute reference coefficients
     ref_matrix := COMPUTE_REF_DCT1D(input_data2,TRUE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv1 = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto1 ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     CMP_MATRIX(ref_matrix,dcto_matrix,MAX_ERROR_1D,error_matrix,error_cnt);
     -------------------------
 
     -------------------------
     -- test 4
     -------------------------
     test_inp <= 4;
     -- compute reference coefficients
     ref_matrix := COMPUTE_REF_DCT1D(input_data0,TRUE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv1 = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto1 ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     CMP_MATRIX(ref_matrix,dcto_matrix,MAX_ERROR_1D,error_matrix,error_cnt);
     -------------------------
 
     -------------------------
     -- test 5
     -------------------------
     test_inp <= 5;
     -- compute reference coefficients
     ref_matrix := COMPUTE_REF_DCT1D(input_data1,TRUE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv1 = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto1 ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     CMP_MATRIX(ref_matrix,dcto_matrix,MAX_ERROR_1D,error_matrix,error_cnt);
     -------------------------
 
     -------------------------
     -- test 6-16
     -------------------------
     for x in 0 to 10 loop
       test_inp <= test_inp + 1;
       -- compute reference coefficients
       if x rem 2 = 0 then
         ref_matrix := COMPUTE_REF_DCT1D(input_data0,TRUE);
       else
         ref_matrix := COMPUTE_REF_DCT1D(input_data3,TRUE);
       end if;
       for i in 0 to N-1 loop
         j := 0;
         while(true) loop
 
           waitposedge;
           if odv1 = '1' then
             dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto1 ));
             j := j + 1;
           end if;
 
           if j = N then
             exit;
           end if;
 
         end loop;
       end loop;
       CMP_MATRIX(ref_matrix,dcto_matrix,MAX_ERROR_1D,error_matrix,error_cnt);
     end loop;
     -------------------------
 
     -------------------------
     -- test 17-33
     -------------------------
     for x in 0 to 16 loop
       test_inp <= test_inp + 1;
       -- compute reference coefficients
       if xi < 4 then
         xi := xi + 1;
       else
         xi := 0;
       end if;
       case xi is
         when 0 =>
           ref_matrix := COMPUTE_REF_DCT1D(input_data1,TRUE);
         when 1 =>
           ref_matrix := COMPUTE_REF_DCT1D(input_data0,TRUE);
         when 2 =>
           ref_matrix := COMPUTE_REF_DCT1D(input_data3,TRUE);
         when 3 =>
           ref_matrix := COMPUTE_REF_DCT1D(input_data4,TRUE);
         when others =>
           ref_matrix := COMPUTE_REF_DCT1D(input_data0,TRUE);
       end case;
 
       for i in 0 to N-1 loop
         j := 0;
         while(true) loop
 
           waitposedge;
           if odv1 = '1' then
             dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto1 ));
             j := j + 1;
           end if;
 
           if j = N then
             exit;
           end if;
 
         end loop;
       end loop;
       CMP_MATRIX(ref_matrix,dcto_matrix,MAX_ERROR_1D,error_matrix,error_cnt);
     end loop;
     -------------------------
 
     -------------------------
     -- test 6
     -------------------------
     test_inp <= 6;
 
     if RUN_FULL_IMAGE = TRUE then
       read_image_for1dct(error_cnt);
     end if;
     -------------------------
 
     -------------------------
     -- test 7
     -------------------------
     test_inp <= 7;
 
     --read_image_for1dct(error_cnt);
     -------------------------
 
     if error_cnt = 0 then
       assert false
         report "No errors found in first stage of DCT"
         severity Note;
     else
       assert false
         report "Found " & STR(error_cnt,10) & " errors in first stage of DCT!"
         severity Error;
     end if;
     assert false
       report "1D Test finished"
       severity Note;
 
     wait;
 end process;
 
 --------------------------
 -- final output coeffs comparison (after 2nd stage)
 --------------------------
 FINAL_OUTIMAGE_PROC: process
   variable i : INTEGER := 0;
   variable j : INTEGER := 0;
   variable error_matrix    : I_MATRIX_TYPE;
   variable error_idct_matrix : I_MATRIX_TYPE;
   variable error_cnt       : INTEGER := 0;
   variable raport_str      : STRING(1 to 255);
   variable ref_matrix_1d   : I_MATRIX_TYPE;
   variable ref_matrix_2d   : I_MATRIX_TYPE;
   variable ref_idct_matrix : I_MATRIX_TYPE;
   variable idcto_matrix    : I_MATRIX_TYPE;
   variable dcto_matrix     : I_MATRIX_TYPE;
   variable tmp_matrix      : I_MATRIX_TYPE;
   variable psnr            : REAL;
   variable xi              : INTEGER := 0;
  -------------------------------------
  -- wait for defined number of clock cycles
  -------------------------------------
  procedure waitposedge(clocks : in INTEGER) is
  begin
    for i in 1 to clocks loop
      wait until clk='1' and clk'event;
    end loop;
  end waitposedge;
 
  -------------------------------------
  -- wait on clock rising edge
  -------------------------------------
  procedure waitposedge is
  begin
    wait until clk='1' and clk'event;
  end waitposedge;
 
  --------------------------------------
  -- read text image data 2D DCT
  --------------------------------------
  procedure read_image_for2dct(error_cnt_i : inout INTEGER) is
    file infile          : TEXT open read_mode is FILEIN_NAME_C;
    file outfile_imagee  : TEXT open write_mode is FILEERROR_NAME_C;
    file outfile_imageo  : TEXT open write_mode is FILEIMAGEO_NAME_C;
    variable inline      : LINE;
    variable outline     : LINE;
    variable outline2    : LINE;
    variable tmp_int     : INTEGER := 0;
    variable y_size      : INTEGER := 0;
    variable x_size      : INTEGER := 0;
    variable x_blocks8   : INTEGER := 0;
    variable y_blocks8   : INTEGER := 0;
    variable matrix      : I_MATRIX_TYPE;
    variable x_blk_cnt   : INTEGER := 0;
    variable y_blk_cnt   : INTEGER := 0;
    variable n_lines_arr : N_LINES_TYPE;
    variable line_n      : INTEGER := 0;
    variable pix_n       : INTEGER := 0;
    variable x_n         : INTEGER := 0;
    variable y_n         : INTEGER := 0;
    variable i           : INTEGER := 0;
    variable j           : INTEGER := 0;
    variable dcto_matrix_v    : I_MATRIX_TYPE;
    variable ref_matrix_v     : I_MATRIX_TYPE;
    variable error_matrix_v   : I_MATRIX_TYPE;
    variable idcto_matrix_v   : I_MATRIX_TYPE;
    variable ref_matrix_1d_v  : I_MATRIX_TYPE;
    variable ref_matrix_2d_v  : I_MATRIX_TYPE;
    variable error_idct_matrix_v : I_MATRIX_TYPE;
    variable error_dct_matrix_v  : I_MATRIX_TYPE;
    variable psnr_v           : REAL := 0.0;
    variable linebuf          : LINE;
    variable input_image      : IMAGE_TYPE;
    variable output_image     : IMAGE_TYPE;
    variable dcto_image       : IMAGE_TYPE;
    variable str2_v           : STRING(1 to 2);
    variable dec_v            : INTEGER := 0;
    variable dec2_v           : INTEGER := 0;
    variable clip_cnt_v       : INTEGER := 0;
    variable tmp_q            : INTEGER := 0;
  begin
    READLINE(infile,inline);
    READ(inline,y_size);
    READLINE(infile,inline);
    READ(inline,x_size);
 
    y_blocks8 := y_size / N;
    x_blocks8 := x_size / N;
 
    assert MAX_IMAGE_SIZE_X > x_size
      report "E02: Input image x size exceeds maximum value!"
      severity Failure;
 
    if y_size rem N > 0 then
      assert false
        report "E03: Image height dimension is not multiply of N!"
        severity Failure;
    end if;
    if x_size rem N > 0 then
      assert false
        report "E03: Image width dimension is not multiply of N!"
        severity Failure;
    end if;
 
    for y_blk_cnt in 0 to y_blocks8-1 loop
 
      -- read N input lines and store them to buffer
      for y_n in 0 to N-1 loop
        READLINE(infile,inline);
        HREAD(inline,n_lines_arr(y_n)(0 to x_size*IP_W-1));
      end loop;
      y_n := 0;
 
      for x_blk_cnt in 0 to x_blocks8-1 loop
        for y_n in 0 to N-1 loop
          for x_n in 0 to N-1 loop
            matrix(y_n,x_n) := TO_INTEGER(UNSIGNED(
                n_lines_arr(y_n)
                    ((x_blk_cnt*N+x_n)*IP_W to
                    (x_blk_cnt*N+(x_n+1))*IP_W-1)));
            input_image(y_blk_cnt*N+y_n,x_blk_cnt*N+x_n) :=
                                                    matrix(y_n,x_n);
          end loop;
        end loop;
 
        for i in 0 to N-1 loop
          j := 0;
          while(true) loop
            waitposedge;
            if odv = '1' then
              tmp_q := TO_INTEGER(SIGNED( dcto ));
              if ENABLE_QUANTIZATION_C = TRUE then
                tmp_q := tmp_q / Q_MATRIX_USED(j,i);
                tmp_q := tmp_q * Q_MATRIX_USED(j,i);
              end if;
              dcto_matrix_v(j,i) := tmp_q;
              j := j + 1;
            end if;
 
            if j = N then
              exit;
            end if;
          end loop;
        end loop;
        idcto_matrix_v := COMPUTE_REF_IDCT(dcto_matrix_v);
        for i in 0 to N-1 loop
          for j in 0 to N-1 loop
            output_image(y_blk_cnt*N+j,x_blk_cnt*N+i) :=
                                                    idcto_matrix_v(j,i);
            dcto_image(y_blk_cnt*N+j,x_blk_cnt*N+i) :=
                                                    dcto_matrix_v(j,i);
          end loop;
        end loop;
        -- compute reference coefficients
        ref_matrix_1d_v := COMPUTE_REF_DCT1D(matrix,TRUE);
        ref_matrix_2d_v := COMPUTE_REF_DCT1D(ref_matrix_1d_v,FALSE);
        CMP_MATRIX(ref_matrix_2d_v,dcto_matrix_v,MAX_ERROR_2D,
                                error_dct_matrix_v,error_cnt_i);
        error_dct_matrix_s <= error_dct_matrix_v;
 
      end loop;
    end loop;
 
    -- PSNR
    psnr_v := COMPUTE_PSNR(input_image,output_image,y_size,x_size);
    WRITE(linebuf,STRING'("PSNR computed for image "
                          & FILEIN_NAME_C & " is "));
    WRITE(linebuf,psnr_v);
    WRITE(linebuf,STRING'(" dB"));
    assert false
      report linebuf.all
      severity Note;
 
    -- Save images
    WRITE(outline,y_size);
    WRITELINE(outfile_imageo,outline);
    WRITE(outline,x_size);
    WRITELINE(outfile_imageo,outline);
 
    WRITE(outline,y_size);
    WRITELINE(outfile_imagee,outline);
    WRITE(outline,x_size);
    WRITELINE(outfile_imagee,outline);
 
    for i in 0 to y_size-1 loop
      for j in 0 to x_size-1 loop
 
        -- output image
        dec_v := output_image(i,j);
        -- if DCT transform error created minus value, set it to zero
        if dec_v < 0 then
          dec_v := 0;
          clip_cnt_v := clip_cnt_v + 1;
        elsif dec_v > 255 then
          dec_v := 255;
          clip_cnt_v := clip_cnt_v + 1;
        end if;
 
        if dec_v <= HEX_BASE-1 then
          str2_v := "0" & STR( dec_v, HEX_BASE);
        else
          str2_v := STR( dec_v, HEX_BASE);
        end if;
        WRITE(outline,str2_v);
 
        -- dcto image
        dec_v := abs(output_image(i,j)-input_image(i,j));
        -- if DCT transform error created minus value, set it to zero
        if dec_v > 255 then
          dec_v := 255;
        end if;
 
        if dec_v <= HEX_BASE-1 then
          str2_v := "0" & STR( dec_v, HEX_BASE);
        else
          str2_v := STR( dec_v, HEX_BASE);
        end if;
        WRITE(outline2,str2_v);
      end loop;
      WRITELINE(outfile_imageo,outline);
      WRITELINE(outfile_imagee,outline2);
    end loop;
 
 
  end read_image_for2dct;
 
  begin
     test_out <= 0;
     testend <= false;
 
     -------------------------
     -- test 1
     -------------------------
     test_out <= 1;
     tmp_matrix := input_data0;
     -- compute reference coefficients
     ref_matrix_1d := COMPUTE_REF_DCT1D(tmp_matrix,TRUE);
     ref_matrix_2d := COMPUTE_REF_DCT1D(ref_matrix_1d,FALSE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     waitposedge;
 
     CMP_MATRIX(ref_matrix_2d,dcto_matrix,MAX_ERROR_2D,error_matrix,error_cnt);
     idcto_matrix := COMPUTE_REF_IDCT(dcto_matrix);
     --error_idct_matrix := CMP_MATRIX(tmp_matrix,idcto_matrix,MAX_ERROR_2D);
     psnr := psnr + COMPUTE_PSNR(tmp_matrix,idcto_matrix);
     -------------------------
 
     -------------------------
     -- test 2
     -------------------------
     test_out <= 2;
     tmp_matrix := input_data1;
     -- compute reference coefficients
     ref_matrix_1d := COMPUTE_REF_DCT1D(tmp_matrix,TRUE);
     ref_matrix_2d := COMPUTE_REF_DCT1D(ref_matrix_1d,FALSE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     waitposedge;
 
     CMP_MATRIX(ref_matrix_2d,dcto_matrix,MAX_ERROR_2D,error_matrix,error_cnt);
     idcto_matrix := COMPUTE_REF_IDCT(dcto_matrix);
     --error_idct_matrix := CMP_MATRIX(tmp_matrix,idcto_matrix,MAX_ERROR_2D);
     psnr := COMPUTE_PSNR(tmp_matrix,idcto_matrix);
     -------------------------
 
     -------------------------
     -- test 3
     -------------------------
     test_out <= 3;
     tmp_matrix := input_data2;
     -- compute reference coefficients
     ref_matrix_1d := COMPUTE_REF_DCT1D(tmp_matrix,TRUE);
     ref_matrix_2d := COMPUTE_REF_DCT1D(ref_matrix_1d,FALSE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     waitposedge;
 
     CMP_MATRIX(ref_matrix_2d,dcto_matrix,MAX_ERROR_2D,error_matrix,error_cnt);
     idcto_matrix := COMPUTE_REF_IDCT(dcto_matrix);
     --error_idct_matrix := CMP_MATRIX(tmp_matrix,idcto_matrix,MAX_ERROR_2D);
     --psnr := COMPUTE_PSNR(tmp_matrix,idcto_matrix);
     -------------------------
 
     -------------------------
     -- test 4
     -------------------------
     test_out <= 4;
     tmp_matrix := input_data0;
     -- compute reference coefficients
     ref_matrix_1d := COMPUTE_REF_DCT1D(tmp_matrix,TRUE);
     ref_matrix_2d := COMPUTE_REF_DCT1D(ref_matrix_1d,FALSE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     waitposedge;
 
     CMP_MATRIX(ref_matrix_2d,dcto_matrix,MAX_ERROR_2D,error_matrix,error_cnt);
     idcto_matrix := COMPUTE_REF_IDCT(dcto_matrix);
     --error_idct_matrix := CMP_MATRIX(tmp_matrix,idcto_matrix,MAX_ERROR_2D);
     psnr := COMPUTE_PSNR(tmp_matrix,idcto_matrix);
     -------------------------
 
     -------------------------
     -- test 5
     -------------------------
     test_out <= 5;
     tmp_matrix := input_data1;
     -- compute reference coefficients
     ref_matrix_1d := COMPUTE_REF_DCT1D(tmp_matrix,TRUE);
     ref_matrix_2d := COMPUTE_REF_DCT1D(ref_matrix_1d,FALSE);
 
     for i in 0 to N-1 loop
       j := 0;
       while(true) loop
 
         waitposedge;
         if odv = '1' then
           dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto ));
           j := j + 1;
         end if;
 
         if j = N then
           exit;
         end if;
 
       end loop;
     end loop;
 
     waitposedge;
 
     CMP_MATRIX(ref_matrix_2d,dcto_matrix,MAX_ERROR_2D,error_matrix,error_cnt);
     idcto_matrix := COMPUTE_REF_IDCT(dcto_matrix);
     psnr := COMPUTE_PSNR(tmp_matrix,idcto_matrix);
     -------------------------
 
     -------------------------
     -- test 6-16
     -------------------------
     for x in 0 to 10 loop
       test_out <= test_out+1;
 
       if x rem 2 = 0 then
         tmp_matrix := input_data0;
       else
         tmp_matrix := input_data3;
       end if;
       -- compute reference coefficients
       ref_matrix_1d := COMPUTE_REF_DCT1D(tmp_matrix,TRUE);
       ref_matrix_2d := COMPUTE_REF_DCT1D(ref_matrix_1d,FALSE);
 
       for i in 0 to N-1 loop
         j := 0;
         while(true) loop
 
           waitposedge;
           if odv = '1' then
             dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto ));
             j := j + 1;
           end if;
 
           if j = N then
             exit;
           end if;
 
         end loop;
       end loop;
 
       CMP_MATRIX(ref_matrix_2d,dcto_matrix,MAX_ERROR_2D,error_matrix,error_cnt);
       idcto_matrix := COMPUTE_REF_IDCT(dcto_matrix);
       psnr := COMPUTE_PSNR(tmp_matrix,idcto_matrix);
     end loop;
     -------------------------
 
     -------------------------
     -- test 17-33
     -------------------------
     for x in 0 to 16 loop
       test_out <= test_out+1;
       if xi < 4 then
         xi := xi + 1;
       else
         xi := 0;
       end if;
       case xi is
         when 0 =>
           tmp_matrix := input_data1;
         when 1 =>
           tmp_matrix := input_data0;
         when 2 =>
           tmp_matrix := input_data3;
         when 3 =>
           tmp_matrix := input_data4;
         when others =>
           tmp_matrix := input_data0;
       end case;
       -- compute reference coefficients
       ref_matrix_1d := COMPUTE_REF_DCT1D(tmp_matrix,TRUE);
       ref_matrix_2d := COMPUTE_REF_DCT1D(ref_matrix_1d,FALSE);
 
       for i in 0 to N-1 loop
         j := 0;
         while(true) loop
 
           waitposedge;
           if odv = '1' then
             dcto_matrix(j,i) := TO_INTEGER(SIGNED( dcto ));
             j := j + 1;
           end if;
 
           if j = N then
             exit;
           end if;
 
         end loop;
       end loop;
 
       CMP_MATRIX(ref_matrix_2d,dcto_matrix,MAX_ERROR_2D,error_matrix,error_cnt);
       idcto_matrix := COMPUTE_REF_IDCT(dcto_matrix);
       psnr := COMPUTE_PSNR(tmp_matrix,idcto_matrix);
     end loop;
     -------------------------
 
     -------------------------
     -- test 6
     -------------------------
     test_out <= 6;
     if RUN_FULL_IMAGE = TRUE then
       read_image_for2dct(error_cnt);
     end if;
     -------------------------
 
     -------------------------
     -- test 7
     -------------------------
     test_out <= 7;
     --read_image_for2dct(error_cnt);
     -------------------------
 
     waitposedge;
     testend <= TRUE;
     if error_cnt = 0 then
       assert false
         report "No errors found in second stage of DCT"
         severity Note;
     else
       assert false
         report "Found " & STR(error_cnt,10) & " errors in second stage of DCT!"
         severity Error;
     end if;
     assert false
       report "2D Test finished"
       severity Note;
 
     wait;
 end process;
 
end SIM;
--**************************************************************************--

Line No.	Rev	Author	Line
1	2	mikel262	`--------------------------------------------------------------------------------`
2			`-- --`
3			`-- V H D L F I L E --`
4			`-- COPYRIGHT (C) 2006 --`
5			`-- --`
6			`--------------------------------------------------------------------------------`
7			`--`
8			`-- Title : INPIMAGE`
9			`-- Design : MDCT Core`
10			`-- Author : Michal Krepa`
11			`--`
12			`--------------------------------------------------------------------------------`
13			`-- File : INPIMAGE.VHD`
14			`-- Created : Sat Mar 12 2006`
15			`--`
16			`--------------------------------------------------------------------------------`
17			`--`
18			`-- Description : 1D Discrete Cosine Transform TB stimulator and results compare`
19			`--`
20			`--------------------------------------------------------------------------------`
21			`library IEEE;`
22			`use IEEE.STD_LOGIC_1164.all;`
23			`use ieee.numeric_std.all;`
24			`use IEEE.STD_LOGIC_TEXTIO.all;`
25
26			`library STD;`
27			`use STD.TEXTIO.all;`
28
29			`library WORK;`
30			`use WORK.MDCT_PKG.all;`
31			`use WORK.MDCTTB_PKG.all;`
32	15	mikel262	`use WORK.RNG.all;`
33	2	mikel262
34			`entity INPIMAGE is`
35			`port (`
36			`clk : in STD_LOGIC;`
37			`odv1 : in STD_LOGIC;`
38			`dcto1 : in STD_LOGIC_VECTOR(OP_W-1 downto 0);`
39			`odv : in STD_LOGIC;`
40			`dcto : in STD_LOGIC_VECTOR(COE_W-1 downto 0);`
41
42			`rst : out STD_LOGIC;`
43			`imageo : out STD_LOGIC_VECTOR(IP_W-1 downto 0);`
44			`dv : out STD_LOGIC;`
45			`testend : out BOOLEAN`
46			`);`
47			`end INPIMAGE;`
48
49			`--**************************************************************************--`
50
51			`architecture SIM of INPIMAGE is`
52
53			`constant PERIOD : TIME := 1 us /(CLK_FREQ_C);`
54
55			`signal rst_s : STD_LOGIC;`
56			`signal test_inp : INTEGER;`
57	15	mikel262	`signal test_stim : INTEGER;`
58	2	mikel262	`signal test_out : INTEGER;`
59			`signal xcon_s : INTEGER;`
60			`signal ycon_s : INTEGER;`
61			`signal error_dct_matrix_s : I_MATRIX_TYPE;`
62	18	mikel262	`signal error_dcto1_matrix_s : I_MATRIX_TYPE;`
63			`signal imageo_s : STD_LOGIC_VECTOR(IP_W-1 downto 0);`
64			`signal dv_s : STD_LOGIC;`
65	2	mikel262
66			`begin`
67
68	18	mikel262	`rst <= rst_s after HOLD_TIME;`
69
70			`imageo <= imageo_s after HOLD_TIME;`
71			`dv <= dv_s after HOLD_TIME;`
72	2	mikel262
73			`--------------------------`
74			`-- input image stimuli`
75			`--------------------------`
76			`INPIMAGE_PROC: process`
77	15	mikel262	`variable i : INTEGER := 0;`
78			`variable j : INTEGER := 0;`
79	13	mikel262	`variable INSERT_DELAYS : BOOLEAN := FALSE;`
80	15	mikel262	`variable unf: Uniform := InitUniform(7, 0.0, 2.0);`
81			`variable rnd: real := 0.0;`
82			`variable xi : INTEGER := 0;`
83	2	mikel262
84			`-------------------------------------`
85			`-- wait for defined number of clock cycles`
86			`-------------------------------------`
87			`procedure waitposedge(clocks : in INTEGER) is`
88			`begin`
89			`for i in 1 to clocks loop`
90			`wait until clk='1' and clk'event;`
91			`end loop;`
92			`end waitposedge;`
93
94			`-------------------------------------`
95			`-- wait on clock rising edge`
96			`-------------------------------------`
97			`procedure waitposedge is`
98			`begin`
99			`wait until clk='1' and clk'event;`
100			`end waitposedge;`
101
102			`--------------------------------------`
103			`-- read text image data`
104			`--------------------------------------`
105			`procedure read_image is`
106			`file infile : TEXT open read_mode is FILEIN_NAME_C;`
107			`variable inline : LINE;`
108			`variable tmp_int : INTEGER := 0;`
109			`variable y_size : INTEGER := 0;`
110			`variable x_size : INTEGER := 0;`
111			`variable x_blocks8 : INTEGER := 0;`
112			`variable y_blocks8 : INTEGER := 0;`
113			`variable matrix : I_MATRIX_TYPE;`
114			`variable x_blk_cnt : INTEGER := 0;`
115			`variable y_blk_cnt : INTEGER := 0;`
116			`variable n_lines_arr : N_LINES_TYPE;`
117			`variable line_n : INTEGER := 0;`
118			`variable pix_n : INTEGER := 0;`
119			`variable x_n : INTEGER := 0;`
120			`variable y_n : INTEGER := 0;`
121			`begin`
122			`READLINE(infile,inline);`
123			`READ(inline,y_size);`
124			`READLINE(infile,inline);`
125			`READ(inline,x_size);`
126
127			`y_blocks8 := y_size / N;`
128			`x_blocks8 := x_size / N;`
129
130			`assert MAX_IMAGE_SIZE_X > x_size`
131			`report "E02: Input image x size exceeds maximum value!"`
132			`severity Failure;`
133
134			`if y_size rem N > 0 then`
135			`assert false`
136			`report "E03: Image height dimension is not multiply of N!"`
137			`severity Failure;`
138			`end if;`
139			`if x_size rem N > 0 then`
140			`assert false`
141			`report "E03: Image width dimension is not multiply of N!"`
142			`severity Failure;`
143			`end if;`
144
145			`for y_blk_cnt in 0 to y_blocks8-1 loop`
146
147			`-- read N input lines and store them to buffer`
148			`for y_n in 0 to N-1 loop`
149			`READLINE(infile,inline);`
150			`HREAD(inline,n_lines_arr(y_n)(0 to x_size*IP_W-1));`
151			`end loop;`
152			`y_n := 0;`
153
154			`for x_blk_cnt in 0 to x_blocks8-1 loop`
155			`for y_n in 0 to N-1 loop`
156			`for x_n in 0 to N-1 loop`
157			`matrix(y_n,x_n) := TO_INTEGER(UNSIGNED(`
158			`n_lines_arr(y_n)`
159			`((x_blk_cntN+x_n)IP_W to (x_blk_cntN+(x_n+1))IP_W-1)));`
160			`end loop;`
161			`end loop;`
162
163			`for i in 0 to N-1 loop`
164			`for j in 0 to N-1 loop`
165	18	mikel262	`dv_s <= '1';`
166			`imageo_s <= STD_LOGIC_VECTOR(`
167	2	mikel262	`TO_UNSIGNED(INTEGER(matrix(i,j)),IP_W));`
168			`xcon_s <= x_blk_cnt*N+j;`
169			`ycon_s <= y_blk_cnt*N+i;`
170			`waitposedge;`
171	13	mikel262	`if INSERT_DELAYS = TRUE then`
172	18	mikel262	`dv_s <= '0';`
173	13	mikel262	`waitposedge(40);`
174			`end if;`
175	2	mikel262	`end loop;`
176			`end loop;`
177
178			`end loop;`
179
180			`end loop;`
181
182			`end read_image;`
183
184			`---------------------------`
185			`-- process begin`
186			`---------------------------`
187			`begin`
188	15	mikel262	`test_stim <= 0;`
189	18	mikel262	`dv_s <= '0';`
190			`imageo_s <= (others => '0');`
191	2	mikel262	`rst_s <= '1';`
192	18	mikel262	`waitposedge(20);`
193	2	mikel262	`rst_s <= '0';`
194
195			`-------------------------`
196			`-- test 1`
197			`-------------------------`
198	15	mikel262	`test_stim <= 1;`
199	2	mikel262	`for i in 0 to 7 loop`
200			`for j in 0 to 7 loop`
201	18	mikel262	`dv_s <= '1';`
202			`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));`
203	2	mikel262	`waitposedge;`
204			`end loop;`
205
206			`end loop;`
207
208	18	mikel262	`dv_s <= '0';`
209	2	mikel262	`waitposedge;`
210			`-------------------------`
211
212			`-------------------------`
213			`-- test 2`
214			`-------------------------`
215	15	mikel262	`test_stim <= 2;`
216	2	mikel262	`for i in 0 to 7 loop`
217			`for j in 0 to 7 loop`
218	18	mikel262	`dv_s <= '1';`
219			`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data1(i,j)),IP_W));`
220	2	mikel262	`waitposedge;`
221			`end loop;`
222
223			`end loop;`
224
225	18	mikel262	`dv_s <= '0';`
226	2	mikel262	`waitposedge;`
227			`------------------------`
228
229			`-------------------------`
230			`-- test 3`
231			`-------------------------`
232	15	mikel262	`test_stim <= 3;`
233	2	mikel262	`for i in 0 to 7 loop`
234			`for j in 0 to 7 loop`
235	18	mikel262	`dv_s <= '1';`
236			`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data2(i,j)),IP_W));`
237	2	mikel262	`waitposedge;`
238			`end loop;`
239
240			`end loop;`
241
242	18	mikel262	`dv_s <= '0';`
243	2	mikel262	`waitposedge;`
244			`------------------------`
245
246			`-------------------------`
247			`-- test 4`
248			`-------------------------`
249	15	mikel262	`test_stim <= 4;`
250	2	mikel262	`for i in 0 to 7 loop`
251			`for j in 0 to 7 loop`
252	18	mikel262	`dv_s <= '1';`
253			`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));`
254	2	mikel262	`waitposedge;`
255	18	mikel262	`dv_s <= '0';`
256	2	mikel262	`waitposedge;`
257			`end loop;`
258
259			`end loop;`
260
261	18	mikel262	`dv_s <= '0';`
262	2	mikel262	`waitposedge;`
263			`------------------------`
264
265			`-------------------------`
266			`-- test 5`
267			`-------------------------`
268	15	mikel262	`test_stim <= 5;`
269	13	mikel262	`for i in 0 to 7 loop`
270			`for j in 0 to 7 loop`
271	18	mikel262	`dv_s <= '1';`
272			`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data1(i,j)),IP_W));`
273	13	mikel262	`waitposedge;`
274	18	mikel262	`dv_s <= '0';`
275	13	mikel262	`waitposedge(25);`
276			`end loop;`
277
278			`end loop;`
279
280	18	mikel262	`dv_s <= '0';`
281	13	mikel262	`waitposedge;`
282			`------------------------`
283
284			`-------------------------`
285	15	mikel262	`-- test 6-16`
286			`-------------------------`
287
288			`for x in 0 to 10 loop`
289			`test_stim <= test_stim+1;`
290			`for i in 0 to 7 loop`
291			`for j in 0 to 7 loop`
292	18	mikel262	`dv_s <= '1';`
293	15	mikel262	`if x rem 2 = 0 then`
294	18	mikel262	`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));`
295	15	mikel262	`else`
296	18	mikel262	`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data3(i,j)),IP_W));`
297	15	mikel262	`end if;`
298			`waitposedge;`
299			`end loop;`
300			`end loop;`
301			`end loop;`
302
303	18	mikel262	`dv_s <= '0';`
304	15	mikel262	`waitposedge;`
305			`------------------------`
306
307			`-------------------------`
308			`-- test 17-33`
309			`-------------------------`
310
311	18	mikel262	`for x in 0 to 16 loop`
312	15	mikel262	`test_stim <= test_stim+1;`
313			`if xi < 4 then`
314			`xi := xi + 1;`
315			`else`
316			`xi := 0;`
317			`end if;`
318			`for i in 0 to 7 loop`
319			`for j in 0 to 7 loop`
320	18	mikel262	`dv_s <= '1';`
321	15	mikel262
322			`case xi is`
323			`when 0 =>`
324	18	mikel262	`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data1(i,j)),IP_W));`
325	15	mikel262	`when 1 =>`
326	18	mikel262	`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));`
327	15	mikel262	`when 2 =>`
328	18	mikel262	`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data3(i,j)),IP_W));`
329	15	mikel262	`when 3 =>`
330	18	mikel262	`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data4(i,j)),IP_W));`
331	15	mikel262	`when others =>`
332	18	mikel262	`imageo_s <= STD_LOGIC_VECTOR(TO_UNSIGNED(INTEGER(input_data0(i,j)),IP_W));`
333	15	mikel262	`end case;`
334			`waitposedge;`
335	18	mikel262	`dv_s <= '0';`
336	15	mikel262	`GenRnd(unf);`
337			`rnd := unf.rnd;`
338			`waitposedge(INTEGER(rnd));`
339			`end loop;`
340			`end loop;`
341			`end loop;`
342
343	18	mikel262	`dv_s <= '0';`
344	15	mikel262	`waitposedge;`
345			`------------------------`
346
347			`-------------------------`
348	13	mikel262	`-- test 6`
349			`-------------------------`
350	15	mikel262	`if RUN_FULL_IMAGE = TRUE then`
351			`read_image;`
352			`end if;`
353	2	mikel262
354	13	mikel262	`-------------------------`
355			`-- test 7`
356			`-------------------------`
357			`--INSERT_DELAYS := TRUE;`
358			`--read_image;`
359
360	18	mikel262	`dv_s <= '0';`
361	2	mikel262	`waitposedge;`
362			`------------------------`
363
364			`wait;`
365			`end process;`
366
367			`--------------------------`
368			`-- output coeffs comparison (after 1st stage)`
369			`--------------------------`
370			`OUTIMAGE_PROC: process`
371			`variable i : INTEGER := 0;`
372			`variable j : INTEGER := 0;`
373			`variable error_matrix : I_MATRIX_TYPE;`
374			`variable error_cnt : INTEGER := 0;`
375			`variable raport_str : STRING(1 to 255);`
376			`variable ref_matrix : I_MATRIX_TYPE;`
377			`variable dcto_matrix : I_MATRIX_TYPE;`
378	15	mikel262	`variable xi : INTEGER := 0;`
379	2	mikel262	`-------------------------------------`
380			`-- wait for defined number of clock cycles`
381			`-------------------------------------`
382			`procedure waitposedge(clocks : in INTEGER) is`
383			`begin`
384			`for i in 1 to clocks loop`
385			`wait until clk='1' and clk'event;`
386			`end loop;`
387			`end waitposedge;`
388
389			`-------------------------------------`
390			`-- wait on clock rising edge`
391			`-------------------------------------`
392			`procedure waitposedge is`
393			`begin`
394			`wait until clk='1' and clk'event;`
395			`end waitposedge;`
396
397			`--------------------------------------`
398			`-- read text image data 1D DCT`
399			`--------------------------------------`
400			`procedure read_image_for1dct(error_cnt_i : inout INTEGER) is`
401			`file infile : TEXT open read_mode is FILEIN_NAME_C;`
402			`variable inline : LINE;`
403			`variable tmp_int : INTEGER := 0;`
404			`variable y_size : INTEGER := 0;`
405			`variable x_size : INTEGER := 0;`
406			`variable x_blocks8 : INTEGER := 0;`
407			`variable y_blocks8 : INTEGER := 0;`
408			`variable matrix : I_MATRIX_TYPE;`
409			`variable x_blk_cnt : INTEGER := 0;`
410			`variable y_blk_cnt : INTEGER := 0;`
411			`variable n_lines_arr : N_LINES_TYPE;`
412			`variable line_n : INTEGER := 0;`
413			`variable pix_n : INTEGER := 0;`
414			`variable x_n : INTEGER := 0;`
415			`variable y_n : INTEGER := 0;`
416			`variable i : INTEGER := 0;`
417			`variable j : INTEGER := 0;`
418			`variable dcto_matrix_v : I_MATRIX_TYPE;`
419			`variable ref_matrix_v : I_MATRIX_TYPE;`
420			`variable error_dcto1_matrix_v : I_MATRIX_TYPE;`
421			`begin`
422			`READLINE(infile,inline);`
423			`READ(inline,y_size);`
424			`READLINE(infile,inline);`
425			`READ(inline,x_size);`
426
427			`y_blocks8 := y_size / N;`
428			`x_blocks8 := x_size / N;`
429
430			`assert MAX_IMAGE_SIZE_X > x_size`
431			`report "E02: Input image x size exceeds maximum value!"`
432			`severity Failure;`
433
434			`if y_size rem N > 0 then`
435			`assert false`
436			`report "E03: Image height dimension is not multiply of N!"`
437			`severity Failure;`
438			`end if;`
439			`if x_size rem N > 0 then`
440			`assert false`
441			`report "E03: Image width dimension is not multiply of N!"`
442			`severity Failure;`
443			`end if;`
444
445			`for y_blk_cnt in 0 to y_blocks8-1 loop`
446
447			`-- read N input lines and store them to buffer`
448			`for y_n in 0 to N-1 loop`
449			`READLINE(infile,inline);`
450			`HREAD(inline,n_lines_arr(y_n)(0 to x_size*IP_W-1));`
451			`end loop;`
452			`y_n := 0;`
453
454			`for x_blk_cnt in 0 to x_blocks8-1 loop`
455			`for y_n in 0 to N-1 loop`
456			`for x_n in 0 to N-1 loop`
457			`matrix(y_n,x_n) := TO_INTEGER(UNSIGNED(`
458			`n_lines_arr(y_n)`
459			`((x_blk_cntN+x_n)IP_W to (x_blk_cntN+(x_n+1))IP_W-1)));`
460			`end loop;`
461			`end loop;`
462
463			`for i in 0 to N-1 loop`
464			`j := 0;`
465			`while(true) loop`
466			`waitposedge;`
467			`if odv1 = '1' then`
468			`dcto_matrix_v(j,i) := TO_INTEGER(SIGNED( dcto1 ));`
469			`j := j + 1;`
470			`end if;`
471
472			`if j = N then`
473			`exit;`
474			`end if;`
475			`end loop;`
476			`end loop;`
477
478			`-- compute reference coefficients`
479			`ref_matrix_v := COMPUTE_REF_DCT1D(matrix,TRUE);`
480			`CMP_MATRIX(ref_matrix_v,dcto_matrix_v,`
481			`MAX_ERROR_1D,error_dcto1_matrix_v,error_cnt_i);`
482			`error_dcto1_matrix_s <= error_dcto1_matrix_v;`
483			`end loop;`
484			`end loop;`
485			`end read_image_for1dct;`
486
487			`begin`
488			`test_inp <= 0;`
489
490			`-------------------------`
491			`-- test 1`
492			`-------------------------`
493			`test_inp <= 1;`
494			`-- compute reference coefficients`
495			`ref_matrix := COMPUTE_REF_DCT1D(input_data0,TRUE);`
496
497			`for i in 0 to N-1 loop`
498			`j := 0;`
499			`while(true) loop`
500

Browse

Tools

Subversion Repositories mdct

[/] [mdct/] [trunk/] [source/] [testbench/] [INPIMAGE.VHD] - Blame information for rev 24