Add compression block to TLM TB

Author: jgavillalobos

modules/Makefile

@@ -26,9 +26,10 @@ EDGE_DIR=../edge-detector
 GRAY_DIR=../rgb2gray
 FILTER_DIR=../filter
 UNIFICATION_DIR=../unification
+COMPRESSION_DIR=../compression
 
-SRCDIRS=$(SRCDIR) $(EDGE_DIR)/src $(GRAY_DIR)/src $(FILTER_DIR)/src $(UNIFICATION_DIR)/src
-INCDIR+=-I$(EDGE_DIR)/include -I$(GRAY_DIR)/include -I$(FILTER_DIR)/include -I$(UNIFICATION_DIR)/include
+SRCDIRS=$(SRCDIR) $(EDGE_DIR)/src $(GRAY_DIR)/src $(FILTER_DIR)/src $(UNIFICATION_DIR)/src $(COMPRESSION_DIR)/src
+INCDIR+=-I$(EDGE_DIR)/include -I$(GRAY_DIR)/include -I$(FILTER_DIR)/include -I$(UNIFICATION_DIR)/include -I$(COMPRESSION_DIR)/include
 endif # USING_TLM_TB_EN
 
 ifdef INCLUDE_OPENCV

modules/compression/include/ips_jpg_pv_model.hpp

@@ -81,8 +81,26 @@ SC_MODULE (jpg_output) {
 		image[i]=image[i]-128;
 	}
 	int number_of_blocks = image_rows*image_cols/(BLOCK_ROWS*BLOCK_COLS);
+	printf("number_of_block %0d ROWS %0d COLS %0d\n", number_of_blocks, BLOCK_ROWS, BLOCK_COLS);
+#ifndef USING_TLM_TB_EN
 	int block_output[number_of_blocks][BLOCK_ROWS*BLOCK_COLS] = {0};
 	int block_output_size[number_of_blocks] = {0};
+#else
+  int** block_output = new int*[number_of_blocks];
+  int* block_output_size = new int[number_of_blocks];
+  for (int i = 0; i < number_of_blocks; i++)
+  {
+    block_output[i] = new int[BLOCK_ROWS * BLOCK_COLS];
+  }
+  for (int i = 0; i < number_of_blocks; i++)
+  {
+    block_output_size[i] = 0;
+    for (int j = 0; j < BLOCK_ROWS * BLOCK_COLS; j++)
+    {
+      block_output[i][j] = 0;
+    }
+  }
+#endif // USING_TLM_TB_EN
 	int block_counter = 0;
 	*output_size = 0;
 	for(int row=0; row<image_rows; row+=BLOCK_ROWS)	{
@@ -105,6 +123,14 @@ SC_MODULE (jpg_output) {
 	  image[output_counter]=eob;
 	  output_counter++;
 	}
+#ifdef USING_TLM_TB_EN
+  for (int i = 0; i < number_of_blocks; i++)
+  {
+    delete[] block_output[i];
+  }
+  delete[] block_output;
+  delete[] block_output_size;
+#endif // USING_TLM_TB_EN
   }  
 
   void dct(int row_offset, int col_offset) {

modules/compression/src/ips_jpg_pv_testbench.cpp

@@ -1,3 +1,4 @@
+#ifndef USING_TLM_TB_EN
 #ifdef IPS_JPG_PV_EN
 #define int64  systemc_int64
 #define uint64 systemc_uint64
@@ -91,3 +92,4 @@ int sc_main(int, char*[]) {
 
 }
 #endif // IPS_JPG_PV_EN
+#endif // USING_TLM_TB_EN

modules/router/Makefile

@@ -62,6 +62,11 @@ ifdef USING_TLM_ROUTER_TB_EN
 	LFLAGS += -DUSING_TLM_ROUTER_TB_EN
 endif # USING_TLM_TB_EN
 
+ifdef IPS_JPG_PV_EN
+	CFLAGS += -DIPS_JPG_PV_EN
+	LFLAGS += -DIPS_JPG_PV_EN
+endif # IPS_JPG_PV_EN
+
 .PHONY: print-all
 print-all:
 		@echo "Incdir is $(INCDIR)"

modules/router/run_all.sh

@@ -2,13 +2,13 @@
 
 case $1 in
   "save_log")
