isp pipeline pass sim

CMakeLists.txt

@@ -36,23 +36,23 @@ find_package(Threads REQUIRED)
 find_package(SystemCLanguage QUIET)
 
 # Create software image process library
-file(GLOB_RECURSE IMG_SRC ${PROJECT_SOURCE_DIR}/src/img_process/*.cpp)
+# file(GLOB_RECURSE IMG_SRC ${PROJECT_SOURCE_DIR}/src/img_process/*.cpp)
-add_library(img_process STATIC ${IMG_SRC})
+# add_library(img_process STATIC ${IMG_SRC})
 
-# Create a new executable target
+# ----------------------  EXE  ---------------------------
-file(GLOB_RECURSE VISP_SRC ${PROJECT_SOURCE_DIR}/src/*.cpp)
+#                         VISP
-add_executable(Visp ${VISP_SRC})
+# ----------------------  EXE  ---------------------------
+add_executable(Visp ${PROJECT_SOURCE_DIR}/src/sc_main.cpp)
 target_compile_definitions(Visp
   PRIVATE INPUT_IMG="${PROJECT_SOURCE_DIR}/src/transform/test.bin"
   PRIVATE OUTPUT_DIR="${PROJECT_SOURCE_DIR}/logs/"
 )
 target_include_directories(Visp PRIVATE ${PROJECT_SOURCE_DIR}/src/img_process)
-target_link_libraries(Visp PRIVATE img_process)
+# target_link_libraries(Visp PRIVATE img_process)
-# target_compile_features(Visp PUBLIC cxx_std_17)
-# set_property(TARGET Visp PROPERTY CXX_STANDARD ${SystemC_CXX_STANDARD})
 
-# Add the Verilated circuit to the target
+# Get RTL source code dir
 SUBDIRLIST(RTL_SUBDIR ${PROJECT_SOURCE_DIR}/rtl)
+# Add the Verilated circuit to the target
 verilate(Visp SYSTEMC COVERAGE TRACE
   INCLUDE_DIRS ${RTL_SUBDIR}
   VERILATOR_ARGS +librescan +libext+.v+.sv+.vh+.svh -y . -x-assign fast
@@ -62,3 +62,27 @@ verilate(Visp SYSTEMC COVERAGE TRACE
 
 # SystemC Link
 verilator_link_systemc(Visp)
+
+# ----------------------  EXE  ---------------------------
+#                    VISP_Pipeline
+# ----------------------  EXE  ---------------------------
+add_executable(Visp_Pipeline ${PROJECT_SOURCE_DIR}/src/sc_main_pipeline.cpp)
+target_compile_definitions(Visp_Pipeline
+  PRIVATE INPUT_IMG="${PROJECT_SOURCE_DIR}/src/transform/test.bin"
+  PRIVATE OUTPUT_DIR="${PROJECT_SOURCE_DIR}/logs/"
+)
+target_include_directories(Visp_Pipeline PRIVATE ${PROJECT_SOURCE_DIR}/src/img_process)
+# target_link_libraries(Visp_Pipeline PRIVATE img_process)
+
+# Get RTL source code dir
+SUBDIRLIST(RTL_SUBDIR ${PROJECT_SOURCE_DIR}/rtl)
+# Add the Verilated circuit to the target
+verilate(Visp_Pipeline SYSTEMC COVERAGE TRACE
+  INCLUDE_DIRS ${RTL_SUBDIR}
+  VERILATOR_ARGS +librescan +libext+.v+.sv+.vh+.svh -y . -x-assign fast -Wno-WIDTHEXPAND
+  SOURCES ${PROJECT_SOURCE_DIR}/rtl/isp_Pipeline.sv
+  TOP_MODULE isp_Pipeline
+)
+
+# SystemC Link
+verilator_link_systemc(Visp_Pipeline)

rtl/Color/ColorBlender_Pipeline.sv

@@ -1,7 +1,7 @@
 `timescale 1ns / 1ps
 
 // 三通道图像合成一个RGB图像
-module ColorBlender #(
+module ColorBlender_Pipeline #(
     parameter reg [4:0] IN_DEPTH  = 12,  // 输入图像的色深
     parameter reg [4:0] OUT_DEPTH = 8    // 输出图像的色深
 ) (

rtl/Crop/Crop_Pipeline.sv

@@ -1,5 +1,5 @@
 `timescale 1ns / 1ps
-module Crop #(
+module Crop_Pipeline #(
     parameter IN_WIDTH = 512,
     parameter IN_HEIGHT = 512,
     parameter OFFSET_X = 120,

rtl/Demosaic/Demosaic2.sv

@@ -4,7 +4,7 @@ module Demosaic2 #(
     parameter reg [15:0] IM_HEIGHT = 256,  // 图像高度
     parameter reg [ 1:0] RAW_TYPE  = 3,    // 0:grbg 1:rggb 2:bggr 3:gbrg
     parameter reg [ 4:0] DATA_SIZE = 16
-) (
+  ) (
     // 基本信号
     input wire clk,
     input wire reset,
@@ -22,7 +22,7 @@ module Demosaic2 #(
     output reg [DATA_SIZE - 1:0] out_r,
     output reg [DATA_SIZE - 1:0] out_g,
     output reg [DATA_SIZE - 1:0] out_b
-);
+  );
 
 
   // 常量，包括状态机
@@ -42,20 +42,29 @@ module Demosaic2 #(
 
   // 三段状态机实现，窗口滑动，颜色计算
   // 状态切换
-  always @(posedge clk) begin
+  always @(posedge clk)
-    if (reset) state <= READ_DATA;
+  begin
-    else state <= nextState;
+    if (reset)
+      state <= READ_DATA;
+    else
+      state <= nextState;
   end
 
   // 下一状态更新
-  always @(*) begin
+  always @(*)
+  begin
     case (state)
       // 记录够3x3个数据后，进行rgb转换
-      READ_DATA:    nextState = (cnt_data >= 3) ? COLOR_GEN : READ_DATA;
+      READ_DATA:
-      COLOR_GEN:    nextState = SEND_DATA;
+        nextState = (cnt_data >= 3) ? COLOR_GEN : READ_DATA;
-      SEND_DATA:    nextState = (in_receive) ? SLIDE_WINDOW : SEND_DATA;
+      COLOR_GEN:
-      SLIDE_WINDOW: nextState = READ_DATA;
+        nextState = SEND_DATA;
-      default:      nextState = READ_DATA;
+      SEND_DATA:
+        nextState = (in_receive) ? SLIDE_WINDOW : SEND_DATA;
+      SLIDE_WINDOW:
+        nextState = READ_DATA;
+      default:
+        nextState = READ_DATA;
     endcase
   end
 
@@ -65,8 +74,10 @@ module Demosaic2 #(
   assign out_receive = (in_en && state == READ_DATA && !reset) ? 1 : 0;
 
   // 各状态执行的操作
-  always @(posedge clk) begin
+  always @(posedge clk)
-    if (reset) begin
+  begin
+    if (reset)
+    begin
       // 外部输出初始化
       out_en <= 0;
       out_r <= 0;
@@ -78,12 +89,16 @@ module Demosaic2 #(
       pos_y <= 0;
       cnt_data <= 0;
       raw_type <= RAW_TYPE;
-    end else begin
+    end
+    else
+    begin
       // 状态机执行
       case (state)
         // 读取数据
-        READ_DATA: begin
+        READ_DATA:
-          if (in_en) begin
+        begin
+          if (in_en)
+          begin
             data_cache[0 + cnt_data * 3] <= in_data[0];
             data_cache[1 + cnt_data * 3] <= in_data[1];
             data_cache[2 + cnt_data * 3] <= in_data[2];
@@ -92,80 +107,107 @@ module Demosaic2 #(
           end
         end
 
-        COLOR_GEN: begin
+        COLOR_GEN:
+        begin
           // 生成rgb图像
           //  data       case 0      case 1      case 2      case 3
           //  0 3 6      G R G       R G R       B G B       G B G
           //  1 4 7      B G B       G B G       G R G       R G R
           //  2 5 8      G R G       R G R       B G B       G B G
           case (raw_type)
-            0: begin  // Missing B, R on G
+            0:
+            begin  // Missing B, R on G
               blue  <= (data_cache[1] + data_cache[7]) >> 1;
               red   <= (data_cache[3] + data_cache[5]) >> 1;
               green <= data_cache[4];
             end
 
-            1: begin  // Missing G, R on B
+            1:
+            begin  // Missing G, R on B
               green <= (data_cache[1] + data_cache[3] + data_cache[5] + data_cache[7]) >> 2;
               red <= (data_cache[0] + data_cache[2] + data_cache[6] + data_cache[8]) >> 2;
               blue <= data_cache[4];
             end
 
-            2: begin  // Missing G, B on R
+            2:
+            begin  // Missing G, B on R
               green <= (data_cache[1] + data_cache[3] + data_cache[5] + data_cache[7]) >> 2;
               blue <= (data_cache[0] + data_cache[2] + data_cache[6] + data_cache[8]) >> 2;
               red <= data_cache[4];
             end
 
 
-            3: begin  // Missing B, R on G
+            3:
+            begin  // Missing B, R on G
               red   <= (data_cache[1] + data_cache[7]) >> 1;
               blue  <= (data_cache[3] + data_cache[5]) >> 1;
               green <= data_cache[4];
             end
-            default: ;
+            default:
+              ;
           endcase
 
           case (raw_type)
-            0: raw_type <= 1;
+            0:
-            1: raw_type <= 0;
+              raw_type <= 1;
-            2: raw_type <= 3;
+            1:
-            3: raw_type <= 2;
+              raw_type <= 0;
+            2:
+              raw_type <= 3;
+            3:
+              raw_type <= 2;
           endcase
         end
 
-        SEND_DATA: begin
+        SEND_DATA:
-          if (in_ready && !in_receive) begin
+        begin
+          if (in_ready && !in_receive)
+          begin
             out_en <= 1;
             out_r  <= red;
             out_b  <= blue;
             out_g  <= green;
-          end else out_en <= 0;
+            pos_x <= pos_x + 1;
+          end
+          else
+            out_en <= 0;
         end
 
-        SLIDE_WINDOW: begin
+        SLIDE_WINDOW:
+        begin
           // 记录位置寄存器自增，并处理缓存数据
-          pos_x <= pos_x + 1;
+          if (pos_x >= IM_WIDTH - 2)
-          if (pos_x >= IM_WIDTH - 2 - 1) begin
+          begin
             cnt_data <= 0;
             pos_x <= 0;
             pos_y <= pos_y + 1;
-            if (pos_y >= IM_HEIGHT - 2 - 1) begin
+            if (pos_y >= IM_HEIGHT - 2)
+            begin
               pos_y <= 0;
             end
             // 换行后切换Bayer格式
-            if (pos_y % 2 == 1) begin
+            if (pos_y % 2 == 1)
+            begin
               raw_type <= RAW_TYPE;
-            end else begin
+            end
+            else
+            begin
               case (RAW_TYPE)
-                0: raw_type <= 2;
+                0:
-                1: raw_type <= 3;
+                  raw_type <= 2;
-                2: raw_type <= 0;
+                1:
-                3: raw_type <= 1;
+                  raw_type <= 3;
-                default: ;
+                2:
+                  raw_type <= 0;
+                3:
+                  raw_type <= 1;
+                default:
+                  ;
               endcase
             end
-          end else begin
+          end
+          else
+          begin
             cnt_data <= 2;
 
             // 窗口右移
@@ -178,7 +220,8 @@ module Demosaic2 #(
           end
         end
 
-        default: ;
+        default:
+          ;
       endcase
     end
   end

rtl/Demosaic/Demosaic_Pipeline.sv

@@ -1,5 +1,5 @@
 `timescale 1ns / 1ps
-module Demosaic #(
+module Demosaic_Pipeline #(
 parameter WINDOW_LENGTH = 3,
 parameter reg [15:0] TOTAL_WIDTH  = 512+3, // 总图像宽度
 parameter reg [15:0] TOTAL_HEIGHT = 256+3, // 总图像高度

rtl/isp_Pipeline.sv

@@ -1,6 +1,6 @@
 `timescale 1ns / 1ps
 
-module isp #(
+module isp_Pipeline #(
     parameter reg [15:0] IN_WIDTH    = 1936,
     parameter reg [15:0] IN_HEIGHT   = 1088,
     parameter            OFFSET_X    = 7,
@@ -59,7 +59,7 @@ module isp #(
   );
 
 
-  Demosaic #(
+  Demosaic_Pipeline #(
       .WINDOW_LENGTH(3),
       .TOTAL_WIDTH  (IN_WIDTH),
       .TOTAL_HEIGHT (IN_HEIGHT),
@@ -78,7 +78,7 @@ module isp #(
       .out_fsync(Demosaic2_fsync)
   );
 
-  ColorBlender #(
+  ColorBlender_Pipeline #(
       .IN_DEPTH(12),  // 输入图像的色深
       .OUT_DEPTH(COLOR_DEPTH)  // 输出图像的色深
   ) ColorBlender_inst (
@@ -101,7 +101,7 @@ module isp #(
       .enable    (blender_enable)
   );
 
-  Crop #(
+  Crop_Pipeline #(
       .IN_WIDTH   (IN_WIDTH),
       .IN_HEIGHT  (IN_HEIGHT),
       .OFFSET_X   (OFFSET_X),

src/img_process/bmp.cpp

@@ -1,87 +0,0 @@
-#include "bmp.hpp"
-
-#include <iostream>
-
-// 将RGB24格式像素数据封装为BMP图像
-bool write_bmp(const char *filename, uint8_t *data, int32_t width,
-               int32_t height) {
-  BMPFileHeader file_header = {0};
-  BMPInfoHeader info_header = {0};
-  std::ofstream ofs(filename, std::ios::binary);
-  if (!ofs) {
-    std::cerr << "Failed to create file: " << filename << std::endl;
-    return false;
-  }
-  // BMP文件头
-  file_header.type = 0x4D42; // BM
-  file_header.size =
-      sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + width * height * 3;
-  file_header.offset = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
-  ofs.write(reinterpret_cast<char *>(&file_header), sizeof(file_header));
-
-  // BMP位图信息头
-  info_header.size = sizeof(BMPInfoHeader);
-  info_header.width = width;
-  info_header.height = height;
-  info_header.planes = 1;
-  info_header.bit_count = 24;
-  info_header.size_image = width * height * 3;
-  ofs.write(reinterpret_cast<char *>(&info_header), sizeof(info_header));
-
-  // 像素数据
-  int32_t row_size = (((width + 1) * 3) / 4) * 4; // 行字节数，必须为4的倍数
-  uint8_t *row_data = new uint8_t[row_size];
-  for (int32_t y = height - 1; y >= 0; --y) { // BMP图像的行是从下往上存储的
-    for (int32_t x = 0; x < width; ++x) {
-      row_data[x * 3 + 2] = data[(y * width + x) * 3 + 0]; // B
-      row_data[x * 3 + 1] = data[(y * width + x) * 3 + 1]; // G
-      row_data[x * 3 + 0] = data[(y * width + x) * 3 + 2]; // R
-    }
-    ofs.write(reinterpret_cast<char *>(row_data), row_size);
-  }
-  delete[] row_data;
-  ofs.close();
-  return true;
-}
-
-bool writeBMP(std::ofstream &pic_file, std::vector<uint8_t> &pic_data,
-              const int32_t pic_width, const int32_t pic_height) {
-  BMPFileHeader file_header = {0};
-  BMPInfoHeader info_header = {0};
-
-  // Check file
-  if (!pic_file || !pic_file.is_open()) {
-    std::printf("Failed to open file!\n");
-    return false;
-  }
-
-  // Write file header
-  file_header.type = 0x4D42; // BM
-  file_header.size =
-      sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + pic_width * pic_height * 3;
-  file_header.offset = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
-  pic_file.write(reinterpret_cast<char *>(&file_header), sizeof(file_header));
-
-  // Write info header
-  info_header.size = sizeof(BMPInfoHeader);
-  info_header.width = pic_width;
-  info_header.height = pic_height;
-  info_header.planes = 1;
-  info_header.bit_count = 24;
-  info_header.size_image = pic_width * pic_height * 3;
-  pic_file.write(reinterpret_cast<char *>(&info_header), sizeof(info_header));
-
-  // Write BMP
-  int32_t row_size = (((pic_width + 1) * 3) / 4) * 4; // 行字节数，必须为4的倍数
-  uint8_t *row_data = new uint8_t[row_size];
-  for (int32_t y = pic_height - 1; y >= 0; --y) { // BMP图像的行是从下往上存储的
-    for (int32_t x = 0; x < pic_width; ++x) {
-      row_data[x * 3 + 2] = pic_data[(y * pic_width + x) * 3 + 0]; // B
-      row_data[x * 3 + 1] = pic_data[(y * pic_width + x) * 3 + 1]; // G
-      row_data[x * 3 + 0] = pic_data[(y * pic_width + x) * 3 + 2]; // R
-    }
-    pic_file.write(reinterpret_cast<char *>(row_data), row_size);
-  }
-  delete[] row_data;
-  return true;
-}

src/img_process/bmp.hpp

@@ -1,43 +0,0 @@
-#ifndef __BMP_H__
-#define __BMP_H__
-
-#include <stdint.h>
-#include <cstdint>
-#include <cstdio>
-#include <fstream>
-#include <vector>
-
-#pragma pack(push, 1) // 1字节对齐
-
-// BMP文件头结构体
-struct BMPFileHeader {
-  uint16_t type;      // 文件类型，必须为"BM"
-  uint32_t size;      // 文件大小，单位为字节
-  uint16_t reserved1; // 保留字段，必须为0
-  uint16_t reserved2; // 保留字段，必须为0
-  uint32_t offset;    // 像素数据起始位置，单位为字节
-};
-
-// BMP位图信息头结构体
-struct BMPInfoHeader {
-  uint32_t size;            // 信息头大小，必须为40
-  int32_t width;            // 图像宽度，单位为像素
-  int32_t height;           // 图像高度，单位为像素
-  uint16_t planes;          // 颜色平面数，必须为1
-  uint16_t bit_count;       // 每个像素的位数，必须为24
-  uint32_t compression;     // 压缩方式，必须为0
-  uint32_t size_image;      // 像素数据大小，单位为字节
-  int32_t x_pels_per_meter; // X方向像素数/米
-  int32_t y_pels_per_meter; // Y方向像素数/米
-  uint32_t clr_used;        // 使用的颜色数，必须为0
-  uint32_t clr_important;   // 重要的颜色数，必须为0
-};
-
-#pragma pack(pop)
-
-bool write_bmp(const char *filename, uint8_t *data, int32_t width,
-               int32_t height);
-bool writeBMP(std::ofstream &pic_file, std::vector<uint8_t> &pic_data,
-              const int32_t pic_width, const int32_t pic_height);
-
-#endif

src/sc_main.cpp

@@ -1,26 +1,31 @@
-// For std::unique_ptr
+// For read and write
-#include <memory>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <ios>
+#include <iostream>
 
 // SystemC global header
+#include "sysc/communication/sc_signal.h"
+#include "sysc/kernel/sc_module.h"
 #include <systemc>
 
 // Include common routines
+#include <string>
 #include <sys/stat.h> // mkdir
+#include <utility>
+#include <vector>
 #include <verilated.h>
 #include <verilated_vcd_sc.h>
 
 // Include model header, generated from Verilating "isp.v"
 #include "Visp.h"
 
-// Handle file
+// Write Pictures
-#include <fstream>
+#include "bitmap_image.hpp"
-#include <iostream>
-
-// math
-#include <cmath>
-
-#include "bmp.hpp"
 
+// Image Parameters
 static const uint16_t IN_WIDTH = 1936;
 static const uint16_t IN_HEIGHT = 1088;
 static const uint32_t IN_SIZE = (IN_WIDTH * IN_HEIGHT);
@@ -45,65 +50,69 @@ struct color_gain {
 } color_gain{1.1, 0.7, 1.3}, white_gain;
 
 static const double gamma_value = 2.2;
-static const double saturation_inc = 0.5;
+static const double sat_inc = 0.5;
 static const double contrast = 1.2;
-// static const double white_radio = 0.1;
 
 using namespace sc_core;
 using namespace sc_dt;
 
-bool picProcess(uint32_t *image, uint16_t number);
-
 SC_MODULE(TB_ISP) {
   sc_in_clk clk;
-  sc_in<bool> reset;
+  sc_in<bool> rst;
 
-  sc_in<bool> in_ready;
+  sc_in<bool> in_ready;         // next module ready to receive data
-  sc_in<bool> in_receive;
+  sc_out<bool> out_valid;       // next module data valid signal
-  sc_out<bool> out_en;
+  sc_out<uint32_t> out_data[3]; // next module receive data
-  sc_out<uint32_t> out_data[3];
 
-  sc_in<bool> im_en;
+  sc_in<bool> in_valid;    // this module receive data valid signal
-  sc_out<bool> out_ready;
+  sc_out<bool> out_ready;  // this module ready to receive data
-  // sc_out<bool> out_receceive;
+  sc_in<uint32_t> in_data; // this module receive data
-  sc_in<uint32_t> im_data;
 
-  sc_out<bool> is_done;
+  bool is_done;                // when receive all data
-  std::unique_ptr<uint16_t[]> image = std::make_unique<uint16_t[]>(IN_SIZE);
+  std::vector<uint16_t> image; // the data of image
   std::vector<uint32_t> process_image = std::vector<uint32_t>(
       OUT_SIZE, 0); // after isp process, the data of image
 
   SC_CTOR(TB_ISP) {
-    SC_CTHREAD(send_Data, clk.pos());
+    SC_CTHREAD(sendData, clk.pos()); // when clk posedge, exec sendData
-    reset_signal_is(reset, true);
+    reset_signal_is(rst, true);      // set rst signal
 
-    SC_CTHREAD(read_Data, clk.pos());
+    SC_CTHREAD(readData, clk.pos());
+    reset_signal_is(rst, true); // set rst signal
   }
 
-  void send_Data(void) {
+  void sendData(void) {
+    // init var
     uint16_t pos_x = 0, pos_y = 0, cnt_flame = 0;
-    bool is_finish = false;
+    bool is_finish = false; // when send all data
+    // reset
+    out_valid = false;
+    for (auto &data : out_data)
+      data = 0;
+
     while (true) {
-      if (in_ready.read() && !is_finish) {
+      if (in_ready && !is_finish) {
-        out_en.write(1);
+        // valid and send data
-
+        out_valid = true;
-        printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
+        out_data[0] = image[(pos_y + 0) * IN_WIDTH + pos_x];
-               image[(pos_y + 0) * IN_WIDTH + pos_x]);
+        out_data[1] = image[(pos_y + 1) * IN_WIDTH + pos_x];
-        printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
+        out_data[2] = image[(pos_y + 2) * IN_WIDTH + pos_x];
-               image[(pos_y + 1) * IN_WIDTH + pos_x]);
-        printf("x=%4d, y=%4d, data=0x%04x\n", pos_x, pos_y,
-               image[(pos_y + 2) * IN_WIDTH + pos_x]);
-
-        out_data[0].write(image[(pos_y + 0) * IN_WIDTH + pos_x]);
-        out_data[1].write(image[(pos_y + 1) * IN_WIDTH + pos_x]);
-        out_data[2].write(image[(pos_y + 2) * IN_WIDTH + pos_x]);
 
+        // print data
+        std::printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
+                    image[(pos_y + 0) * IN_WIDTH + pos_x]);
+        std::printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
+                    image[(pos_y + 1) * IN_WIDTH + pos_x]);
+        std::printf("x=%4d, y=%4d, data=0x%04x\n", pos_x, pos_y,
+                    image[(pos_y + 2) * IN_WIDTH + pos_x]);
         pos_x++;
+
+        // calculate position and recognize when to finish
         if (pos_x >= IN_WIDTH) {
           pos_x = 0;
           pos_y++;
         }
-        if (pos_y >= IN_HEIGHT - 2) {
+        if (pos_y >= IN_HEIGHT - 1) {
           pos_y = 0;
           cnt_flame++;
         }
@@ -111,55 +120,66 @@ SC_MODULE(TB_ISP) {
           is_finish = true;
         }
       } else {
-        out_en.write(0);
+        out_valid = false;
       }
 
+      // wait for next clk
       wait();
     }
   }
 
-  void read_Data(void) {
+  void readData(void) {
-    is_done.write(0);
+    // init local var
-    uint32_t pos_x = 0, pos_y = 0, cnt_flame = 0;
+    uint16_t pos_x = 0, pos_y = 0, cnt_flame = 0;
     uint32_t last_data = 0, cnt = 0;
     bool is_finish = false;
+    // reset
+    out_ready = false;
+    is_done = false;
+
     while (true) {
-      if (im_en.read() && !is_finish) {
+      if (!is_finish) {
-        out_ready.write(false);
+        out_ready = true;
 
-        process_image[pos_y * OUT_WIDTH + pos_x] = im_data.read();
+        // when data valid, write it down
-        pos_x++;
+        if (in_valid) {
+          process_image[pos_y * OUT_WIDTH + pos_x] = in_data;
 
-        if (pos_x >= OUT_WIDTH) {
+          // calculate position
-          pos_x = 0;
+          pos_x++;
-          pos_y++;
+
-        }
+          if (pos_x >= OUT_WIDTH) {
-        if (pos_y >= OUT_HEIGHT) {
+            pos_x = 0;
-          pos_y = 0;
+            pos_y++;
-          saveData(
+          }
-              ("output_img_" + std::to_string(cnt_flame) + ".bmp").c_str());
+          if (pos_y >= OUT_HEIGHT) {
-          cnt_flame++;
+            pos_y = 0;
-        }
+            saveData(
-        if (cnt_flame >= FLAMES) {
+                ("output_img_" + std::to_string(cnt_flame) + ".bmp").c_str());
-          is_finish = true;
+            cnt_flame++;
+          }
+          if (cnt_flame >= FLAMES) {
+            is_finish = true;
+          }
         }
       } else {
-        out_ready.write(true);
+        out_ready = false;
-        // out_receceive.write(false);
       }
 
-      // when data didn't change some time, it end
+      // when no data send, give finish signal
-      if (last_data == im_data.read() && is_finish) {
+      if (is_finish && (last_data == in_data)) {
         cnt++;
-        if (cnt >= 100000L) {
+        if (cnt >= 100000L) { // when receive many times the same data
-          is_done.write(1);
+          is_done = true;
-          printf("x=%d, y=%d\n", pos_x, pos_y);
+          std::printf("Finish Reading data; pos_x = %d, pos_y = %d\n", pos_x,
+                      pos_y);
         }
       } else {
         cnt = 0;
       }
-      last_data = im_data.read();
+      last_data = in_data;
 
+      // wait for next clk
       wait();
     }
   }
@@ -174,157 +194,53 @@ SC_MODULE(TB_ISP) {
       return false;
     }
 
-    // Transform isp image
-    std::vector<uint8_t> bmp_image(3 * OUT_SIZE);
-    for (int i = 0; i < OUT_SIZE; i++) {
-      bmp_image[3 * i + 0] = (process_image[i] & 0x00ff0000) >> 16;
-      bmp_image[3 * i + 1] = (process_image[i] & 0x0000ff00) >> 8;
-      bmp_image[3 * i + 2] = (process_image[i] & 0x000000ff) >> 0;
-    }
-
     // Write BMP image
-    std::ofstream bmp;
+    bitmap_image bmp(OUT_WIDTH, OUT_HEIGHT);
-    bmp.open(std::string(OUTPUT_DIR) + name);
+    if (!bmp) {
-    if (!bmp.is_open()) {
+      std::cout << "Output Image Open Failed!!!\n";
-      std::cout << "Output File Open Failed!!!\n";
       return false;
     }
-    ret = writeBMP(bmp, bmp_image, OUT_WIDTH, OUT_HEIGHT);
+    for (int y = 0; y < OUT_HEIGHT; y++)
-    bmp.close();
+      for (int x = 0; x < OUT_WIDTH; x++)
+        bmp.set_pixel(x, y,
+                      (process_image[y * OUT_WIDTH + x] & 0x00ff0000) >> 16,
+                      (process_image[y * OUT_WIDTH + x] & 0x0000ff00) >> 8,
+                      (process_image[y * OUT_WIDTH + x] & 0x000000ff) >> 0);
+    bmp.save_image(std::string(OUTPUT_DIR) + name);
     return ret;
   }
 };
 
-bool picProcess(uint32_t *image, uint16_t number) {
-  uint8_t *data = new uint8_t[OUT_WIDTH * OUT_HEIGHT * 3]; // RGB24格式像素数据
-
-  // software algorthms analyze
-  uint32_t red_total = 0, green_total = 0, blue_total = 0;
-  uint8_t red_max = 0, green_max = 0, blue_max = 0;
-  for (int32_t y = 0; y < OUT_HEIGHT; ++y) {
-    for (int32_t x = 0; x < OUT_WIDTH; ++x) {
-      int32_t index = (y * OUT_WIDTH + x) * 3;
-
-      uint8_t red = (image[y * OUT_WIDTH + x] & 0x00ff0000) >> 16;
-      uint8_t green = (image[y * OUT_WIDTH + x] & 0x0000ff00) >> 8;
-      uint8_t blue = (image[y * OUT_WIDTH + x] & 0x000000ff);
-
-      // Adjust gamma line
-      // red = 255 * std::pow(red / 255.0, 1 / gamma_value);
-      // green = 255 * std::pow(green / 255.0, 1 / gamma_value);
-      // blue = 255 * std::pow(blue / 255.0, 1 / gamma_value);
-
-      // Calculate white balance data
-      // red_max = std::max(red_max, red);
-      // green_max = std::max(green_max, green);
-      // blue_max = std::max(blue_max, blue);
-      // red_total += red;
-      // green_total += green;
-      // blue_total += blue;
-
-      // Adjust vibrance
-      // uint8_t max = std::max({red, green, blue});
-      // uint8_t min = std::min({red, green, blue});
-      // double delta = (max - min) / 255.0;
-      // double value = (max + min) / 255.0;
-      // if (delta != 0) {
-      //     double L = value / 2.0;
-      //     // double S = (L <= 0.5) ? delta / value : delta / (2 -
-      //     value); double S = delta / max; double alpha = 0.0; if
-      //     (saturation_inc >= 0) {
-      //         if ((saturation_inc + S) >= 1)
-      //             alpha = S;
-      //         else
-      //             alpha = 1 - saturation_inc;
-      //         alpha = 1 / alpha - 1;
-      //         red = static_cast<uchar>(red + (red - L * 255) * alpha);
-      //         green =
-      //             static_cast<uchar>(green + (green - L * 255) *
-      //             alpha);
-      //         blue = static_cast<uchar>(blue + (blue - L * 255) *
-      //         alpha);
-      //     } else {
-      //         alpha = saturation_inc;
-      //         red = static_cast<uchar>(L * 255 +
-      //                                  (red - L * 255) * (1 + alpha));
-      //         green = static_cast<uchar>(L * 255 +
-      //                                    (green - L * 255) * (1 +
-      //                                    alpha));
-      // blue = static_cast<uchar>(L * 255 +
-      //                                   (blue - L * 255) * (1 +
-      //                                   alpha));
-      //     }
-      // }
-
-      // Contrast enhancement
-      // red = static_cast<uchar>(contrast * (red - 128) + 128);
-      // green = static_cast<uchar>(contrast * (green - 128) + 128);
-      // blue = static_cast<uchar>(contrast * (blue - 128) + 128);
-
-      // save data
-      data[index + 0] = red;   // R
-      data[index + 1] = green; // G
-      data[index + 2] = blue;  // B
-    }
-  }
-
-  // Adjust White Balance : Grey World Color Correction
-  // double K = static_cast<double>(red_total + green_total + blue_total) /
-  //            (3 * OUT_SIZE);
-  // white_gain.red = static_cast<double>(K * OUT_SIZE) / red_total;
-  // white_gain.green = static_cast<double>(K * OUT_SIZE) / green_total;
-  // white_gain.blue = static_cast<double>(K * OUT_SIZE) / blue_total;
-  // printf("Gain: red = %f, green = %f, blue = %f", white_gain.red,
-  //        white_gain.green, white_gain.blue);
-  // for (int32_t y = 0; y < OUT_HEIGHT; ++y) {
-  //     for (int32_t x = 0; x < OUT_WIDTH; ++x) {
-  //         int32_t index = (y * OUT_WIDTH + x) * 3;
-
-  //         data[index + 0] =
-  //             static_cast<uint8_t>(white_gain.red * data[index + 0]);
-  //         data[index + 1] =
-  //             static_cast<uint8_t>(white_gain.green * data[index + 1]);
-  //         data[index + 2] =
-  //             static_cast<uint8_t>(white_gain.blue * data[index + 2]);
-  //     }
-  // }
-
-  // save to bmp
-  std::cout << "Ready to save raw RGB image" << std::endl;
-  char file_name[64] = {0};
-  snprintf(file_name, sizeof(file_name), "pic_%d.bmp", number);
-  write_bmp(file_name, data, OUT_WIDTH, OUT_HEIGHT);
-  delete[] data;
-
-  return true;
-}
-
 int sc_main(int argc, char *argv[]) {
-  std::cout << "Get into sc_main" << std::endl;
+  std::printf("Enter into sc_main\n");
-  // Open image
+
-  std::ifstream in_image;
+  // Open Image
-  in_image.open(INPUT_IMG, std::ios::in | std::ios::binary);
+  std::ifstream image;
-  if (!in_image.is_open()) {
+  image.open(INPUT_IMG, std::ios::in | std::ios::binary);
-    std::cout << "Open image fail" << std::endl;
+  // Check image whether is open
+  if (!image.is_open()) {
+    std::printf("Open Image Failed!!!\n");
     exit(0);
   } else {
-    std::cout << "Ready to sim" << std::endl;
+    std::printf("Open Image Successfully!!!\n");
   }
 
-  // Read image
+  // Read and Transform Image
-  auto buf = std::make_unique<uint8_t[]>(2 * IN_SIZE);
+  std::vector<uint16_t> in_image(IN_SIZE);
-  in_image.read((char *)buf.get(), IN_SIZE * 2);
+  uint8_t *buf = new uint8_t[2 * IN_SIZE];
-  in_image.close();
+  image.read((char *)buf, 2 * IN_SIZE);
-  // Reshape data
-  auto image = std::make_unique<uint16_t[]>(IN_SIZE);
   uint32_t i = 0;
   for (int y = 0; y < IN_HEIGHT; y++) {
     for (int x = 0; x < IN_WIDTH; x++) {
-      image[y * IN_WIDTH + x] = (uint16_t)buf[i] + ((uint16_t)buf[i + 1] << 8);
+      in_image[y * IN_WIDTH + x] =
+          (uint16_t)buf[i] + ((uint16_t)buf[i + 1] << 8);
       i += 2;
     }
   }
-  std::cout << "Finish Reading data" << std::endl;
+  // Close and delete image
+  image.close();
+  delete[] buf;
+  std::printf("Finish Reading Image\n");
 
   // This is a more complicated example, please also see the simpler
   // examples/make_hello_c.
@@ -354,113 +270,112 @@ int sc_main(int argc, char *argv[]) {
   // Define clocks
   sc_clock clk{"clk", 10, SC_NS, 0.5, 3, SC_NS, true};
   // Define interconnect
-  sc_signal<bool> reset;
+  sc_signal<bool> rst;
-
+  // ISP Modules in ports
-  sc_signal<bool> in_en;
+  sc_signal<bool> in_valid;
   sc_signal<bool> in_ready;
-  // sc_signal<bool> in_receive;
   sc_signal<uint32_t> in_data[3];
-
+  // ISP Modules out ports
-  sc_signal<bool> out_clk;
+  sc_signal<bool> out_valid;
-  sc_signal<bool> out_en;
   sc_signal<bool> out_ready;
-  sc_signal<bool> out_receive;
   sc_signal<uint32_t> out_data;
-
+  // ISP Modules Enable Ports
   sc_signal<bool> blender_enable;
+  sc_signal<bool> gamma_enable;
+  sc_signal<bool> white_enable;
+  sc_signal<bool> saturation_enable;
+  // ISP Modules Configurations Ports
   sc_signal<uint32_t> gain_red;
   sc_signal<uint32_t> gain_green;
   sc_signal<uint32_t> gain_blue;
-
-  sc_signal<bool> gamma_enable;
-  sc_signal<uint32_t> gamma_inverse;
-  sc_signal<uint32_t> gamma_table[256];
-
-  sc_signal<uint32_t> white_gain[3];
   sc_signal<uint32_t> flame_rate;
-  sc_signal<bool> white_enable;
+  sc_signal<uint32_t> saturation_inc;
-
+  sc_signal<uint32_t> gamma_table[256];
-  sc_signal<bool> saturation_enable;
+  sc_signal<uint32_t> white_gain[3];
-  sc_signal<uint32_t> saturation_increase;
-
-  sc_signal<bool> flag_done;
 
   // Construct the Verilated model, from inside Visp.h
-  // Using unique_ptr is similar to "Visp* isp = new Visp" then deleting at
+  Visp isp("Visp");
-  // end
+  // isp.clk(clk);
-  const std::unique_ptr<Visp> isp{new Visp{"isp"}};
+  // isp.reset(rst);
-  // Attach Visp's signals to this upper model
+  // // Connect input signal
-  isp->clk(clk);
+  // isp.in_valid(in_valid);
-  isp->reset(reset);
+  // isp.in_ready(in_ready);
-  isp->in_en(in_en);
+  // for (int i = 0; i < 3; i++)
-  isp->in_ready(in_ready);
+  //   isp.in_data[i](in_data[i]);
-  // isp->in_receive(in_receive);
+  // // Connect output signal
-  isp->in_data[0](in_data[0]);
+  // isp.out_valid(out_valid);
-  isp->in_data[1](in_data[1]);
+  // isp.out_ready(out_ready);
-  isp->in_data[2](in_data[2]);
+  // isp.out_data(out_data);
-  isp->out_en(out_en);
+  // // Connect ISP modules enable signal
-  isp->out_ready(out_ready);
+  // isp.blender_enable(blender_enable);
-  isp->out_receive(out_receive);
+  // // Connect ISP modules configuration signal
-  isp->out_data(out_data);
+  // isp.gain_red(gain_red);
+  // isp.gain_green(gain_green);
+  // isp.gain_blue(gain_blue);
 
-  isp->gain_red(gain_red);
+  // ISP Old Version
-  isp->gain_green(gain_green);
+  isp.clk(clk);
-  isp->gain_blue(gain_blue);
+  isp.reset(rst);
-  isp->blender_enable(blender_enable);
+  isp.in_en(in_valid);
+  isp.in_ready(in_ready);
+  for (int i = 0; i < 3; i++)
+    isp.in_data[i](in_data[i]);
+  sc_signal<bool> out_receive;
+  isp.out_receive(out_receive);
+  isp.out_en(out_valid);
+  isp.out_ready(out_ready);
+  isp.out_data(out_data);
+  isp.blender_enable(blender_enable);
+  isp.gamma_enable(gamma_enable);
+  isp.white_enable(white_enable);
+  isp.saturation_enable(saturation_enable);
+  isp.gain_red(gain_red);
+  isp.gain_green(gain_green);
+  isp.gain_blue(gain_blue);
+  isp.flame_rate(flame_rate);
+  isp.saturation_inc(saturation_inc);
+  for (int i = 0; i < 256; i++)
+    isp.gamma_table[i](gamma_table[i]);
+  for (int i = 0; i < 3; i++)
+    isp.white_gain[i](white_gain[i]);
 
-  isp->gamma_enable(gamma_enable);
+  // Construct testbench module
-  // isp->gamma_inverse(gamma_inverse);
+  TB_ISP tb_isp("tb_isp");
+  tb_isp.image = std::move(in_image);
+  tb_isp.clk(clk);
+  tb_isp.rst(rst);
+  // Connect input signal
+  tb_isp.in_valid(out_valid);
+  tb_isp.in_ready(out_ready);
+  tb_isp.in_data(out_data);
+  // Connect output signal
+  tb_isp.out_valid(in_valid);
+  tb_isp.out_ready(in_ready);
+  for (int i = 0; i < 3; i++)
+    tb_isp.out_data[i](in_data[i]);
 
-  isp->white_enable(white_enable);
+  // Set ISP modules parameters
-  isp->flame_rate(flame_rate);
+  // Color Blender
-  isp->white_gain[0](white_gain[0]);
+  blender_enable = true;
-  isp->white_gain[1](white_gain[1]);
-  isp->white_gain[2](white_gain[2]);
-
-  isp->saturation_enable(saturation_enable);
-  isp->saturation_inc(saturation_increase);
-
-  blender_enable = true; // enable color correction
   gain_red = static_cast<uint32_t>(color_gain.red * std::pow(2, 8));
   gain_green = static_cast<uint32_t>(color_gain.green * std::pow(2, 8));
   gain_blue = static_cast<uint32_t>(color_gain.blue * std::pow(2, 8));
-
+  // Gamma table
   gamma_enable = true;
-  gamma_inverse = static_cast<uint32_t>((1.0 / gamma_value) * std::pow(2, 8));
   for (int i = 0; i < 256; i++) {
-    // calculate gamma table
-    isp->gamma_table[i](gamma_table[i]);
     gamma_table[i] =
         static_cast<uint32_t>(255 * pow(i / 255.0, 1.0 / gamma_value));
   }
-
+  // White Correction
   white_enable = true;
   flame_rate = 0;
   white_gain[0] = 255;
   white_gain[1] = 255;
   white_gain[2] = 255;
-
+  // Saturation Correction
   saturation_enable = true;
-  saturation_increase =
+  saturation_inc = (int32_t)((sat_inc >= 0) ? (sat_inc * std::pow(2, 8))
-      (int32_t)((saturation_inc >= 0) ? (saturation_inc * std::pow(2, 8))
+                                            : (sat_inc * std::pow(2, 8)));
-                                      : (saturation_inc * std::pow(2, 8)));
-
-  // Construct testbench module
-  TB_ISP tb_isp("tb_isp");
-  tb_isp.clk(clk);
-  tb_isp.reset(reset);
-  tb_isp.in_ready(out_ready);
-  tb_isp.in_receive(out_receive);
-  tb_isp.out_en(in_en);
-  tb_isp.out_ready(in_ready);
-  // tb_isp.out_receceive(in_receive);
-  tb_isp.out_data[0](in_data[0]);
-  tb_isp.out_data[1](in_data[1]);
-  tb_isp.out_data[2](in_data[2]);
-  tb_isp.im_en(out_en);
-  tb_isp.im_data(out_data);
-  tb_isp.is_done(flag_done);
-  tb_isp.image = std::move(image);
 
   // You must do one evaluation before enabling waves, in order to allow
   // SystemC to interconnect everything for testing.
@@ -473,26 +388,27 @@ int sc_main(int argc, char *argv[]) {
   if (flag && 0 == std::strcmp(flag, "+trace")) {
     std::cout << "Enabling waves into logs/vlt_dump.vcd...\n";
     tfp = new VerilatedVcdSc;
-    isp->trace(tfp, 99); // Trace 99 levels of hierarchy
+    isp.trace(tfp, 99); // Trace 99 levels of hierarchy
     Verilated::mkdir("logs");
     tfp->open("logs/vlt_dump.vcd");
   }
 
   // Simulate until $finish
+  std::cout << "Ready to simulate!\n";
   while (!Verilated::gotFinish()) {
-    // Flush the wave files each cycle so we can immediately see the OUTPUT_DIR
+    // Flush the wave files each cycle so we can immediately see the output
     // Don't do this in "real" programs, do it in an abort() handler instead
     if (tfp)
       tfp->flush();
 
     // Apply inputs
     if (sc_time_stamp() < sc_time(10, SC_NS)) {
-      reset.write(1); // Assert reset
+      rst.write(1); // Assert reset
     } else {
-      reset.write(0); // Deassert reset
+      rst.write(0); // Deassert reset
     }
 
-    if (flag_done.read())
+    if (tb_isp.is_done)
       break;
 
     // Simulate 1ns
@@ -500,7 +416,7 @@ int sc_main(int argc, char *argv[]) {
   }
 
   // Final model cleanup
-  isp->final();
+  isp.final();
 
   // Close trace if opened
   if (tfp) {

src/sc_main.cpp.back

@@ -0,0 +1,525 @@
+// For std::unique_ptr
+#include <cstdint>
+#include <memory>
+
+// SystemC global header
+#include <string>
+#include <systemc>
+
+// Include common routines
+#include <sys/stat.h> // mkdir
+#include <vector>
+#include <verilated.h>
+#include <verilated_vcd_sc.h>
+
+// Include model header, generated from Verilating "isp.v"
+#include "Visp.h"
+
+// Handle file
+#include <fstream>
+#include <iostream>
+
+// math
+#include <cmath>
+
+#include "bitmap_image.hpp"
+
+static const uint16_t IN_WIDTH = 1936;
+static const uint16_t IN_HEIGHT = 1088;
+static const uint32_t IN_SIZE = (IN_WIDTH * IN_HEIGHT);
+static const uint16_t OUT_WIDTH = 1920;
+static const uint16_t OUT_HEIGHT = 1080;
+static const uint32_t OUT_SIZE = (OUT_WIDTH * OUT_HEIGHT);
+static const uint32_t FLAMES = 2;
+
+// Input image path and Output directory path
+#ifndef INPUT_IMG
+const char *INPUT_IMG = "./src/transform/test.bin";
+#endif
+#ifndef OUTPUT_DIR
+const char *OUTPUT_DIR = "./logs/";
+#endif
+
+// color gain for correcting color
+struct color_gain {
+  double red;
+  double green;
+  double blue;
+} color_gain{1.1, 0.7, 1.3}, white_gain;
+
+static const double gamma_value = 2.2;
+static const double saturation_inc = 0.5;
+static const double contrast = 1.2;
+// static const double white_radio = 0.1;
+
+using namespace sc_core;
+using namespace sc_dt;
+
+bool picProcess(uint32_t *image, uint16_t number);
+
+SC_MODULE(TB_ISP) {
+  sc_in_clk clk;
+  sc_in<bool> reset;
+
+  sc_in<bool> in_ready;
+  sc_in<bool> in_receive;
+  sc_out<bool> out_en;
+  sc_out<uint32_t> out_data[3];
+
+  sc_in<bool> im_en;
+  sc_out<bool> out_ready;
+  // sc_out<bool> out_receceive;
+  sc_in<uint32_t> im_data;
+
+  sc_out<bool> is_done;
+  std::vector<uint16_t> image; // the data of image
+  std::vector<uint32_t> process_image = std::vector<uint32_t>(
+      OUT_SIZE, 0); // after isp process, the data of image
+
+  SC_CTOR(TB_ISP) {
+    SC_CTHREAD(send_Data, clk.pos());
+    reset_signal_is(reset, true);
+
+    SC_CTHREAD(read_Data, clk.pos());
+  }
+
+  void send_Data(void) {
+    uint16_t pos_x = 0, pos_y = 0, cnt_flame = 0;
+    bool is_finish = false;
+    while (true) {
+      if (in_ready.read() && !is_finish) {
+        out_en.write(1);
+
+        printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
+               image[(pos_y + 0) * IN_WIDTH + pos_x]);
+        printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
+               image[(pos_y + 1) * IN_WIDTH + pos_x]);
+        printf("x=%4d, y=%4d, data=0x%04x\n", pos_x, pos_y,
+               image[(pos_y + 2) * IN_WIDTH + pos_x]);
+
+        out_data[0].write(image[(pos_y + 0) * IN_WIDTH + pos_x]);
+        out_data[1].write(image[(pos_y + 1) * IN_WIDTH + pos_x]);
+        out_data[2].write(image[(pos_y + 2) * IN_WIDTH + pos_x]);
+
+        pos_x++;
+        if (pos_x >= IN_WIDTH) {
+          pos_x = 0;
+          pos_y++;
+        }
+        if (pos_y >= IN_HEIGHT - 1) {
+          pos_y = 0;
+          cnt_flame++;
+        }
+        if (cnt_flame >= FLAMES) {
+          is_finish = true;
+        }
+      } else {
+        out_en.write(0);
+      }
+
+      wait();
+    }
+  }
+
+  void read_Data(void) {
+    is_done.write(0);
+    uint32_t pos_x = 0, pos_y = 0, cnt_flame = 0;
+    uint32_t last_data = 0, cnt = 0;
+    bool is_finish = false;
+    while (true) {
+      if (im_en.read() && !is_finish) {
+        out_ready.write(false);
+
+        process_image[pos_y * OUT_WIDTH + pos_x] = im_data.read();
+        pos_x++;
+
+        if (pos_x >= OUT_WIDTH) {
+          pos_x = 0;
+          pos_y++;
+        }
+        if (pos_y >= OUT_HEIGHT) {
+          pos_y = 0;
+          saveData(
+              ("output_img_" + std::to_string(cnt_flame) + ".bmp").c_str());
+          cnt_flame++;
+        }
+        if (cnt_flame >= FLAMES) {
+          is_finish = true;
+        }
+      } else {
+        out_ready.write(true);
+        // out_receceive.write(false);
+      }
+
+      // when data didn't change some time, it end
+      if (last_data == im_data.read() && is_finish) {
+        cnt++;
+        if (cnt >= 100000L) {
+          is_done.write(1);
+          printf("x=%d, y=%d\n", pos_x, pos_y);
+        }
+      } else {
+        cnt = 0;
+      }
+      last_data = im_data.read();
+
+      wait();
+    }
+  }
+
+  bool saveData(const char *name) {
+    bool ret = true;
+
+    // Check Image Size
+    if (process_image.size() > OUT_SIZE) {
+      std::cout << "Process Image Over Size!!!\n"
+                << "Image Size:" << process_image.size() << "\n";
+      return false;
+    }
+
+    // Transform isp image
+    // std::vector<uint8_t> bmp_image(3 * OUT_SIZE);
+    // for (int i = 0; i < OUT_SIZE; i++) {
+    //   bmp_image[3 * i + 0] = (process_image[i] & 0x00ff0000) >> 16;
+    //   bmp_image[3 * i + 1] = (process_image[i] & 0x0000ff00) >> 8;
+    //   bmp_image[3 * i + 2] = (process_image[i] & 0x000000ff) >> 0;
+    // }
+
+    // Write BMP image
+    bitmap_image bmp(OUT_WIDTH, OUT_HEIGHT);
+    if (!bmp) {
+      std::cout << "Output Image Open Failed!!!\n";
+      return false;
+    }
+    for (int y = 0; y < OUT_HEIGHT; y++)
+      for (int x = 0; x < OUT_WIDTH; x++)
+        bmp.set_pixel(x, y,
+                      (process_image[y * OUT_WIDTH + x] & 0x00ff0000) >> 16,
+                      (process_image[y * OUT_WIDTH + x] & 0x0000ff00) >> 8,
+                      (process_image[y * OUT_WIDTH + x] & 0x000000ff) >> 0);
+    bmp.save_image(std::string(OUTPUT_DIR) + name);
+    return ret;
+  }
+};
+
+// bool picProcess(uint32_t *image, uint16_t number) {
+//   uint8_t *data = new uint8_t[OUT_WIDTH * OUT_HEIGHT * 3]; //
+//   RGB24格式像素数据
+
+//   // software algorthms analyze
+//   uint32_t red_total = 0, green_total = 0, blue_total = 0;
+//   uint8_t red_max = 0, green_max = 0, blue_max = 0;
+//   for (int32_t y = 0; y < OUT_HEIGHT; ++y) {
+//     for (int32_t x = 0; x < OUT_WIDTH; ++x) {
+//       int32_t index = (y * OUT_WIDTH + x) * 3;
+
+//       uint8_t red = (image[y * OUT_WIDTH + x] & 0x00ff0000) >> 16;
+//       uint8_t green = (image[y * OUT_WIDTH + x] & 0x0000ff00) >> 8;
+//       uint8_t blue = (image[y * OUT_WIDTH + x] & 0x000000ff);
+
+//       // Adjust gamma line
+//       // red = 255 * std::pow(red / 255.0, 1 / gamma_value);
+//       // green = 255 * std::pow(green / 255.0, 1 / gamma_value);
+//       // blue = 255 * std::pow(blue / 255.0, 1 / gamma_value);
+
+//       // Calculate white balance data
+//       // red_max = std::max(red_max, red);
+//       // green_max = std::max(green_max, green);
+//       // blue_max = std::max(blue_max, blue);
+//       // red_total += red;
+//       // green_total += green;
+//       // blue_total += blue;
+
+//       // Adjust vibrance
+//       // uint8_t max = std::max({red, green, blue});
+//       // uint8_t min = std::min({red, green, blue});
+//       // double delta = (max - min) / 255.0;
+//       // double value = (max + min) / 255.0;
+//       // if (delta != 0) {
+//       //     double L = value / 2.0;
+//       //     // double S = (L <= 0.5) ? delta / value : delta / (2 -
+//       //     value); double S = delta / max; double alpha = 0.0; if
+//       //     (saturation_inc >= 0) {
+//       //         if ((saturation_inc + S) >= 1)
+//       //             alpha = S;
+//       //         else
+//       //             alpha = 1 - saturation_inc;
+//       //         alpha = 1 / alpha - 1;
+//       //         red = static_cast<uchar>(red + (red - L * 255) * alpha);
+//       //         green =
+//       //             static_cast<uchar>(green + (green - L * 255) *
+//       //             alpha);
+//       //         blue = static_cast<uchar>(blue + (blue - L * 255) *
+//       //         alpha);
+//       //     } else {
+//       //         alpha = saturation_inc;
+//       //         red = static_cast<uchar>(L * 255 +
+//       //                                  (red - L * 255) * (1 + alpha));
+//       //         green = static_cast<uchar>(L * 255 +
+//       //                                    (green - L * 255) * (1 +
+//       //                                    alpha));
+//       // blue = static_cast<uchar>(L * 255 +
+//       //                                   (blue - L * 255) * (1 +
+//       //                                   alpha));
+//       //     }
+//       // }
+
+//       // Contrast enhancement
+//       // red = static_cast<uchar>(contrast * (red - 128) + 128);
+//       // green = static_cast<uchar>(contrast * (green - 128) + 128);
+//       // blue = static_cast<uchar>(contrast * (blue - 128) + 128);
+
+//       // save data
+//       data[index + 0] = red;   // R
+//       data[index + 1] = green; // G
+//       data[index + 2] = blue;  // B
+//     }
+//   }
+
+//   // Adjust White Balance : Grey World Color Correction
+//   // double K = static_cast<double>(red_total + green_total + blue_total) /
+//   //            (3 * OUT_SIZE);
+//   // white_gain.red = static_cast<double>(K * OUT_SIZE) / red_total;
+//   // white_gain.green = static_cast<double>(K * OUT_SIZE) / green_total;
+//   // white_gain.blue = static_cast<double>(K * OUT_SIZE) / blue_total;
+//   // printf("Gain: red = %f, green = %f, blue = %f", white_gain.red,
+//   //        white_gain.green, white_gain.blue);
+//   // for (int32_t y = 0; y < OUT_HEIGHT; ++y) {
+//   //     for (int32_t x = 0; x < OUT_WIDTH; ++x) {
+//   //         int32_t index = (y * OUT_WIDTH + x) * 3;
+
+//   //         data[index + 0] =
+//   //             static_cast<uint8_t>(white_gain.red * data[index + 0]);
+//   //         data[index + 1] =
+//   //             static_cast<uint8_t>(white_gain.green * data[index + 1]);
+//   //         data[index + 2] =
+//   //             static_cast<uint8_t>(white_gain.blue * data[index + 2]);
+//   //     }
+//   // }
+
+//   // save to bmp
+//   std::cout << "Ready to save raw RGB image" << std::endl;
+//   char file_name[64] = {0};
+//   snprintf(file_name, sizeof(file_name), "pic_%d.bmp", number);
+//   write_bmp(file_name, data, OUT_WIDTH, OUT_HEIGHT);
+//   delete[] data;
+
+//   return true;
+// }
+
+int sc_main(int argc, char *argv[]) {
+  std::printf("Enter into sc_main\n");
+
+  // Open Image
+  std::ifstream image;
+  image.open(INPUT_IMG, std::ios::in | std::ios::binary);
+  // Check image whether is open
+  if (!image.is_open()) {
+    std::printf("Open Image Failed!!!\n");
+    exit(0);
+  } else {
+    std::printf("Open Image Successfully!!!\n");
+  }
+
+  // Read and Transform Image
+  std::vector<uint16_t> in_image(IN_SIZE);
+  uint8_t *buf = new uint8_t[2 * IN_SIZE];
+  image.read((char *)buf, 2 * IN_SIZE);
+  uint32_t i = 0;
+  for (int y = 0; y < IN_HEIGHT; y++) {
+    for (int x = 0; x < IN_WIDTH; x++) {
+      in_image[y * IN_WIDTH + x] =
+          (uint16_t)buf[i] + ((uint16_t)buf[i + 1] << 8);
+      i += 2;
+    }
+  }
+  // Close and delete image
+  image.close();
+  delete[] buf;
+  std::printf("Finish Reading Image\n");
+
+  // This is a more complicated example, please also see the simpler
+  // examples/make_hello_c.
+
+  // Create logs/ directory in case we have traces to put under it
+  Verilated::mkdir("logs");
+
+  // Set debug level, 0 is off, 9 is highest presently used
+  // May be overridden by commandArgs argument parsing
+  Verilated::debug(0);
+
+  // Randomization reset policy
+  // May be overridden by commandArgs argument parsing
+  Verilated::randReset(2);
+
+  // Before any evaluation, need to know to calculate those signals only used
+  // for tracing
+  Verilated::traceEverOn(true);
+
+  // Pass arguments so Verilated code can see them, e.g. $value$plusargs
+  // This needs to be called before you create any model
+  Verilated::commandArgs(argc, argv);
+
+  // General logfile
+  std::ios::sync_with_stdio();
+
+  // Define clocks
+  sc_clock clk{"clk", 10, SC_NS, 0.5, 3, SC_NS, true};
+  // Define interconnect
+  sc_signal<bool> reset;
+
+  sc_signal<bool> in_en;
+  sc_signal<bool> in_ready;
+  // sc_signal<bool> in_receive;
+  sc_signal<uint32_t> in_data[3];
+
+  sc_signal<bool> out_clk;
+  sc_signal<bool> out_en;
+  sc_signal<bool> out_ready;
+  sc_signal<bool> out_receive;
+  sc_signal<uint32_t> out_data;
+
+  sc_signal<bool> blender_enable;
+  sc_signal<uint32_t> gain_red;
+  sc_signal<uint32_t> gain_green;
+  sc_signal<uint32_t> gain_blue;
+
+  sc_signal<bool> gamma_enable;
+  sc_signal<uint32_t> gamma_inverse;
+  sc_signal<uint32_t> gamma_table[256];
+
+  sc_signal<uint32_t> white_gain[3];
+  sc_signal<uint32_t> flame_rate;
+  sc_signal<bool> white_enable;
+
+  sc_signal<bool> saturation_enable;
+  sc_signal<uint32_t> saturation_increase;
+
+  sc_signal<bool> flag_done;
+
+  // Construct the Verilated model, from inside Visp.h
+  // Using unique_ptr is similar to "Visp* isp = new Visp" then deleting at
+  // end
+  const std::unique_ptr<Visp> isp{new Visp{"isp"}};
+  // Attach Visp's signals to this upper model
+  isp->clk(clk);
+  isp->reset(reset);
+  isp->in_en(in_en);
+  isp->in_ready(in_ready);
+  // isp->in_receive(in_receive);
+  isp->in_data[0](in_data[0]);
+  isp->in_data[1](in_data[1]);
+  isp->in_data[2](in_data[2]);
+  isp->out_en(out_en);
+  isp->out_ready(out_ready);
+  isp->out_receive(out_receive);
+  isp->out_data(out_data);
+
+  isp->gain_red(gain_red);
+  isp->gain_green(gain_green);
+  isp->gain_blue(gain_blue);
+  isp->blender_enable(blender_enable);
+
+  isp->gamma_enable(gamma_enable);
+  // isp->gamma_inverse(gamma_inverse);
+
+  isp->white_enable(white_enable);
+  isp->flame_rate(flame_rate);
+  isp->white_gain[0](white_gain[0]);
+  isp->white_gain[1](white_gain[1]);
+  isp->white_gain[2](white_gain[2]);
+
+  isp->saturation_enable(saturation_enable);
+  isp->saturation_inc(saturation_increase);
+
+  blender_enable = true; // enable color correction
+  gain_red = static_cast<uint32_t>(color_gain.red * std::pow(2, 8));
+  gain_green = static_cast<uint32_t>(color_gain.green * std::pow(2, 8));
+  gain_blue = static_cast<uint32_t>(color_gain.blue * std::pow(2, 8));
+
+  gamma_enable = true;
+  gamma_inverse = static_cast<uint32_t>((1.0 / gamma_value) * std::pow(2, 8));
+  for (int i = 0; i < 256; i++) {
+    // calculate gamma table
+    isp->gamma_table[i](gamma_table[i]);
+    gamma_table[i] =
+        static_cast<uint32_t>(255 * pow(i / 255.0, 1.0 / gamma_value));
+  }
+
+  white_enable = true;
+  flame_rate = 0;
+  white_gain[0] = 255;
+  white_gain[1] = 255;
+  white_gain[2] = 255;
+
+  saturation_enable = true;
+  saturation_increase =
+      (int32_t)((saturation_inc >= 0) ? (saturation_inc * std::pow(2, 8))
+                                      : (saturation_inc * std::pow(2, 8)));
+
+  // Construct testbench module
+  TB_ISP tb_isp("tb_isp");
+  tb_isp.clk(clk);
+  tb_isp.reset(reset);
+  tb_isp.in_ready(out_ready);
+  tb_isp.in_receive(out_receive);
+  tb_isp.out_en(in_en);
+  tb_isp.out_ready(in_ready);
+  // tb_isp.out_receceive(in_receive);
+  tb_isp.out_data[0](in_data[0]);
+  tb_isp.out_data[1](in_data[1]);
+  tb_isp.out_data[2](in_data[2]);
+  tb_isp.im_en(out_en);
+  tb_isp.im_data(out_data);
+  tb_isp.is_done(flag_done);
+  tb_isp.image = std::move(in_image);
+
+  // You must do one evaluation before enabling waves, in order to allow
+  // SystemC to interconnect everything for testing.
+  sc_start(SC_ZERO_TIME);
+
+  // If verilator was invoked with --trace argument,
+  // and if at run time passed the +trace argument, turn on tracing
+  VerilatedVcdSc *tfp = nullptr;
+  const char *flag = Verilated::commandArgsPlusMatch("trace");
+  if (flag && 0 == std::strcmp(flag, "+trace")) {
+    std::cout << "Enabling waves into logs/vlt_dump.vcd...\n";
+    tfp = new VerilatedVcdSc;
+    isp->trace(tfp, 99); // Trace 99 levels of hierarchy
+    Verilated::mkdir("logs");
+    tfp->open("logs/vlt_dump.vcd");
+  }
+
+  // Simulate until $finish
+  while (!Verilated::gotFinish()) {
+    // Flush the wave files each cycle so we can immediately see the OUTPUT_DIR
+    // Don't do this in "real" programs, do it in an abort() handler instead
+    if (tfp)
+      tfp->flush();
+
+    // Apply inputs
+    if (sc_time_stamp() < sc_time(10, SC_NS)) {
+      reset.write(1); // Assert reset
+    } else {
+      reset.write(0); // Deassert reset
+    }
+
+    if (flag_done.read())
+      break;
+
+    // Simulate 1ns
+    sc_start(1, SC_NS);
+  }
+
+  // Final model cleanup
+  isp->final();
+
+  // Close trace if opened
+  if (tfp) {
+    tfp->close();
+    tfp = nullptr;
+  }
+
+  // Return good completion status
+  return 0;
+}

src/sc_main_pipeline.cpp

@@ -7,6 +7,8 @@
 #include <iostream>
 
 // SystemC global header
+#include "sysc/communication/sc_signal.h"
+#include "sysc/kernel/sc_module.h"
 #include <systemc>
 
 // Include common routines
@@ -18,12 +20,10 @@
 #include <verilated_vcd_sc.h>
 
 // Include model header, generated from Verilating "isp.v"
-#include "Visp.h"
+#include "Visp_Pipeline.h"
 
 // Write Pictures
-#include "bmp.hpp"
+#include "bitmap_image.hpp"
-#include "sysc/communication/sc_signal.h"
-#include "sysc/kernel/sc_module.h"
 
 // Image Parameters
 static const uint16_t IN_WIDTH = 1936;
@@ -32,13 +32,17 @@ static const uint32_t IN_SIZE = (IN_WIDTH * IN_HEIGHT);
 static const uint16_t OUT_WIDTH = 1920;
 static const uint16_t OUT_HEIGHT = 1080;
 static const uint32_t OUT_SIZE = (OUT_WIDTH * OUT_HEIGHT);
-static const uint32_t CNT_FLAME = 2;
+static const uint32_t FLAMES = 2;
 
 // Input image path and Output directory path
-const char *input = "./src/transform/test.bin";
+#ifndef INPUT_IMG
-const char *output = "./logs/";
+const char *INPUT_IMG = "./src/transform/test.bin";
+#endif
+#ifndef OUTPUT_DIR
+const char *OUTPUT_DIR = "./logs/";
+#endif
 
-// Modules Configuration
+// color gain for correcting color
 struct color_gain {
   double red;
   double green;
@@ -101,16 +105,19 @@ SC_MODULE(TB_ISP) {
                     image[(pos_y + 1) * IN_WIDTH + pos_x]);
         std::printf("x=%4d, y=%4d, data=0x%04x\n", pos_x, pos_y,
                     image[(pos_y + 2) * IN_WIDTH + pos_x]);
+        pos_x++;
 
         // calculate position and recognize when to finish
-        if (++pos_x >= IN_WIDTH) {
+        if (pos_x >= IN_WIDTH) {
           pos_x = 0;
-          if (++pos_y >= IN_HEIGHT - 2) { // demosaic window is 3x3
+          pos_y++;
-            pos_y = 0;
+        }
-            if (++cnt_flame >= CNT_FLAME) {
+        if (pos_y >= IN_HEIGHT - 1) {
-              is_finish = true;
+          pos_y = 0;
-            }
+          cnt_flame++;
-          }
+        }
+        if (cnt_flame >= FLAMES) {
+          is_finish = true;
         }
       } else {
         out_valid = false;
@@ -139,18 +146,20 @@ SC_MODULE(TB_ISP) {
           process_image[pos_y * OUT_WIDTH + pos_x] = in_data;
 
           // calculate position
-          if (++pos_x >= OUT_WIDTH) {
+          pos_x++;
-            pos_x = 0;
-            if (++pos_y >= OUT_HEIGHT) {
-              pos_y = 0;
-              if (++cnt_flame >= CNT_FLAME) {
-                is_finish = true;
-              }
 
-              // Save image
+          if (pos_x >= OUT_WIDTH) {
-              saveData(
+            pos_x = 0;
-                  ("output_img_" + std::to_string(cnt_flame) + ".bmp").c_str());
+            pos_y++;
-            }
+          }
+          if (pos_y >= OUT_HEIGHT) {
+            pos_y = 0;
+            saveData(
+                ("output_img_" + std::to_string(cnt_flame) + ".bmp").c_str());
+            cnt_flame++;
+          }
+          if (cnt_flame >= FLAMES) {
+            is_finish = true;
           }
         }
       } else {
@@ -177,23 +186,27 @@ SC_MODULE(TB_ISP) {
 
   bool saveData(const char *name) {
     bool ret = true;
-    // Transform isp image
+
-    std::vector<uint8_t> bmp_image(3 * OUT_SIZE);
+    // Check Image Size
-    for (int i = 0; i < OUT_SIZE; i++) {
+    if (process_image.size() > OUT_SIZE) {
-      bmp_image[i + 0] = (process_image[i] & 0x00ff0000) >> 16;
+      std::cout << "Process Image Over Size!!!\n"
-      bmp_image[i + 1] = (process_image[i] & 0x0000ff00) >> 8;
+                << "Image Size:" << process_image.size() << "\n";
-      bmp_image[i + 2] = (process_image[i] & 0x000000ff) >> 0;
+      return false;
     }
 
     // Write BMP image
-    std::ofstream bmp;
+    bitmap_image bmp(OUT_WIDTH, OUT_HEIGHT);
-    bmp.open(std::string(output) + name);
+    if (!bmp) {
-    if (!bmp.is_open()) {
+      std::cout << "Output Image Open Failed!!!\n";
-      std::cout << "Output File Open Failed!!!\n";
       return false;
     }
-    ret = writeBMP(bmp, bmp_image, OUT_WIDTH, OUT_HEIGHT);
+    for (int y = 0; y < OUT_HEIGHT; y++)
-    bmp.close();
+      for (int x = 0; x < OUT_WIDTH; x++)
+        bmp.set_pixel(x, y,
+                      (process_image[y * OUT_WIDTH + x] & 0x00ff0000) >> 16,
+                      (process_image[y * OUT_WIDTH + x] & 0x0000ff00) >> 8,
+                      (process_image[y * OUT_WIDTH + x] & 0x000000ff) >> 0);
+    bmp.save_image(std::string(OUTPUT_DIR) + name);
     return ret;
   }
 };
@@ -203,7 +216,7 @@ int sc_main(int argc, char *argv[]) {
 
   // Open Image
   std::ifstream image;
-  image.open(input, std::ios::in | std::ios::binary);
+  image.open(INPUT_IMG, std::ios::in | std::ios::binary);
   // Check image whether is open
   if (!image.is_open()) {
     std::printf("Open Image Failed!!!\n");
@@ -214,13 +227,13 @@ int sc_main(int argc, char *argv[]) {
 
   // Read and Transform Image
   std::vector<uint16_t> in_image(IN_SIZE);
-  char *buf = new char[2 * IN_SIZE];
+  uint8_t *buf = new uint8_t[2 * IN_SIZE];
-  image.read(buf, sizeof(buf));
+  image.read((char *)buf, 2 * IN_SIZE);
   uint32_t i = 0;
   for (int y = 0; y < IN_HEIGHT; y++) {
-    for (int x = 0; x < IN_HEIGHT; x++) {
+    for (int x = 0; x < IN_WIDTH; x++) {
-      in_image[y * IN_HEIGHT + x] =
+      in_image[y * IN_WIDTH + x] =
-          static_cast<uint16_t>(i) + (static_cast<uint16_t>(i + 1) << 8);
+          (uint16_t)buf[i] + ((uint16_t)buf[i + 1] << 8);
       i += 2;
     }
   }
@@ -281,50 +294,24 @@ int sc_main(int argc, char *argv[]) {
   sc_signal<uint32_t> white_gain[3];
 
   // Construct the Verilated model, from inside Visp.h
-  Visp isp("Visp");
+  Visp_Pipeline isp("Visp");
-  // isp.clk(clk);
-  // isp.reset(rst);
-  // // Connect input signal
-  // isp.in_valid(in_valid);
-  // isp.in_ready(in_ready);
-  // for (int i = 0; i < 3; i++)
-  //   isp.in_data[i](in_data[i]);
-  // // Connect output signal
-  // isp.out_valid(out_valid);
-  // isp.out_ready(out_ready);
-  // isp.out_data(out_data);
-  // // Connect ISP modules enable signal
-  // isp.blender_enable(blender_enable);
-  // // Connect ISP modules configuration signal
-  // isp.gain_red(gain_red);
-  // isp.gain_green(gain_green);
-  // isp.gain_blue(gain_blue);
-
-  // ISP Old Version
   isp.clk(clk);
   isp.reset(rst);
-  isp.in_en(in_valid);
+  // Connect input signal
+  isp.in_valid(in_valid);
   isp.in_ready(in_ready);
   for (int i = 0; i < 3; i++)
     isp.in_data[i](in_data[i]);
-  sc_signal<bool> out_receive;
+  // Connect output signal
-  isp.out_receive(out_receive);
+  isp.out_valid(out_valid);
-  isp.out_en(out_valid);
   isp.out_ready(out_ready);
   isp.out_data(out_data);
+  // Connect ISP modules enable signal
   isp.blender_enable(blender_enable);
-  isp.gamma_enable(gamma_enable);
+  // Connect ISP modules configuration signal
-  isp.white_enable(white_enable);
-  isp.saturation_enable(saturation_enable);
   isp.gain_red(gain_red);
   isp.gain_green(gain_green);
   isp.gain_blue(gain_blue);
-  isp.flame_rate(flame_rate);
-  isp.saturation_inc(saturation_inc);
-  for (int i = 0; i < 256; i++)
-    isp.gamma_table[i](gamma_table[i]);
-  for (int i = 0; i < 3; i++)
-    isp.white_gain[i](white_gain[i]);
 
   // Construct testbench module
   TB_ISP tb_isp("tb_isp");

xmake.lua

@@ -16,7 +16,8 @@ target("TB_ISP")
   add_includedirs(
     ".",
     "src",
-    "obj_dir",
+    "build/CMakeFiles/Visp_Pipeline.dir/Visp_Pipeline.dir",
+    "build/CMakeFiles/Visp.dir/Visp.dir",
     "src/img_process",
     INCLUDE_DIRS
   )