use cmake to replace makefiel

CMakeLists.txt

@@ -0,0 +1,64 @@
+cmake_minimum_required(VERSION 3.29.6)
+cmake_policy(SET CMP0074 NEW)
+
+project(ISP CXX)
+
+# Add Macro to get all subdir
+MACRO(SUBDIRLIST result curdir)
+  FILE(GLOB children RELATIVE ${curdir} ${curdir}/*)
+  SET(dirlist "")
+  FOREACH(child ${children})
+    IF(IS_DIRECTORY ${curdir}/${child})
+      LIST(APPEND dirlist ${curdir}/${child})
+    ENDIF()
+  ENDFOREACH()
+  SET(${result} ${dirlist})
+ENDMACRO()
+
+# Set C++ Standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED true)
+
+# Find Verilator
+find_package(verilator HINTS $ENV{VERILATOR_ROOT} ${VERILATOR_ROOT})
+if(NOT verilator_FOUND)
+  message(
+        FATAL_ERROR
+        "Verilator was not found. Either install it, or set the VERILATOR_ROOT environment variable"
+    )
+endif()
+
+# SystemC dependencies
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+# Find SystemC using SystemC's CMake integration
+find_package(SystemCLanguage QUIET)
+
+# Create software image process library
+file(GLOB_RECURSE IMG_SRC ${PROJECT_SOURCE_DIR}/src/img_process/*.cpp)
+add_library(img_process STATIC ${IMG_SRC})
+
+# Create a new executable target
+file(GLOB_RECURSE VISP_SRC ${PROJECT_SOURCE_DIR}/src/*.cpp)
+add_executable(Visp ${VISP_SRC})
+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_compile_features(Visp PUBLIC cxx_std_17)
+# set_property(TARGET Visp PROPERTY CXX_STANDARD ${SystemC_CXX_STANDARD})
+
+# Add the Verilated circuit to the target
+SUBDIRLIST(RTL_SUBDIR ${PROJECT_SOURCE_DIR}/rtl)
+verilate(Visp SYSTEMC COVERAGE TRACE
+  INCLUDE_DIRS ${RTL_SUBDIR}
+  VERILATOR_ARGS +librescan +libext+.v+.sv+.vh+.svh -y . -x-assign fast
+  SOURCES ${PROJECT_SOURCE_DIR}/rtl/isp.sv
+  TOP_MODULE isp
+)
+
+# SystemC Link
+verilator_link_systemc(Visp)

FPGA.nix

@@ -8,11 +8,13 @@
     svls
     
     # C/C++
-    gnumake
     xmake
+    gnumake
+    cmake
+    ninja
     gcc
+    neocmakelsp
     clang-tools
-    bear
   ];
   
   # Enable languages support

Makefile

@@ -1,134 +0,0 @@
-######################################################################
-#
-# DESCRIPTION: Verilator Example: Small Makefile
-#
-# This calls the object directory makefile.  That allows the objects to
-# be placed in the "current directory" which simplifies the Makefile.
-#
-# This file ONLY is placed under the Creative Commons Public Domain, for
-# any use, without warranty, 2020 by Wilson Snyder.
-# SPDX-License-Identifier: CC0-1.0
-#
-######################################################################
-# Check for sanity to avoid later confusion
-
-ifneq ($(words $(CURDIR)),1)
- $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
-endif
-
-######################################################################
-# Set up variables
-
-# If $VERILATOR_ROOT isn't in the environment, we assume it is part of a
-# package install, and verilator is in your path. Otherwise find the
-# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
-ifeq ($(VERILATOR_ROOT),)
-VERILATOR = verilator
-VERILATOR_COVERAGE = verilator_coverage
-else
-export VERILATOR_ROOT
-VERILATOR = $(VERILATOR_ROOT)/bin/verilator
-VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
-endif
-
-VERILATOR_FLAGS =
-# Generate SystemC in executable form
-VERILATOR_FLAGS += -sc --exe
-# Generate makefile dependencies (not shown as complicates the Makefile)
-#VERILATOR_FLAGS += -MMD
-# Optimize
-VERILATOR_FLAGS += -x-assign fast
-# Warn abount lint issues; may not want this on less solid designs
-VERILATOR_FLAGS += -Wall
-# Make waveforms
-VERILATOR_FLAGS += --trace
-# Check SystemVerilog assertions
-VERILATOR_FLAGS += --assert
-# Enable multithreading
-VERILATOR_FLAGS += --threads 14
-# Generate coverage analysis
-# VERILATOR_FLAGS += --coverage
-# Run Verilator in debug mode
-#VERILATOR_FLAGS += --debug
-# Add this trace to get a backtrace in gdb
-#VERILATOR_FLAGS += --gdbbt
-# Ignore Some Warnings
-VERILATOR_FLAGS += -Wno-WIDTHEXPAND -Wno-UNUSEDSIGNAL -Wno-UNUSEDPARAM
-
-# Specify top module
-TOP_MODULE = isp
-VERILATOR_FLAGS += --top-module $(TOP_MODULE)
-# Input files for Verilator
-# Verilog/SystemVerilog files
-SOURCES := $(wildcard ./rtl/isp.sv ./rtl/Windows.sv ./rtl/Demosaic/*.sv ./rtl/Crop/*.sv ./rtl/Color/*.sv)
-# C/C++ files
-SOURCES += $(wildcard ./src/*.cpp ./src/transform/*.cpp)
-# Exclude files
-EXCLUDES := $(wildcard )
-VERILATOR_INPUT := $(filter-out $(EXCLUDES), $(SOURCES))
-# Check if SC exists via a verilator call (empty if not)
-SYSTEMC_EXISTS := $(shell $(VERILATOR) --get-supported SYSTEMC)
-
-######################################################################
-
-ifneq ($(SYSTEMC_EXISTS),)
-default: build run
-else
-default: nosc
-endif
-
-lint:
-	@echo "-- Verilator lint check ----"
-	$(VERILATOR) -sc --lint-only $(VERILATOR_INPUT)
-
-build:
-	@echo
-	@echo "-- VERILATE ----------------"
-	$(VERILATOR) $(VERILATOR_FLAGS) $(VERILATOR_INPUT)
-
-	@echo
-	@echo "-- COMPILE -----------------"
-# To compile, we can either
-# 1. Pass --build to Verilator by editing VERILATOR_FLAGS above.
-# 2. Or, run the make rules Verilator does:
-#	$(MAKE) -j -C obj_dir -f Vtop.mk
-# 3. Or, call a submakefile where we can override the rules ourselves:
-	$(MAKE) -j -C obj_dir -f V$(TOP_MODULE).mk
-
-run:
-	@echo
-	@echo "-- RUN ---------------------"
-	obj_dir/V$(TOP_MODULE)
-
-# @echo
-# @echo "-- COVERAGE ----------------"
-# @rm -rf logs/annotated
-# $(VERILATOR_COVERAGE) --annotate logs/annotated logs/coverage.dat
-	@echo "-- FINISH ------------------"
-
-trace:
-	@rm -rf logs
-	@mkdir -p logs
-	obj_dir/V$(TOP_MODULE) +trace
-
-	@echo
-	@echo "-- DONE --------------------"
-	@echo "To see waveforms, open vlt_dump.vcd in a waveform viewer"
-	@echo
-
-
-######################################################################
-# Other targets
-
-nosc:
-	@echo
-	@echo "%Skip: SYSTEMC_INCLUDE not in environment"
-	@echo "(If you have SystemC see the README, and rebuild Verilator)"
-	@echo
-
-show-config:
-	$(VERILATOR) -V
-
-maintainer-copy::
-clean mostlyclean distclean maintainer-clean::
-	-rm -rf obj_dir logs *.log *.dmp *.vpd coverage.dat core

rtl/Color/ColorBlender.sv

@@ -1,5 +1,4 @@
-`timescale 1ns / 1ps
+`timescale 1ns/1ps
-
 // 三通道图像合成一个RGB图像
 module ColorBlender #(
     parameter reg [4:0] IN_DEPTH  = 12,  // 输入图像的色深
@@ -8,20 +7,16 @@ module ColorBlender #(
     input wire clk,
     input wire reset,
 
-    input wire [16 - 1:0] in_data [3],
+    input wire in_en,
-    output reg [OUT_DEPTH - 1:0] out_data [3],
+    input wire [15:0] in_data[3],  // 0:R 1:G 2:B
-    
-    input wire in_valid,
-    output wire out_valid,
-    
-    input wire in_ready,
     output wire out_ready,
+    output wire out_receive,
 
-    input wire in_hsync,
+    // 输出相关
-    input wire in_fsync,
+    input wire in_ready,
-    
+    input wire in_receive,
-    output wire out_hsync,
+    output reg out_en,
-    output wire out_fsync,
+    output reg [OUT_DEPTH - 1:0] out_data[3],
 
     // 颜色校正
     input wire [15:0] gain_red,
@@ -29,71 +24,86 @@ module ColorBlender #(
     input wire [15:0] gain_blue,
     input wire enable
 );
+  localparam reg [2:0] READ_DATA = 0;
+  localparam reg [2:0] CALC_DATA = 1;
+  localparam reg [2:0] SATI_DATA = 2;
+  localparam reg [2:0] SEND_DATA = 3;
 
-  localparam PIPELINE = 4;
+  reg [2:0] state, nextState;
+  reg [32 - 1:0] data_cal[3];  // 用于保存运算结果，防止溢出
 
-  reg [PIPELINE-1:0] pipeline_hsync, pipeline_fsync, pipeline_valid;
-  wire pipeline_flag;
-  assign pipeline_flag = (pipeline_valid[PIPELINE-1] == 0) | (in_ready);
-
-  //out_ready ：只要本模块可以接收数据就一直拉高
-  assign out_ready = pipeline_flag;
-  //out_valid ：只要本模块有数据要发送就一直拉高
-  assign out_valid = pipeline_valid[PIPELINE-1];
-
-  assign out_hsync = pipeline_hsync[PIPELINE-1];
-  assign out_fsync = pipeline_fsync[PIPELINE-1];
-
-  reg [32 - 1:0] data_cal0[3];
-  reg [32 - 1:0] data_cal1[3];
-  reg [32 - 1:0] data_cal2[3];
-
-  integer i;
   always @(posedge clk) begin
-    if(reset) begin
+    if (reset) begin
-      pipeline_valid <= 0;
+      state <= READ_DATA;
-      pipeline_hsync <= 0;
-      pipeline_fsync <= 0;
-      for(i=0;i<3;i=i+1) data_cal0[i] <= 0;
-      for(i=0;i<3;i=i+1) data_cal1[i] <= 0;
-      for(i=0;i<3;i=i+1) data_cal2[i] <= 0;
-      for(i=0;i<3;i=i+1) out_data[i] <= 0;
-    end else if(pipeline_flag) begin
-      /*************   流水    ************/
-      pipeline_valid <= {pipeline_valid[PIPELINE-2:0], in_valid};
-      pipeline_hsync <= {pipeline_hsync[PIPELINE-2:0], in_hsync};
-      pipeline_fsync <= {pipeline_fsync[PIPELINE-2:0], in_fsync};
-      /************* 1:计算1   ************/
-      if(in_valid) begin 
-        data_cal0[0] <= ({16'b0, in_data[0]}) << (8 - (IN_DEPTH - OUT_DEPTH));
-        data_cal0[1] <= ({16'b0, in_data[1]}) << (8 - (IN_DEPTH - OUT_DEPTH));
-        data_cal0[2] <= ({16'b0, in_data[2]}) << (8 - (IN_DEPTH - OUT_DEPTH));
-      end
-      /************* 2:计算2   ************/
-      if(pipeline_valid[0]) begin 
-        if(enable) begin
-          data_cal1[0] <= (data_cal0[0] * {16'b0, gain_red}) >> 16;
-          data_cal1[1] <= (data_cal0[1] * {16'b0, gain_green}) >> 16;
-          data_cal1[2] <= (data_cal0[2] * {16'b0, gain_blue}) >> 16;
     end else begin
-          data_cal1[0] <= data_cal0[0] >> 8;
+      state <= nextState;
-          data_cal1[1] <= data_cal0[1] >> 8;
-          data_cal1[2] <= data_cal0[2] >> 8;
     end
   end
-      /************* 3:计算3   ************/
+
-      if(pipeline_valid[1]) begin 
+  always @(*) begin
-        data_cal2[0] <= (data_cal1[0][31 : OUT_DEPTH] != 0) ? {32{1'b1}} : data_cal1[0];
+    case (state)
-        data_cal2[1] <= (data_cal1[1][31 : OUT_DEPTH] != 0) ? {32{1'b1}} : data_cal1[1];
+      READ_DATA: nextState = (in_en) ? CALC_DATA : READ_DATA;
-        data_cal2[2] <= (data_cal1[2][31 : OUT_DEPTH] != 0) ? {32{1'b1}} : data_cal1[2];
+      CALC_DATA: nextState = SATI_DATA;
+      SATI_DATA: nextState = SEND_DATA;
+      SEND_DATA: nextState = (in_receive) ? READ_DATA : SEND_DATA;
+      default:   nextState = READ_DATA;
+    endcase
   end
-      /************* 4:发送结果  ************/
+
-      if(pipeline_valid[2]) begin 
+  assign out_ready   = (!in_en && state == READ_DATA && !reset) ? 1 : 0;
-        out_data[0] <= data_cal2[0][OUT_DEPTH-1:0];
+  assign out_receive = (in_en && state == READ_DATA && !reset) ? 1 : 0;
-        out_data[1] <= data_cal2[1][OUT_DEPTH-1:0];
+
-        out_data[2] <= data_cal2[2][OUT_DEPTH-1:0];
+  always @(posedge clk) begin
+    if (reset) begin
+      // 初始化
+      data_cal[0] <= 0;
+      data_cal[1] <= 0;
+      data_cal[2] <= 0;
+
+      out_data[0] <= 0;
+      out_data[1] <= 0;
+      out_data[2] <= 0;
+      out_en <= 0;
+    end else begin
+      case (state)
+        READ_DATA: begin
+          if (in_en) begin
+            data_cal[0] <= ({16'b0, in_data[0]}) << (8 - (IN_DEPTH - OUT_DEPTH));
+            data_cal[1] <= ({16'b0, in_data[1]}) << (8 - (IN_DEPTH - OUT_DEPTH));
+            data_cal[2] <= ({16'b0, in_data[2]}) << (8 - (IN_DEPTH - OUT_DEPTH));
           end
         end
+
+        CALC_DATA: begin
+          if (enable) begin
+            data_cal[0] <= (data_cal[0] * {16'b0, gain_red}) >> 16;
+            data_cal[1] <= (data_cal[1] * {16'b0, gain_green}) >> 16;
+            data_cal[2] <= (data_cal[2] * {16'b0, gain_blue}) >> 16;
+          end else begin
+            data_cal[0] <= data_cal[0] >> 8;
+            data_cal[1] <= data_cal[1] >> 8;
+            data_cal[2] <= data_cal[2] >> 8;
+          end
+        end
+
+        SATI_DATA: begin
+          data_cal[0] <= |data_cal[0][31 : OUT_DEPTH] ? {32{1'b1}} : data_cal[0];
+          data_cal[1] <= |data_cal[1][31 : OUT_DEPTH] ? {32{1'b1}} : data_cal[1];
+          data_cal[2] <= |data_cal[2][31 : OUT_DEPTH] ? {32{1'b1}} : data_cal[2];
+        end
+
+        SEND_DATA: begin
+          if (in_ready && !in_receive) begin
+            out_en <= 1;
+            out_data[0] <= data_cal[0][OUT_DEPTH-1:0];
+            out_data[1] <= data_cal[1][OUT_DEPTH-1:0];
+            out_data[2] <= data_cal[2][OUT_DEPTH-1:0];
+          end else out_en <= 0;
+        end
+
+        default: ;
+      endcase
+    end
   end
 
 endmodule

rtl/Color/ColorBlender_Pipeline.sv

@@ -0,0 +1,99 @@
+`timescale 1ns / 1ps
+
+// 三通道图像合成一个RGB图像
+module ColorBlender #(
+    parameter reg [4:0] IN_DEPTH  = 12,  // 输入图像的色深
+    parameter reg [4:0] OUT_DEPTH = 8    // 输出图像的色深
+) (
+    input wire clk,
+    input wire reset,
+    
+    input wire [16 - 1:0] in_data [3],
+    output reg [OUT_DEPTH - 1:0] out_data [3],
+    
+    input wire in_valid,
+    output wire out_valid,
+    
+    input wire in_ready,
+    output wire out_ready,
+    
+    input wire in_hsync,
+    input wire in_fsync,
+    
+    output wire out_hsync,
+    output wire out_fsync,
+
+    // 颜色校正
+    input wire [15:0] gain_red,
+    input wire [15:0] gain_green,
+    input wire [15:0] gain_blue,
+    input wire enable
+);
+
+  localparam PIPELINE = 4;
+
+  reg [PIPELINE-1:0] pipeline_hsync, pipeline_fsync, pipeline_valid;
+  wire pipeline_flag;
+  assign pipeline_flag = (pipeline_valid[PIPELINE-1] == 0) | (in_ready);
+
+  //out_ready ：只要本模块可以接收数据就一直拉高
+  assign out_ready = pipeline_flag;
+  //out_valid ：只要本模块有数据要发送就一直拉高
+  assign out_valid = pipeline_valid[PIPELINE-1];
+
+  assign out_hsync = pipeline_hsync[PIPELINE-1];
+  assign out_fsync = pipeline_fsync[PIPELINE-1];
+
+  reg [32 - 1:0] data_cal0[3];
+  reg [32 - 1:0] data_cal1[3];
+  reg [32 - 1:0] data_cal2[3];
+
+  integer i;
+  always @(posedge clk) begin
+    if(reset) begin
+      pipeline_valid <= 0;
+      pipeline_hsync <= 0;
+      pipeline_fsync <= 0;
+      for(i=0;i<3;i=i+1) data_cal0[i] <= 0;
+      for(i=0;i<3;i=i+1) data_cal1[i] <= 0;
+      for(i=0;i<3;i=i+1) data_cal2[i] <= 0;
+      for(i=0;i<3;i=i+1) out_data[i] <= 0;
+    end else if(pipeline_flag) begin
+      /*************   流水    ************/
+      pipeline_valid <= {pipeline_valid[PIPELINE-2:0], in_valid};
+      pipeline_hsync <= {pipeline_hsync[PIPELINE-2:0], in_hsync};
+      pipeline_fsync <= {pipeline_fsync[PIPELINE-2:0], in_fsync};
+      /************* 1:计算1   ************/
+      if(in_valid) begin 
+        data_cal0[0] <= ({16'b0, in_data[0]}) << (8 - (IN_DEPTH - OUT_DEPTH));
+        data_cal0[1] <= ({16'b0, in_data[1]}) << (8 - (IN_DEPTH - OUT_DEPTH));
+        data_cal0[2] <= ({16'b0, in_data[2]}) << (8 - (IN_DEPTH - OUT_DEPTH));
+      end
+      /************* 2:计算2   ************/
+      if(pipeline_valid[0]) begin 
+        if(enable) begin
+          data_cal1[0] <= (data_cal0[0] * {16'b0, gain_red}) >> 16;
+          data_cal1[1] <= (data_cal0[1] * {16'b0, gain_green}) >> 16;
+          data_cal1[2] <= (data_cal0[2] * {16'b0, gain_blue}) >> 16;
+        end else begin
+          data_cal1[0] <= data_cal0[0] >> 8;
+          data_cal1[1] <= data_cal0[1] >> 8;
+          data_cal1[2] <= data_cal0[2] >> 8;
+        end
+      end
+      /************* 3:计算3   ************/
+      if(pipeline_valid[1]) begin 
+        data_cal2[0] <= (data_cal1[0][31 : OUT_DEPTH] != 0) ? {32{1'b1}} : data_cal1[0];
+        data_cal2[1] <= (data_cal1[1][31 : OUT_DEPTH] != 0) ? {32{1'b1}} : data_cal1[1];
+        data_cal2[2] <= (data_cal1[2][31 : OUT_DEPTH] != 0) ? {32{1'b1}} : data_cal1[2];
+      end
+      /************* 4:发送结果  ************/
+      if(pipeline_valid[2]) begin 
+        out_data[0] <= data_cal2[0][OUT_DEPTH-1:0];
+        out_data[1] <= data_cal2[1][OUT_DEPTH-1:0];
+        out_data[2] <= data_cal2[2][OUT_DEPTH-1:0];
+      end
+    end
+  end
+
+endmodule

rtl/Crop/Crop.sv

@@ -1,106 +1,104 @@
-`timescale 1ns / 1ps
+`timescale 1ns/1ps
 module Crop #(
-    parameter IN_WIDTH = 512,
+    parameter reg [15:0] IN_WIDTH = 1934,
-    parameter IN_HEIGHT = 512,
+    parameter reg [15:0] IN_HEIGHT = 1086,
-    parameter OFFSET_X = 120,
+    parameter reg [15:0] OFFSET_X = 7,
-    parameter OFFSET_Y = 256,
+    parameter reg [15:0] OFFSET_Y = 3,
-    // parameter TRANSLAYT_X = 120,
+    parameter reg [15:0] OUT_WIDTH = 640,
-    // parameter TRANSLAYT_Y = 120,
+    parameter reg [15:0] OUT_HEIGHT = 480,
-    parameter OUT_WIDTH = 512,
+    parameter reg [4:0] COLOR_DEPTH = 8
-    parameter OUT_HEIGHT = 512,
-    parameter BLANK_COLOR = 6'h000000,
-    parameter COLOR_DEPTH = 16
 ) (
     input wire clk,
     input wire reset,
 
-    input  wire [COLOR_DEPTH - 1:0] in_data [3],
+    input wire in_en,
-    output reg  [COLOR_DEPTH - 1:0] out_data[3],
+    output wire out_ready,
-
+    output wire out_receive,
-    input  wire in_valid,
+    input wire [COLOR_DEPTH - 1:0] in_data[3],
-    output reg  out_valid,
 
     input wire in_ready,
-    output wire out_ready,
+    input wire in_receive,
-
+    output reg out_en,
-    input wire in_hsync,
+    output reg [COLOR_DEPTH - 1:0] out_data[3]
-    input wire in_fsync,
-
-    output reg out_hsync,
-    output reg out_fsync
 );
+  reg [1:0] state, nextState;
+  localparam reg [1:0] READ_DATA = 0;
+  localparam reg [1:0] HANDLE_DATA = 1;
+  localparam reg [1:0] SEND_DATA = 2;
 
-  localparam PIPILINE = 3;
+  reg [15:0] cnt_x, cnt_y;
+  reg [COLOR_DEPTH - 1:0] data[3];
+  wire is_valid;
 
-  reg [PIPILINE-1:0] pipeline_valid;
+  // 状态切换
-  wire pipeline_running;
+  always @(posedge clk) begin
-  assign pipeline_running = in_ready | ~pipeline_valid[PIPILINE-1];
+    if (reset) state <= READ_DATA;
+    else state <= nextState;
+  end
 
-  reg [31:0] cnt_x, cnt_y, temp_x, temp_y;
+  // 下一状态更新
-  reg force_dis, force_en;
+  always @(*) begin
-  reg [COLOR_DEPTH-1:0] data_cache0[3];
+    case (state)
-  reg [COLOR_DEPTH-1:0] data_cache1[3];
+      READ_DATA:   nextState = in_en ? HANDLE_DATA : READ_DATA;
+      HANDLE_DATA: nextState = SEND_DATA;
+      SEND_DATA:   nextState = (is_valid && !in_receive) ? SEND_DATA : READ_DATA;
+      default:     nextState = READ_DATA;
+    endcase
+  end
 
-  //out_ready ：只要本模块可以接收数据就一直拉高
+  assign out_ready = (!in_en && state == READ_DATA && !reset) ? 1 : 0;
-  assign out_ready = pipeline_running;
+  assign out_receive = (in_en && state == READ_DATA && !reset) ? 1 : 0;
-  //out_valid ：只要本模块可以发出数据就一直拉高
+  assign is_valid = ((OFFSET_Y <= cnt_y && cnt_y <= (OFFSET_Y + OUT_HEIGHT - 1)) &&
-  assign out_valid = (pipeline_valid[PIPILINE-1] & ~force_dis) | force_en;
+                    (OFFSET_X <= cnt_x && cnt_x <= (OFFSET_X + OUT_WIDTH))) ? 1 : 0;
 
-  //分别表示当前像素: 显示；被裁掉；空。
-  reg [1:0] flag_crop;
-  localparam CROP_ERROR = 2'b00, CROP_KEEP = 2'b01, CROP_GIVE_UP = 2'b10, CROP_BLANK = 2'b11;
-
-  integer i;
   always @(posedge clk) begin
     if (reset) begin
-      pipeline_valid <= 0;
       cnt_x <= 0;
       cnt_y <= 0;
-      for (i = 0; i < 3; i++) data_cache0[i] <= 0;
+      data[0] <= 0;
-      for (i = 0; i < 3; i++) data_cache1[i] <= 0;
+      data[1] <= 0;
-      for (i = 0; i < 3; i++) out_data[i] <= 0;
+      data[2] <= 0;
-      flag_crop <= 0;
-      force_dis <= 0;
-      force_en <= 0;
-      out_hsync <= 0;
-      out_fsync <= 0;
-      temp_x <= 0;
-      temp_y <= 0;
-    end else if (pipeline_running) begin
 
-      pipeline_valid <= {pipeline_valid[PIPILINE-2:0], in_valid};
+      out_en <= 0;
-
+      out_data[0] <= 0;
-      if (in_valid) begin  //when 00
+      out_data[1] <= 0;
-        for (i = 0; i < 3; i++) data_cache0[i] <= in_data[i];
+      out_data[2] <= 0;
-        cnt_x <= (in_hsync) ? (0) : (cnt_x + 1);
+    end else begin
-        cnt_y <= (in_hsync) ? ((in_fsync) ? (0) : (cnt_y + 1)) : (cnt_y);
+      case (state)
+        READ_DATA: begin
+          if (in_en) begin
+            data[0] <= in_data[0];
+            data[1] <= in_data[1];
+            data[2] <= in_data[2];
+          end
         end
 
-      if (pipeline_valid[0]) begin  //when 00
+        HANDLE_DATA: begin
-        for (i = 0; i < 3; i++) data_cache1[i] <= data_cache0[i];
+          if (cnt_x >= IN_WIDTH - 1) begin
-        temp_x <= cnt_x;
+            cnt_x <= 0;
-        temp_y <= cnt_y;
+            cnt_y <= cnt_y + 1;
-        if (cnt_x < OFFSET_X || cnt_y < OFFSET_Y) flag_crop <= CROP_GIVE_UP;
+          end else begin
-        else if (cnt_x < OFFSET_X + OUT_WIDTH && cnt_y < OFFSET_Y + OUT_HEIGHT) begin
+            cnt_x <= cnt_x + 1;
-          if (cnt_x < IN_WIDTH && cnt_y < IN_HEIGHT) flag_crop <= CROP_KEEP;
+          end
-          else flag_crop <= CROP_BLANK;
-        end else flag_crop <= CROP_ERROR;
         end
 
-      if (pipeline_valid[1]) begin
+        SEND_DATA: begin
-        for (i = 0; i < 3; i++) out_data[i] <= data_cache1[i];
+          if (cnt_y >= IN_HEIGHT) begin
-        out_hsync <= (temp_x == OFFSET_X) && (temp_y >= OFFSET_Y);
+            cnt_y <= 0;
-        out_fsync <= (temp_x == OFFSET_X) && (temp_y == OFFSET_Y);
+          end
-        case (flag_crop)
+
-          CROP_ERROR: {force_dis, force_en} <= {1'b1, 1'b0};
+          if (in_ready && !in_receive && is_valid) begin
-          CROP_KEEP: {force_dis, force_en} <= {1'b0, 1'b0};
+            out_en <= 1;
-          CROP_GIVE_UP: {force_dis, force_en} <= {1'b1, 1'b0};
+            out_data[0] <= data[0];
-          CROP_BLANK:
+            out_data[1] <= data[1];
-          {force_dis, force_en} <= {1'b0, 1'b0};  //应该是01, 但我还没写BLANK逻辑
+            out_data[2] <= data[2];
+          end else out_en <= 0;
+        end
+
+        default: ;
+
       endcase
     end
   end
-  end
-
 
 endmodule

rtl/Crop/Crop_Pipeline.sv

@@ -0,0 +1,106 @@
+`timescale 1ns / 1ps
+module Crop #(
+    parameter IN_WIDTH = 512,
+    parameter IN_HEIGHT = 512,
+    parameter OFFSET_X = 120,
+    parameter OFFSET_Y = 256,
+    // parameter TRANSLAYT_X = 120,
+    // parameter TRANSLAYT_Y = 120,
+    parameter OUT_WIDTH = 512,
+    parameter OUT_HEIGHT = 512,
+    parameter BLANK_COLOR = 6'h000000,
+    parameter COLOR_DEPTH = 16
+) (
+    input wire clk,
+    input wire reset,
+
+    input  wire [COLOR_DEPTH - 1:0] in_data [3],
+    output reg  [COLOR_DEPTH - 1:0] out_data[3],
+
+    input  wire in_valid,
+    output reg  out_valid,
+
+    input  wire in_ready,
+    output wire out_ready,
+
+    input wire in_hsync,
+    input wire in_fsync,
+
+    output reg out_hsync,
+    output reg out_fsync
+);
+
+  localparam PIPILINE = 3;
+
+  reg [PIPILINE-1:0] pipeline_valid;
+  wire pipeline_running;
+  assign pipeline_running = in_ready | ~pipeline_valid[PIPILINE-1];
+
+  reg [31:0] cnt_x, cnt_y, temp_x, temp_y;
+  reg force_dis, force_en;
+  reg [COLOR_DEPTH-1:0] data_cache0[3];
+  reg [COLOR_DEPTH-1:0] data_cache1[3];
+
+  //out_ready ：只要本模块可以接收数据就一直拉高
+  assign out_ready = pipeline_running;
+  //out_valid ：只要本模块可以发出数据就一直拉高
+  assign out_valid = (pipeline_valid[PIPILINE-1] & ~force_dis) | force_en;
+
+  //分别表示当前像素: 显示；被裁掉；空。
+  reg [1:0] flag_crop;
+  localparam CROP_ERROR = 2'b00, CROP_KEEP = 2'b01, CROP_GIVE_UP = 2'b10, CROP_BLANK = 2'b11;
+
+  integer i;
+  always @(posedge clk) begin
+    if (reset) begin
+      pipeline_valid <= 0;
+      cnt_x <= 0;
+      cnt_y <= 0;
+      for (i = 0; i < 3; i++) data_cache0[i] <= 0;
+      for (i = 0; i < 3; i++) data_cache1[i] <= 0;
+      for (i = 0; i < 3; i++) out_data[i] <= 0;
+      flag_crop <= 0;
+      force_dis <= 0;
+      force_en <= 0;
+      out_hsync <= 0;
+      out_fsync <= 0;
+      temp_x <= 0;
+      temp_y <= 0;
+    end else if (pipeline_running) begin
+
+      pipeline_valid <= {pipeline_valid[PIPILINE-2:0], in_valid};
+
+      if (in_valid) begin  //when 00
+        for (i = 0; i < 3; i++) data_cache0[i] <= in_data[i];
+        cnt_x <= (in_hsync) ? (0) : (cnt_x + 1);
+        cnt_y <= (in_hsync) ? ((in_fsync) ? (0) : (cnt_y + 1)) : (cnt_y);
+      end
+
+      if (pipeline_valid[0]) begin  //when 00
+        for (i = 0; i < 3; i++) data_cache1[i] <= data_cache0[i];
+        temp_x <= cnt_x;
+        temp_y <= cnt_y;
+        if (cnt_x < OFFSET_X || cnt_y < OFFSET_Y) flag_crop <= CROP_GIVE_UP;
+        else if (cnt_x < OFFSET_X + OUT_WIDTH && cnt_y < OFFSET_Y + OUT_HEIGHT) begin
+          if (cnt_x < IN_WIDTH && cnt_y < IN_HEIGHT) flag_crop <= CROP_KEEP;
+          else flag_crop <= CROP_BLANK;
+        end else flag_crop <= CROP_ERROR;
+      end
+
+      if (pipeline_valid[1]) begin
+        for (i = 0; i < 3; i++) out_data[i] <= data_cache1[i];
+        out_hsync <= (temp_x == OFFSET_X) && (temp_y >= OFFSET_Y);
+        out_fsync <= (temp_x == OFFSET_X) && (temp_y == OFFSET_Y);
+        case (flag_crop)
+          CROP_ERROR: {force_dis, force_en} <= {1'b1, 1'b0};
+          CROP_KEEP: {force_dis, force_en} <= {1'b0, 1'b0};
+          CROP_GIVE_UP: {force_dis, force_en} <= {1'b1, 1'b0};
+          CROP_BLANK:
+          {force_dis, force_en} <= {1'b0, 1'b0};  //应该是01, 但我还没写BLANK逻辑
+        endcase
+      end
+    end
+  end
+
+
+endmodule

rtl/Demosaic/Demosaic2.sv

@@ -0,0 +1,187 @@
+`timescale 1ns/1ps
+module Demosaic2 #(
+    parameter reg [15:0] IM_WIDTH  = 512,  // 图像宽度
+    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,
+
+    // 数据输入信号
+    input wire in_en,
+    input wire [DATA_SIZE - 1:0] in_data [3],     // 数据输入线，0、1、2分别表示第一、二、三行
+    output wire out_ready,            // 数据请求线，高电平：请求三个数据，直到读取完才拉低
+    output wire out_receive,
+
+    // en: 输出数据有效信号，高电平有效
+    input wire in_ready,
+    input wire in_receive,
+    output reg out_en,
+    output reg [DATA_SIZE - 1:0] out_r,
+    output reg [DATA_SIZE - 1:0] out_g,
+    output reg [DATA_SIZE - 1:0] out_b
+);
+
+
+  // 常量，包括状态机
+  // localparam IM_SIZE = IM_HEIGHT * IM_WIDTH;
+  localparam reg [2:0] READ_DATA = 0;
+  localparam reg [2:0] COLOR_GEN = 1;
+  localparam reg [2:0] SEND_DATA = 2;
+  localparam reg [2:0] SLIDE_WINDOW = 3;
+
+  // 寄存器
+  reg [2:0] state, nextState;
+  reg [15:0] data_cache[9];  // 缓存颜色数据，行列3x3
+  reg [15:0] pos_x, pos_y;  // 滑动窗口左上角位置
+  reg [2:0] cnt_data;  // 记录输入数据数量，最大值256
+  reg [1:0] raw_type;
+  reg [15:0] red, blue, green;
+
+  // 三段状态机实现，窗口滑动，颜色计算
+  // 状态切换
+  always @(posedge clk) begin
+    if (reset) state <= READ_DATA;
+    else state <= nextState;
+  end
+
+  // 下一状态更新
+  always @(*) begin
+    case (state)
+      // 记录够3x3个数据后，进行rgb转换
+      READ_DATA:    nextState = (cnt_data >= 3) ? COLOR_GEN : READ_DATA;
+      COLOR_GEN:    nextState = SEND_DATA;
+      SEND_DATA:    nextState = (in_receive) ? SLIDE_WINDOW : SEND_DATA;
+      SLIDE_WINDOW: nextState = READ_DATA;
+      default:      nextState = READ_DATA;
+    endcase
+  end
+
+  // 请求数据
+  assign out_ready   = (cnt_data <= 2 && !in_en && state == READ_DATA && !reset) ? 1 : 0;
+  // 收到数据
+  assign out_receive = (in_en && state == READ_DATA && !reset) ? 1 : 0;
+
+  // 各状态执行的操作
+  always @(posedge clk) begin
+    if (reset) begin
+      // 外部输出初始化
+      out_en <= 0;
+      out_r <= 0;
+      out_g <= 0;
+      out_r <= 0;
+
+      // 内部寄存器初始化
+      pos_x <= 0;
+      pos_y <= 0;
+      cnt_data <= 0;
+      raw_type <= RAW_TYPE;
+    end else begin
+      // 状态机执行
+      case (state)
+        // 读取数据
+        READ_DATA: 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];
+
+            cnt_data <= cnt_data + 1;
+          end
+        end
+
+        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
+              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
+              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
+              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
+              red   <= (data_cache[1] + data_cache[7]) >> 1;
+              blue  <= (data_cache[3] + data_cache[5]) >> 1;
+              green <= data_cache[4];
+            end
+            default: ;
+          endcase
+
+          case (raw_type)
+            0: raw_type <= 1;
+            1: raw_type <= 0;
+            2: raw_type <= 3;
+            3: raw_type <= 2;
+          endcase
+        end
+
+        SEND_DATA: begin
+          if (in_ready && !in_receive) begin
+            out_en <= 1;
+            out_r  <= red;
+            out_b  <= blue;
+            out_g  <= green;
+          end else out_en <= 0;
+        end
+
+        SLIDE_WINDOW: begin
+          // 记录位置寄存器自增，并处理缓存数据
+          pos_x <= pos_x + 1;
+          if (pos_x >= IM_WIDTH - 2 - 1) begin
+            cnt_data <= 0;
+            pos_x <= 0;
+            pos_y <= pos_y + 1;
+            if (pos_y >= IM_HEIGHT - 2 - 1) begin
+              pos_y <= 0;
+            end
+            // 换行后切换Bayer格式
+            if (pos_y % 2 == 1) begin
+              raw_type <= RAW_TYPE;
+            end else begin
+              case (RAW_TYPE)
+                0: raw_type <= 2;
+                1: raw_type <= 3;
+                2: raw_type <= 0;
+                3: raw_type <= 1;
+                default: ;
+              endcase
+            end
+          end else begin
+            cnt_data <= 2;
+
+            // 窗口右移
+            data_cache[0] <= data_cache[3];
+            data_cache[1] <= data_cache[4];
+            data_cache[2] <= data_cache[5];
+            data_cache[3] <= data_cache[6];
+            data_cache[4] <= data_cache[7];
+            data_cache[5] <= data_cache[8];
+          end
+        end
+
+        default: ;
+      endcase
+    end
+  end
+
+endmodule
+

rtl/isp.sv

@@ -1,10 +1,7 @@
-`timescale 1ns / 1ps
+`timescale 1ns/1ps
-
 module isp #(
     parameter reg [15:0] IN_WIDTH    = 1936,
     parameter reg [15:0] IN_HEIGHT   = 1088,
-    parameter            OFFSET_X    = 7,
-    parameter            OFFSET_Y    = 3,
     parameter reg [15:0] OUT_WIDTH   = 1920,
     parameter reg [15:0] OUT_HEIGHT  = 1080,
     parameter reg [ 4:0] COLOR_DEPTH = 8,     // Can't Change!!!
@@ -14,140 +11,196 @@ module isp #(
     input wire clk,
     input wire reset,
 
-    // 数据线
+    // 数据输入信号
+    input wire in_en,
     input wire [15:0] in_data[3],  // 数据输入线，0、1、2分别表示第一、二、三行
+    output wire out_ready,            // 数据请求线，高电平：请求三个数据，直到读取完才拉低
+    output wire out_receive,
+
+    // output wire out_clk,
+    output wire out_en,
     output wire [3 * COLOR_DEPTH - 1:0] out_data,
-
-    // 数据有效信号
-    input  wire in_valid,
-    output wire out_valid,
-
-    // 准备信号
     input wire in_ready,
-    output wire out_ready,
+    // input wire in_receive,
 
     // 颜色校正，低八位为小数位，高八位为整数位
     input wire [15:0] gain_red,
     input wire [15:0] gain_green,
     input wire [15:0] gain_blue,
-    input wire blender_enable  // 是否启用颜色校正
+    input wire blender_enable,  // 是否启用颜色校正
+
+    // Gamma矫正，低八位为小数位
+    // input wire [7:0] gamma_inverse,
+    input wire [7:0] gamma_table[256],
+    input wire gamma_enable,
+
+    // 白平衡
+    input wire [15:0] white_gain[3],
+    input wire [8:0] flame_rate,
+    input wire white_enable,
+
+    // 饱和度校正
+    input wire signed [31:0] saturation_inc,
+    input wire               saturation_enable  // -256~256
 );
+  localparam reg [15:0] BAYER_WIDTH = IN_WIDTH - 2;
+  localparam reg [15:0] BAYER_HEIGHT = IN_HEIGHT - 2;
 
-  wire [15:0] Demosaic2_data[3];
+  wire [COLOR_DEPTH - 1:0] w_out_data[3];
-  wire [15:0] Windows_data[9];
+  assign out_data = {w_out_data[2], w_out_data[1], w_out_data[0]};
-  wire [COLOR_DEPTH - 1 : 0] Blender_data[3];
-  wire [COLOR_DEPTH - 1 : 0] Crop_data[3];
-  wire Windows_valid, Demosaic2_valid, Blender_valid, Crop_valid;
-  wire Windows_ready, Demosaic2_ready, Blender_ready, Crop_ready;
-  wire Demosaic2_hsync, Blender_hsync, Crop_hsync;
-  wire Demosaic2_fsync, Blender_fsync, Crop_fsync;
-  assign out_valid = Crop_valid;
-  assign out_ready = Windows_ready;
-  assign out_data  = {Crop_data[2], Crop_data[1], Crop_data[0]};
 
-  Windows #(
+  // 颜色校正，并改变色深
-      .DATA_WIDTH(16)
+  wire blender_en, blender_ready, blender_receive;
-  ) Windows_inst (
+  wire [15:0] blender_r, blender_g, blender_b;
-      .clk      (clk),
-      .reset    (reset),
-      .in_data  (in_data),
-      .out_data (Windows_data),
-      .in_valid (in_valid),
-      .out_valid(Windows_valid),
-      .in_ready (Demosaic2_ready),
-      .out_ready(Windows_ready)
-  );
 
+  // 裁切图像
+  wire crop_en, crop_ready, crop_receive;  // scaler 请求数据
+  reg [COLOR_DEPTH - 1:0] crop_data[3];
 
-  Demosaic #(
+  // Gamma矫正
-      .WINDOW_LENGTH(3),
+  wire gamma_en, gamma_ready, gamma_receive;
-      .TOTAL_WIDTH  (IN_WIDTH),
+  wire [COLOR_DEPTH - 1 : 0] gamma_data[3];
-      .TOTAL_HEIGHT (IN_HEIGHT),
+
-      .RAW_TYPE     (RAW_TYPE),
+  // 白平衡
-      .DATA_WIDTH   (16)
+  wire white_en, white_ready, white_receive;
-  ) Demosaic2_inst (
+  wire [COLOR_DEPTH - 1 : 0] white_data[3];
-      .clk      (clk),
+
-      .reset    (reset),
+  // 饱和度校正
-      .in_data  (Windows_data),
+  wire saturation_en, saturation_ready, saturation_receive;
-      .out_data (Demosaic2_data),
+  wire [COLOR_DEPTH - 1 : 0] saturation_data[3];
-      .in_valid (Windows_valid),
+
-      .out_valid(Demosaic2_valid),
+  //   reg in_receive;
-      .in_ready (Blender_ready),
+  //   always @(posedge clk) in_receive <= in_en;
-      .out_ready(Demosaic2_ready),
+  wire in_receive;
-      .out_hsync(Demosaic2_hsync),
+  assign in_receive = out_en;
-      .out_fsync(Demosaic2_fsync)
+
+  // assign out_clk = clk;
+
+  Demosaic2 #(
+      .IM_WIDTH (IN_WIDTH),
+      .IM_HEIGHT(IN_HEIGHT),
+      .RAW_TYPE (RAW_TYPE)
+  ) inst_demosaic (
+      .clk(clk),
+      .reset(reset),
+      .in_en(in_en),
+      .in_data(in_data),
+      .out_ready(out_ready),
+      .out_receive(out_receive),
+
+      .out_en(blender_en),
+      .in_ready(blender_ready),
+      .in_receive(blender_receive),
+      .out_r(blender_r),
+      .out_g(blender_g),
+      .out_b(blender_b)
   );
 
   ColorBlender #(
-      .IN_DEPTH(12),  // 输入图像的色深
+      .IN_DEPTH (12),
-      .OUT_DEPTH(COLOR_DEPTH)  // 输出图像的色深
+      .OUT_DEPTH(COLOR_DEPTH)
-  ) ColorBlender_inst (
+  ) inst_blender (
       .clk  (clk),
-      .reset    (reset),
+      .reset(reset),
-      .in_data  (Demosaic2_data),
-      .out_data (Blender_data),
-      .in_valid (Demosaic2_valid),
-      .out_valid(Blender_valid),
-      .in_ready (Crop_ready),
-      .out_ready(Blender_ready),
-      .in_hsync (Demosaic2_hsync),
-      .in_fsync (Demosaic2_fsync),
-      .out_hsync(Blender_hsync),
-      .out_fsync(Blender_fsync),
 
-      .gain_red  (gain_red),
+      .in_en(blender_en),
+      .in_data({blender_b, blender_g, blender_r}),
+      .out_ready(blender_ready),
+      .out_receive(blender_receive),
+
+      .in_ready(crop_ready),
+      .in_receive(crop_receive),
+      .out_en(crop_en),
+      .out_data(crop_data),
+
+      .gain_red(gain_red),
       .gain_green(gain_green),
-      .gain_blue (gain_blue),
+      .gain_blue(gain_blue),
-      .enable    (blender_enable)
+      .enable(blender_enable)
   );
 
   Crop #(
-      .IN_WIDTH   (IN_WIDTH),
+      .IN_WIDTH(BAYER_WIDTH),
-      .IN_HEIGHT  (IN_HEIGHT),
+      .IN_HEIGHT(BAYER_HEIGHT),
-      .OFFSET_X   (OFFSET_X),
+      .OUT_WIDTH(OUT_WIDTH),
-      .OFFSET_Y   (OFFSET_Y),
+      .OUT_HEIGHT(OUT_HEIGHT),
-      .OUT_WIDTH  (OUT_WIDTH),
-      .OUT_HEIGHT (OUT_HEIGHT),
       .COLOR_DEPTH(COLOR_DEPTH)
-  ) Crop_inst (
+  ) inst_crop (
       .clk  (clk),
-      .reset    (reset),
+      .reset(reset),
-      .in_data  (Blender_data),
+
-      .out_data (Crop_data),
+      .in_en(crop_en),
-      .in_valid (Blender_valid),
+      .out_ready(crop_ready),
-      .out_valid(Crop_valid),
+      .out_receive(crop_receive),
-      .in_ready (in_ready),
+      .in_data({crop_data[2], crop_data[1], crop_data[0]}),
-      .out_ready(Crop_ready),
+
-      .in_hsync (Blender_hsync),
+      .out_en(white_en),
-      .in_fsync (Blender_fsync),
+      .in_ready(white_ready),
-      .out_hsync(Crop_hsync),
+      .in_receive(white_receive),
-      .out_fsync(Crop_fsync)
+      .out_data({white_data[2], white_data[1], white_data[0]})
   );
 
-  // reg [15:0] data_out_temp[8192];
+  GreyWorld #(
-  // reg [31:0] now;
+      .COLOR_DEPTH(COLOR_DEPTH),
-  // reg [2:0] cnt_www;
+      .IM_SIZE({16'b0, OUT_WIDTH} * {16'b0, OUT_HEIGHT})
-  // reg flag_ifdataerror;
+  ) inst_whitebalance (
+      .clk  (clk),
+      .reset(reset),
 
-  // initial cnt_www = 0;
+      .in_en(white_en),
-  // always @(posedge reset) begin
+      .in_data(white_data),
-  //     cnt_www <= cnt_www + 1;
+      .out_ready(white_ready),
-  // end
+      .out_receive(white_receive),
 
-  // integer i;
+      .in_ready(gamma_ready),
-  // always @(posedge clk) begin
+      .in_receive(gamma_receive),
-  //     if(reset) begin
+      .out_en(gamma_en),
-  //         flag_ifdataerror <= 0;
+      .out_data(gamma_data),
-  //         if(cnt_www==1) for(i=0;i<8192;i=i+1) data_out_temp[i] <= 0;
+
-  //         now <= 0;
+      .enable(white_enable),
-  //     end else if(Crop_valid && in_ready)begin
+      .flame_rate(flame_rate),
-  //         now <= now + 1;
+      .white_gain(white_gain)
-  //         if(cnt_www==1)begin
+  );
-  //             if(now<8192) data_out_temp[now] <= Crop_data[0];
+
-  //         end else if(cnt_www==2)begin
+  // 查找表型Gamma校正
-  //             flag_ifdataerror <= (data_out_temp[now] != Crop_data[0]);
+  GammaCorrection #(
-  //         end else flag_ifdataerror <= flag_ifdataerror;
+      .COLOR_DEPTH(COLOR_DEPTH)
-  //     end
+  ) inst_gamma (
-  // end
+      .clk  (clk),
+      .reset(reset),
+
+      .in_en(gamma_en),
+      .in_data(gamma_data),
+      .out_ready(gamma_ready),
+      .out_receive(gamma_receive),
+
+      .in_ready(saturation_ready),
+      .in_receive(saturation_receive),
+      .out_en(saturation_en),
+      .out_data(saturation_data),
+
+      .gamma_table(gamma_table),
+      .enable(gamma_enable)
+  );
+
+  SaturationCorrection #(
+      .COLOR_DEPTH(COLOR_DEPTH)
+  ) inst_saturation (
+      .clk  (clk),
+      .reset(reset),
+
+      .in_en(saturation_en),
+      .out_ready(saturation_ready),
+      .out_receive(saturation_receive),
+      .in_data(saturation_data),
+
+      .in_ready(in_ready),
+      .in_receive(in_receive),
+      .out_en(out_en),
+      .out_data(w_out_data),
+
+      .saturation_inc(saturation_inc),
+      .enable(saturation_enable)
+  );
 
 endmodule

rtl/isp_Pipeline.sv

@@ -0,0 +1,153 @@
+`timescale 1ns / 1ps
+
+module isp #(
+    parameter reg [15:0] IN_WIDTH    = 1936,
+    parameter reg [15:0] IN_HEIGHT   = 1088,
+    parameter            OFFSET_X    = 7,
+    parameter            OFFSET_Y    = 3,
+    parameter reg [15:0] OUT_WIDTH   = 1920,
+    parameter reg [15:0] OUT_HEIGHT  = 1080,
+    parameter reg [ 4:0] COLOR_DEPTH = 8,     // Can't Change!!!
+    parameter reg [ 1:0] RAW_TYPE    = 3      // 0:grbg 1:rggb 2:bggr 3:gbrg
+) (
+    // 基本信号
+    input wire clk,
+    input wire reset,
+
+    // 数据线
+    input wire [15:0] in_data[3],  // 数据输入线，0、1、2分别表示第一、二、三行
+    output wire [3 * COLOR_DEPTH - 1:0] out_data,
+
+    // 数据有效信号
+    input  wire in_valid,
+    output wire out_valid,
+
+    // 准备信号
+    input  wire in_ready,
+    output wire out_ready,
+
+    // 颜色校正，低八位为小数位，高八位为整数位
+    input wire [15:0] gain_red,
+    input wire [15:0] gain_green,
+    input wire [15:0] gain_blue,
+    input wire blender_enable  // 是否启用颜色校正
+);
+
+  wire [15:0] Demosaic2_data[3];
+  wire [15:0] Windows_data[9];
+  wire [COLOR_DEPTH - 1 : 0] Blender_data[3];
+  wire [COLOR_DEPTH - 1 : 0] Crop_data[3];
+  wire Windows_valid, Demosaic2_valid, Blender_valid, Crop_valid;
+  wire Windows_ready, Demosaic2_ready, Blender_ready, Crop_ready;
+  wire Demosaic2_hsync, Blender_hsync, Crop_hsync;
+  wire Demosaic2_fsync, Blender_fsync, Crop_fsync;
+  assign out_valid = Crop_valid;
+  assign out_ready = Windows_ready;
+  assign out_data  = {Crop_data[2], Crop_data[1], Crop_data[0]};
+
+  Windows #(
+      .DATA_WIDTH(16)
+  ) Windows_inst (
+      .clk      (clk),
+      .reset    (reset),
+      .in_data  (in_data),
+      .out_data (Windows_data),
+      .in_valid (in_valid),
+      .out_valid(Windows_valid),
+      .in_ready (Demosaic2_ready),
+      .out_ready(Windows_ready)
+  );
+
+
+  Demosaic #(
+      .WINDOW_LENGTH(3),
+      .TOTAL_WIDTH  (IN_WIDTH),
+      .TOTAL_HEIGHT (IN_HEIGHT),
+      .RAW_TYPE     (RAW_TYPE),
+      .DATA_WIDTH   (16)
+  ) Demosaic2_inst (
+      .clk      (clk),
+      .reset    (reset),
+      .in_data  (Windows_data),
+      .out_data (Demosaic2_data),
+      .in_valid (Windows_valid),
+      .out_valid(Demosaic2_valid),
+      .in_ready (Blender_ready),
+      .out_ready(Demosaic2_ready),
+      .out_hsync(Demosaic2_hsync),
+      .out_fsync(Demosaic2_fsync)
+  );
+
+  ColorBlender #(
+      .IN_DEPTH(12),  // 输入图像的色深
+      .OUT_DEPTH(COLOR_DEPTH)  // 输出图像的色深
+  ) ColorBlender_inst (
+      .clk      (clk),
+      .reset    (reset),
+      .in_data  (Demosaic2_data),
+      .out_data (Blender_data),
+      .in_valid (Demosaic2_valid),
+      .out_valid(Blender_valid),
+      .in_ready (Crop_ready),
+      .out_ready(Blender_ready),
+      .in_hsync (Demosaic2_hsync),
+      .in_fsync (Demosaic2_fsync),
+      .out_hsync(Blender_hsync),
+      .out_fsync(Blender_fsync),
+
+      .gain_red  (gain_red),
+      .gain_green(gain_green),
+      .gain_blue (gain_blue),
+      .enable    (blender_enable)
+  );
+
+  Crop #(
+      .IN_WIDTH   (IN_WIDTH),
+      .IN_HEIGHT  (IN_HEIGHT),
+      .OFFSET_X   (OFFSET_X),
+      .OFFSET_Y   (OFFSET_Y),
+      .OUT_WIDTH  (OUT_WIDTH),
+      .OUT_HEIGHT (OUT_HEIGHT),
+      .COLOR_DEPTH(COLOR_DEPTH)
+  ) Crop_inst (
+      .clk      (clk),
+      .reset    (reset),
+      .in_data  (Blender_data),
+      .out_data (Crop_data),
+      .in_valid (Blender_valid),
+      .out_valid(Crop_valid),
+      .in_ready (in_ready),
+      .out_ready(Crop_ready),
+      .in_hsync (Blender_hsync),
+      .in_fsync (Blender_fsync),
+      .out_hsync(Crop_hsync),
+      .out_fsync(Crop_fsync)
+  );
+
+  // reg [15:0] data_out_temp[8192];
+  // reg [31:0] now;
+  // reg [2:0] cnt_www;
+  // reg flag_ifdataerror;
+
+  // initial cnt_www = 0;
+  // always @(posedge reset) begin
+  //     cnt_www <= cnt_www + 1;
+  // end
+
+  // integer i;
+  // always @(posedge clk) begin
+  //     if(reset) begin
+  //         flag_ifdataerror <= 0;
+  //         if(cnt_www==1) for(i=0;i<8192;i=i+1) data_out_temp[i] <= 0;
+  //         now <= 0;
+  //     end else if(Crop_valid && in_ready)begin
+  //         now <= now + 1;
+  //         if(cnt_www==1)begin
+  //             if(now<8192) data_out_temp[now] <= Crop_data[0];
+  //         end else if(cnt_www==2)begin
+  //             flag_ifdataerror <= (data_out_temp[now] != Crop_data[0]);
+  //         end else flag_ifdataerror <= flag_ifdataerror;
+  //     end
+  // end
+
+endmodule

src/img_process/bmp.cpp

@@ -0,0 +1,87 @@
+#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

@@ -0,0 +1,43 @@
+#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

@@ -10,14 +10,504 @@
 #include <verilated_vcd_sc.h>
 
 // Include model header, generated from Verilating "isp.v"
-#include "obj_dir/Visp.h"
+#include "Visp.h"
-#include "tb_isp.hpp"
 
-// Read/Write Files
+// Handle file
 #include <fstream>
 #include <iostream>
 
-int sc_main(int argc, const char** argv) {
+// math
+#include <cmath>
 
+#include "bmp.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::unique_ptr<uint16_t[]> image = std::make_unique<uint16_t[]>(IN_SIZE);
+  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 - 2) {
+          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
+    std::ofstream bmp;
+    bmp.open(std::string(OUTPUT_DIR) + name);
+    if (!bmp.is_open()) {
+      std::cout << "Output File Open Failed!!!\n";
+      return false;
+    }
+    ret = writeBMP(bmp, bmp_image, OUT_WIDTH, OUT_HEIGHT);
+    bmp.close();
+    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;
+  // Open image
+  std::ifstream in_image;
+  in_image.open(INPUT_IMG, std::ios::in | std::ios::binary);
+  if (!in_image.is_open()) {
+    std::cout << "Open image fail" << std::endl;
+    exit(0);
+  } else {
+    std::cout << "Ready to sim" << std::endl;
+  }
+
+  // Read image
+  auto buf = std::make_unique<uint8_t[]>(2 * IN_SIZE);
+  in_image.read((char *)buf.get(), IN_SIZE * 2);
+  in_image.close();
+  // 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);
+      i += 2;
+    }
+  }
+  std::cout << "Finish Reading data" << std::endl;
+
+  // 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(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.cpp.bak

@@ -1,294 +1,233 @@
-// 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 <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 <iostream>
-
-// math
-#include <cmath>
-
 #include "bmp.hpp"
+#include "sysc/communication/sc_signal.h"
+#include "sysc/kernel/sc_module.h"
 
+// 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);
 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;
+static const uint32_t CNT_FLAME = 2;
 
-// color gain for correcting color
+// Input image path and Output directory path
+const char *input = "./src/transform/test.bin";
+const char *output = "./logs/";
+
+// Modules Configuration
 struct color_gain {
   double red;
   double green;
   double blue;
-} color_gain{ 1.1, 0.7, 1.3 }, white_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_out<bool> out_valid;
+  sc_out<bool> out_valid;       // next module data valid signal
-  sc_out<uint32_t> out_data[3];
+  sc_out<uint32_t> out_data[3]; // next module receive data
 
-  sc_in<bool> im_clk;
+  sc_in<bool> in_valid;    // this module receive data valid signal
-  sc_in<bool> im_en;
+  sc_out<bool> out_ready;  // this module ready to receive data
-  sc_out<bool> out_ready;
+  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::unique_ptr<uint32_t[]> out = std::make_unique<uint32_t[]>(OUT_SIZE);
+  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, im_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
-    while (true) {
+    // reset
-      if (in_ready.read() && !is_finish) {
+    out_valid = false;
-        out_valid.write(1);
+    for (auto &data : out_data)
+      data = 0;
 
-        printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
+    while (true) {
+      if (in_ready && !is_finish) {
+        // valid and send data
+        out_valid = true;
+        out_data[0] = image[(pos_y + 0) * IN_WIDTH + pos_x];
+        out_data[1] = image[(pos_y + 1) * IN_WIDTH + pos_x];
+        out_data[2] = 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]);
-        printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
+        std::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,
+        std::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]);
+        // calculate position and recognize when to finish
-        out_data[1].write(image[(pos_y + 1) * IN_WIDTH + pos_x]);
+        if (++pos_x >= IN_WIDTH) {
-        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 - 2) { // demosaic window is 3x3
-        }
-        if (pos_y >= IN_HEIGHT - 2) {
             pos_y = 0;
-          cnt_flame++;
+            if (++cnt_flame >= CNT_FLAME) {
-        }
-        if (cnt_flame >= FLAMES) {
               is_finish = true;
             }
           }
-      else {
+        }
-        out_valid.write(0);
+      } else {
+        out_valid = false;
       }
 
+      // wait for next clk
       wait();
     }
   }
 
-  void read_Data(void) {
+  void readData(void) {
-    is_done.write(0);
+    // init local var
     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) {
-
-      // when not finish, read data
       if (!is_finish) {
-        out_ready.write(true);
+        out_ready = true;
-        if (im_en.read()) {
-          out[pos_y * OUT_WIDTH + pos_x] = im_data.read();
 
-          pos_x++;
+        // when data valid, write it down
-          if (pos_x >= IN_WIDTH) {
+        if (in_valid) {
+          process_image[pos_y * OUT_WIDTH + pos_x] = in_data;
+
+          // calculate position
+          if (++pos_x >= OUT_WIDTH) {
             pos_x = 0;
-            pos_y++;
+            if (++pos_y >= OUT_HEIGHT) {
-          }
-          if (pos_y >= IN_HEIGHT - 2) {
               pos_y = 0;
-            cnt_flame++;
+              if (++cnt_flame >= CNT_FLAME) {
-          }
+                is_finish = true;
-        }
-      }
-      else {
-        out_ready.write(false);
               }
 
-      // when data didn't change some time, it end
+              // Save image
-      if (last_data == im_data.read() && is_finish) {
+              saveData(
+                  ("output_img_" + std::to_string(cnt_flame) + ".bmp").c_str());
+            }
+          }
+        }
+      } else {
+        out_ready = false;
+      }
+
+      // when no data send, give finish signal
+      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 {
-      else {
         cnt = 0;
       }
-      last_data = im_data.read();
+      last_data = in_data;
 
+      // wait for next clk
       wait();
     }
   }
+
+  bool saveData(const char *name) {
+    bool ret = true;
+    // Transform isp image
+    std::vector<uint8_t> bmp_image(3 * OUT_SIZE);
+    for (int i = 0; i < OUT_SIZE; i++) {
+      bmp_image[i + 0] = (process_image[i] & 0x00ff0000) >> 16;
+      bmp_image[i + 1] = (process_image[i] & 0x0000ff00) >> 8;
+      bmp_image[i + 2] = (process_image[i] & 0x000000ff) >> 0;
+    }
+
+    // Write BMP image
+    std::ofstream bmp;
+    bmp.open(std::string(output) + name);
+    if (!bmp.is_open()) {
+      std::cout << "Output File Open Failed!!!\n";
+      return false;
+    }
+    ret = writeBMP(bmp, bmp_image, OUT_WIDTH, OUT_HEIGHT);
+    bmp.close();
+    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("./transform/test.bin", std::ios::in | std::ios::binary);
+  std::ifstream image;
-  if (!in_image.is_open()) {
+  image.open(input, 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 {
-  else {
+    std::printf("Open Image Successfully!!!\n");
-    std::cout << "Ready to sim" << std::endl;
   }
 
-  // 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);
+  char *buf = new char[2 * IN_SIZE];
-  in_image.close();
+  image.read(buf, sizeof(buf));
-  // 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++) {
+    for (int x = 0; x < IN_HEIGHT; x++) {
-      image[y * IN_WIDTH + x] =
+      in_image[y * IN_HEIGHT + x] =
-        (uint16_t)buf[i] + ((uint16_t)buf[i + 1] << 8);
+          static_cast<uint16_t>(i) + (static_cast<uint16_t>(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.
@@ -316,110 +255,114 @@ int sc_main(int argc, char *argv[]) {
   std::ios::sync_with_stdio();
 
   // Define clocks
-  sc_clock clk{ "clk", 10, SC_NS, 0.5, 3, SC_NS, true };
+  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_valid;
   sc_signal<bool> in_ready;
   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_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 the end
+  Visp isp("Visp");
-  const std::unique_ptr<Visp> isp{ new Visp{"isp"} };
+  // isp.clk(clk);
-  // Attach Visp's signals to this upper model
+  // isp.reset(rst);
-  isp->clk(clk);
+  // // Connect input signal
-  isp->reset(reset);
+  // isp.in_valid(in_valid);
-  isp->in_valid(in_valid);
+  // isp.in_ready(in_ready);
-  isp->in_ready(in_ready);
+  // for (int i = 0; i < 3; i++)
-  isp->in_data[0](in_data[0]);
+  //   isp.in_data[i](in_data[i]);
-  isp->in_data[1](in_data[1]);
+  // // Connect output signal
-  isp->in_data[2](in_data[2]);
+  // isp.out_valid(out_valid);
-  isp->out_valid(out_valid);
+  // isp.out_ready(out_ready);
-  isp->out_ready(out_ready);
+  // isp.out_data(out_data);
-  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->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);
-  // isp->gamma_enable(gamma_enable);
+  for (int i = 0; i < 3; i++)
-  // isp->gamma_inverse(gamma_inverse);
+    isp.in_data[i](in_data[i]);
-
+  sc_signal<bool> out_receive;
-  // isp->white_enable(white_enable);
+  isp.out_receive(out_receive);
-  // isp->flame_rate(flame_rate);
+  isp.out_en(out_valid);
-  // isp->white_gain[0](white_gain[0]);
+  isp.out_ready(out_ready);
-  // isp->white_gain[1](white_gain[1]);
+  isp.out_data(out_data);
-  // isp->white_gain[2](white_gain[2]);
+  isp.blender_enable(blender_enable);
-
+  isp.gamma_enable(gamma_enable);
-  // isp->saturation_enable(saturation_enable);
+  isp.white_enable(white_enable);
-  // isp->saturation_inc(saturation_increase);
+  isp.saturation_enable(saturation_enable);
-
+  isp.gain_red(gain_red);
-  // blender_enable = true;  // enable color correction
+  isp.gain_green(gain_green);
-  // gain_red = static_cast<uint32_t>(color_gain.red * std::pow(2, 8));
+  isp.gain_blue(gain_blue);
-  // gain_green = static_cast<uint32_t>(color_gain.green * std::pow(2, 8));
+  isp.flame_rate(flame_rate);
-  // gain_blue = static_cast<uint32_t>(color_gain.blue * std::pow(2, 8));
+  isp.saturation_inc(saturation_inc);
-
+  for (int i = 0; i < 256; i++)
-  // gamma_enable = true;
+    isp.gamma_table[i](gamma_table[i]);
-  // gamma_inverse = static_cast<uint32_t>((1.0 / gamma_value) * std::pow(2, 8));
+  for (int i = 0; i < 3; i++)
-  // for (int i = 0; i < 256; i++) {
+    isp.white_gain[i](white_gain[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.image = std::move(in_image);
   tb_isp.clk(clk);
-  tb_isp.reset(reset);
+  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);
-  // tb_isp.out_receceive(in_receive);
+  for (int i = 0; i < 3; i++)
-  tb_isp.out_data[0](in_data[0]);
+    tb_isp.out_data[i](in_data[i]);
-  tb_isp.out_data[1](in_data[1]);
+
-  tb_isp.out_data[2](in_data[2]);
+  // Set ISP modules parameters
-  tb_isp.im_clk(out_clk);
+  // Color Blender
-  tb_isp.im_en(out_valid);
+  blender_enable = true;
-  tb_isp.im_data(out_data);
+  gain_red = static_cast<uint32_t>(color_gain.red * std::pow(2, 8));
-  tb_isp.is_done(flag_done);
+  gain_green = static_cast<uint32_t>(color_gain.green * std::pow(2, 8));
-  tb_isp.image = move(image);
+  gain_blue = static_cast<uint32_t>(color_gain.blue * std::pow(2, 8));
+  // Gamma table
+  gamma_enable = true;
+  for (int i = 0; i < 256; 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_inc = (int32_t)((sat_inc >= 0) ? (sat_inc * std::pow(2, 8))
+                                            : (sat_inc * std::pow(2, 8)));
 
   // You must do one evaluation before enabling waves, in order to allow
   // SystemC to interconnect everything for testing.
@@ -432,33 +375,35 @@ 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
     // Don't do this in "real" programs, do it in an abort() handler instead
-    if (tfp) tfp->flush();
+    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 {
-    else {
+      rst.write(0); // Deassert reset
-      reset.write(0);  // Deassert reset
     }
 
-    if (flag_done.read()) break;
+    if (tb_isp.is_done)
+      break;
 
     // Simulate 1ns
     sc_start(1, SC_NS);
   }
 
   // Final model cleanup
-  isp->final();
+  isp.final();
 
   // Close trace if opened
   if (tfp) {

src/tb_isp.hpp

@@ -1,24 +0,0 @@
-#ifndef __TB_ISP_HPP__
-#define __TB_ISP_HPP__
-
-#include "sysc/communication/sc_signal_ports.h"
-#include <systemc>
-
-namespace testbench {
-using namespace sc_core;
-using namespace sc_dt;
-
-SC_MODULE(TB_ISP) {
-  sc_in_clk clk;
-  sc_in<bool> rst;
-
-  sc_in<bool> in_ready;
-  sc_out<bool> out_valid;
-  sc_out<sc_uint<8>> out_data[3];
-
-  sc_in<uint32_t> in_data;
-};
-
-} // namespace testbench
-
-#endif

src/transform/bmp.cpp

@@ -1,46 +0,0 @@
-#include "bmp.hpp"
-
-#include <fstream>
-#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;
-}

src/transform/bmp.hpp

@@ -1,35 +0,0 @@
-#ifndef __BMP_H__
-#define __BMP_H__
-
-#include <stdint.h>
-#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);
-
-#endif

xmake.lua

@@ -7,9 +7,16 @@ local INCLUDE_DIRS = path.splitenv(
 
 target("TB_ISP")
   set_toolchains("gcc")
+  set_languages("c++17")
   --- C/C++ Codes
   add_files(
     "src/**.cpp"
   )
   --- Include directories
-  add_includedirs("src", ".", INCLUDE_DIRS)
+  add_includedirs(
+    ".",
+    "src",
+    "obj_dir",
+    "src/img_process",
+    INCLUDE_DIRS
+  )