-    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 USING_TLM_TB_EN=1 all > output.log
+    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 IPS_JPG_PV_EN=1 USING_TLM_TB_EN=1 all > output.log
     ;;
   "print_all")
-    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 USING_TLM_TB_EN=1 print-all
+    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 IPS_JPG_PV_EN=1 USING_TLM_TB_EN=1 print-all
     ;;
   "compile")
-    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 USING_TLM_TB_EN=1 compile
+    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 IPS_JPG_PV_EN=1 USING_TLM_TB_EN=1 compile
     ;;
   "router_tb")
     make RGB2GRAY_PV_EN=1 EDGE_DETECTOR_AT_EN=1 USING_TLM_ROUTER_TB_EN=1 USING_TLM_TB_EN=1 all > output.log
@@ -17,6 +17,6 @@ case $1 in
     make RGB2GRAY_PV_EN=1 EDGE_DETECTOR_AT_EN=1 USING_TLM_ROUTER_TB_EN=1 USING_TLM_TB_EN=1 all > output.log
     ;;
   *)
-    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 USING_TLM_TB_EN=1 all
+    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 IPS_JPG_PV_EN=1 USING_TLM_TB_EN=1 all
     ;;
 esac

modules/router/src/img_target.cpp

@@ -165,7 +165,7 @@ struct img_target: sc_module
         switch(cmd) {
             case tlm::TLM_READ_COMMAND: {
                 unsigned char* response_data_ptr;
-                response_data_ptr = (unsigned char*)malloc(len);
+                response_data_ptr = new unsigned char[len];
                 this->do_when_read_transaction(response_data_ptr, len, addr);
                 //Add read according to length
                 //-----------DEBUG-----------

modules/router/src/tb_edge_detector_tlm.cpp

@@ -34,10 +34,11 @@ using namespace std;
 #include "ips_filter_tlm.hpp"
 #include "sobel_edge_detector_tlm.hpp"
 #include "unification_pv_model.hpp"
+#include "ips_jpg_pv_model.hpp"
 #include "img_initiator.cpp"
 
-#if !defined(RGB2GRAY_PV_EN) || !defined(EDGE_DETECTOR_AT_EN)
-#error "Not all the required macros (RGB2GRAY_PV_EN and EDGE_DETECTOR_LT_EN) are defined is defined."
+#if !defined(RGB2GRAY_PV_EN) || !defined(IPS_FILTER_LT_EN) || !defined(EDGE_DETECTOR_AT_EN) || !defined(IMG_UNIFICATE_PV_EN) || !defined(IPS_JPG_PV_EN)
+#error "Not all the required macros (RGB2GRAY_PV_EN, IPS_FILTER_LT_EN, EDGE_DETECTOR_AT_EN, IMG_UNIFICATE_PV_EN and IPS_JPG_PV_EN) are defined."
 #endif
 
 SC_MODULE(Tb_top)
@@ -50,6 +51,7 @@ SC_MODULE(Tb_top)
   img_initiator *filter_initiator;
   ips_filter_tlm *filter_DUT;
   img_unification_module* unification_DUT;
+  jpg_output *jpg_comp_DUT;
 
   SC_CTOR(Tb_top)
   {
@@ -61,6 +63,7 @@ SC_MODULE(Tb_top)
     filter_initiator = new img_initiator("filter_initiator");
     filter_DUT = new ips_filter_tlm("filter_DUT");
     unification_DUT = new img_unification_module("unification_DUT");
+    jpg_comp_DUT = new jpg_output("jpg_comp_DUT", IMAG_ROWS, IMAG_COLS);
 
     sobel_initiator->start_img_initiators();
     sobel_initiator->set_delays(sc_time(10, SC_NS), sc_time(10, SC_NS));
@@ -96,6 +99,11 @@ SC_MODULE(Tb_top)
     int current_number_of_pixels = 0;
     float next_target_of_completion = 10.0;
 
+    int local_group_count;
+    int compression_output_size = 0;
+    
+    signed char* compression_results;
+    
     colorImage = imread("../../tools/datagen/src/imgs/car.jpg", IMREAD_UNCHANGED);
 
     if (colorImage.empty())
@@ -170,7 +178,7 @@ SC_MODULE(Tb_top)
 
     for (int i = 0; i < IMAG_ROWS; i++)
     {
-      int local_group_count = 0;
+      local_group_count = 0;
       for (int j = 0; j < IMAG_COLS; j++)
       {
         unsigned char* read_ptr;
@@ -233,7 +241,7 @@ SC_MODULE(Tb_top)
 
     for (int i = 0; i < IMAG_ROWS; i++)
     {
-      int local_group_count = 0;
+      local_group_count = 0;
       for (int j = 0; j < IMAG_COLS; j++)
       {
         unsigned char* local_window_ptr = new unsigned char[9];
@@ -314,7 +322,7 @@ SC_MODULE(Tb_top)
 
     for (int i = 0; i < IMAG_ROWS; i++)
     {
-      int local_group_count = 0;
+      local_group_count = 0;
       for (int j = 0; j < IMAG_COLS; j++)
       {
         unsigned char* local_window_ptr = new unsigned char[16];
@@ -398,6 +406,8 @@ SC_MODULE(Tb_top)
       }
     }
 
+    dbgprint("Finished calculating sobel gradients of the image");
+    
     // Sanity check that the image was written in memory as expected
     for (int i = 0; i < IMAG_ROWS; i++)
     {
@@ -434,9 +444,13 @@ SC_MODULE(Tb_top)
       }
     }
 
+    local_count = 0;
+    current_number_of_pixels = 0;
+    next_target_of_completion = 10.0;
+    
     for (int i = 0; i < IMAG_ROWS; i++)
     {
-      int local_group_count = 0;
+      local_group_count = 0;
       for (int j = 0; j < IMAG_COLS; j++)
       {
         unsigned char* read_ptr;
@@ -495,6 +509,8 @@ SC_MODULE(Tb_top)
       }
     }
 
+    dbgprint("Finished with the unification of the magnitude of the gradients of the image");
+    
     // Sanity check that the image was written in memory as expected
     for (int i = 0; i < IMAG_ROWS; i++)
     {
@@ -506,6 +522,64 @@ SC_MODULE(Tb_top)
       }
     }
 
+    local_count = 0;
+    current_number_of_pixels = 0;
+    next_target_of_completion = 10.0;
+    
+    for (int i = 0; i < IMAG_ROWS; i++)
+    {
+      local_group_count = 0;
+      for (int j = 0; j < IMAG_COLS; j++)
+      {
+        if (local_count == 0)
+        {
+          unsigned char* read_ptr;
+          local_read = new unsigned char[8];
+        
+          dbgprint("Before doing a read in TB");
+          memory_initiator->read(read_ptr, IMG_INPROCESS_A + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), 8 * sizeof(char));
+          dbgprint("After doing a read in TB");
+          memcpy(local_read, read_ptr, 8 * sizeof(char));
+        }
+        
+        jpg_comp_DUT->input_pixel((int)*(local_read + local_count), i, j);
+        
+        if (local_count == 8)
+        {
+          local_count = 0;
+          local_group_count++;
+        }
+      }
+    }
+    
+    jpg_comp_DUT->jpeg_compression(&compression_output_size);
+    
+    local_count = 0;
+    local_group_count = 0;
+    compression_results = new signed char[compression_output_size];
+    for (int i = 0; i < compression_output_size; i++)
+    {
+      jpg_comp_DUT->output_byte(compression_results, i);
+      
+      dbgprint("Data_returned compression_result: %0d", *(compression_results + i));
+      
+      local_count++;
+      
+      if ((local_count == 8))
+      {
+        local_results = reinterpret_cast<unsigned char*>(compression_results + (local_group_count * 8 * sizeof(char)));
+        dbgprint("Before doing a write in TB");
+        sanity_check_address(IMG_COMPRESSED + (local_group_count * 8 * sizeof(char)), IMG_COMPRESSED, IMG_COMPRESSED + IMG_COMPRESSED_SZ);
+        memory_initiator->write(local_results, IMG_COMPRESSED + (local_group_count * 8 * sizeof(char)), 8 * sizeof(char));
+        dbgprint("After doing a write in TB");
+        local_count = 0;
+        local_group_count++;
+      }
+      
+    }
+    
+    dbgprint("Finished with the compression of the image");
+    
     imwrite("grayImagePrevMem.jpg", grayImagePrevMem);
     imwrite("grayImageAfterMem.jpg", grayImageAfterMem);
     imwrite("filteredImagePrevMem.jpg", filteredImagePrevMem);