isp pipeline pass sim

This commit is contained in:
SikongJueluo 2024-10-03 17:06:40 +08:00
parent 35e6ab1e85
commit c807c24456
No known key found for this signature in database
13 changed files with 5924 additions and 556 deletions

View File

@ -36,23 +36,23 @@ find_package(Threads REQUIRED)
find_package(SystemCLanguage QUIET) find_package(SystemCLanguage QUIET)
# Create software image process library # 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 target_compile_definitions(Visp
PRIVATE INPUT_IMG="${PROJECT_SOURCE_DIR}/src/transform/test.bin" PRIVATE INPUT_IMG="${PROJECT_SOURCE_DIR}/src/transform/test.bin"
PRIVATE OUTPUT_DIR="${PROJECT_SOURCE_DIR}/logs/" PRIVATE OUTPUT_DIR="${PROJECT_SOURCE_DIR}/logs/"
) )
target_include_directories(Visp PRIVATE ${PROJECT_SOURCE_DIR}/src/img_process) 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) SUBDIRLIST(RTL_SUBDIR ${PROJECT_SOURCE_DIR}/rtl)
# Add the Verilated circuit to the target
verilate(Visp SYSTEMC COVERAGE TRACE verilate(Visp SYSTEMC COVERAGE TRACE
INCLUDE_DIRS ${RTL_SUBDIR} INCLUDE_DIRS ${RTL_SUBDIR}
VERILATOR_ARGS +librescan +libext+.v+.sv+.vh+.svh -y . -x-assign fast VERILATOR_ARGS +librescan +libext+.v+.sv+.vh+.svh -y . -x-assign fast
@ -62,3 +62,27 @@ verilate(Visp SYSTEMC COVERAGE TRACE
# SystemC Link # SystemC Link
verilator_link_systemc(Visp) 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)

View File

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

View File

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

View File

@ -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 end
// 下一状态更新 // 下一状态更新
always @(*) begin always @(*)
begin
case (state) case (state)
// 记录够3x3个数据后进行rgb转换 // 记录够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 endcase
end end
@ -65,8 +74,10 @@ module Demosaic2 #(
assign out_receive = (in_en && state == READ_DATA && !reset) ? 1 : 0; 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_en <= 0;
out_r <= 0; out_r <= 0;
@ -78,12 +89,16 @@ module Demosaic2 #(
pos_y <= 0; pos_y <= 0;
cnt_data <= 0; cnt_data <= 0;
raw_type <= RAW_TYPE; raw_type <= RAW_TYPE;
end else begin end
else
begin
// 状态机执行 // 状态机执行
case (state) 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[0 + cnt_data * 3] <= in_data[0];
data_cache[1 + cnt_data * 3] <= in_data[1]; data_cache[1 + cnt_data * 3] <= in_data[1];
data_cache[2 + cnt_data * 3] <= in_data[2]; data_cache[2 + cnt_data * 3] <= in_data[2];
@ -92,80 +107,107 @@ module Demosaic2 #(
end end
end end
COLOR_GEN: begin COLOR_GEN:
begin
// 生成rgb图像 // 生成rgb图像
// data case 0 case 1 case 2 case 3 // data case 0 case 1 case 2 case 3
// 0 3 6 G R G R G R B G B G B G // 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 // 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 // 2 5 8 G R G R G R B G B G B G
case (raw_type) 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; blue <= (data_cache[1] + data_cache[7]) >> 1;
red <= (data_cache[3] + data_cache[5]) >> 1; red <= (data_cache[3] + data_cache[5]) >> 1;
green <= data_cache[4]; green <= data_cache[4];
end 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; 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; red <= (data_cache[0] + data_cache[2] + data_cache[6] + data_cache[8]) >> 2;
blue <= data_cache[4]; blue <= data_cache[4];
end 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; 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; blue <= (data_cache[0] + data_cache[2] + data_cache[6] + data_cache[8]) >> 2;
red <= data_cache[4]; red <= data_cache[4];
end end
3: begin // Missing B, R on G 3:
begin // Missing B, R on G
red <= (data_cache[1] + data_cache[7]) >> 1; red <= (data_cache[1] + data_cache[7]) >> 1;
blue <= (data_cache[3] + data_cache[5]) >> 1; blue <= (data_cache[3] + data_cache[5]) >> 1;
green <= data_cache[4]; green <= data_cache[4];
end end
default: ; default:
;
endcase endcase
case (raw_type) 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 endcase
end end
SEND_DATA: begin SEND_DATA:
if (in_ready && !in_receive) begin begin
if (in_ready && !in_receive)
begin
out_en <= 1; out_en <= 1;
out_r <= red; out_r <= red;
out_b <= blue; out_b <= blue;
out_g <= green; out_g <= green;
end else out_en <= 0; pos_x <= pos_x + 1;
end
else
out_en <= 0;
end 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; cnt_data <= 0;
pos_x <= 0; pos_x <= 0;
pos_y <= pos_y + 1; pos_y <= pos_y + 1;
if (pos_y >= IM_HEIGHT - 2 - 1) begin if (pos_y >= IM_HEIGHT - 2)
begin
pos_y <= 0; pos_y <= 0;
end end
// 换行后切换Bayer格式 // 换行后切换Bayer格式
if (pos_y % 2 == 1) begin if (pos_y % 2 == 1)
begin
raw_type <= RAW_TYPE; raw_type <= RAW_TYPE;
end else begin end
else
begin
case (RAW_TYPE) 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 endcase
end end
end else begin end
else
begin
cnt_data <= 2; cnt_data <= 2;
// 窗口右移 // 窗口右移
@ -178,7 +220,8 @@ module Demosaic2 #(
end end
end end
default: ; default:
;
endcase endcase
end end
end end

View File

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

View File

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

File diff suppressed because it is too large Load Diff

View File

@ -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;
}

View File

@ -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

466
src/sc_main.cpp Normal file → Executable file
View File

@ -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 // SystemC global header
#include "sysc/communication/sc_signal.h"
#include "sysc/kernel/sc_module.h"
#include <systemc> #include <systemc>
// Include common routines // Include common routines
#include <string>
#include <sys/stat.h> // mkdir #include <sys/stat.h> // mkdir
#include <utility>
#include <vector>
#include <verilated.h> #include <verilated.h>
#include <verilated_vcd_sc.h> #include <verilated_vcd_sc.h>
// Include model header, generated from Verilating "isp.v" // Include model header, generated from Verilating "isp.v"
#include "Visp.h" #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_WIDTH = 1936;
static const uint16_t IN_HEIGHT = 1088; static const uint16_t IN_HEIGHT = 1088;
static const uint32_t IN_SIZE = (IN_WIDTH * IN_HEIGHT); 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; } color_gain{1.1, 0.7, 1.3}, white_gain;
static const double gamma_value = 2.2; 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 contrast = 1.2;
// static const double white_radio = 0.1;
using namespace sc_core; using namespace sc_core;
using namespace sc_dt; using namespace sc_dt;
bool picProcess(uint32_t *image, uint16_t number);
SC_MODULE(TB_ISP) { SC_MODULE(TB_ISP) {
sc_in_clk clk; 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>( std::vector<uint32_t> process_image = std::vector<uint32_t>(
OUT_SIZE, 0); // after isp process, the data of image OUT_SIZE, 0); // after isp process, the data of image
SC_CTOR(TB_ISP) { 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; 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) { while (true) {
if (in_ready.read() && !is_finish) { if (in_ready && !is_finish) {
out_en.write(1); // 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];
printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y, // print data
std::printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
image[(pos_y + 0) * IN_WIDTH + pos_x]); 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]); 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]); 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++; pos_x++;
// calculate position and recognize when to finish
if (pos_x >= IN_WIDTH) { if (pos_x >= IN_WIDTH) {
pos_x = 0; pos_x = 0;
pos_y++; pos_y++;
} }
if (pos_y >= IN_HEIGHT - 2) { if (pos_y >= IN_HEIGHT - 1) {
pos_y = 0; pos_y = 0;
cnt_flame++; cnt_flame++;
} }
@ -111,23 +120,32 @@ SC_MODULE(TB_ISP) {
is_finish = true; is_finish = true;
} }
} else { } else {
out_en.write(0); out_valid = false;
} }
// wait for next clk
wait(); 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; uint32_t last_data = 0, cnt = 0;
bool is_finish = false; bool is_finish = false;
while (true) { // reset
if (im_en.read() && !is_finish) { out_ready = false;
out_ready.write(false); is_done = false;
process_image[pos_y * OUT_WIDTH + pos_x] = im_data.read(); while (true) {
if (!is_finish) {
out_ready = true;
// when data valid, write it down
if (in_valid) {
process_image[pos_y * OUT_WIDTH + pos_x] = in_data;
// calculate position
pos_x++; pos_x++;
if (pos_x >= OUT_WIDTH) { if (pos_x >= OUT_WIDTH) {
@ -143,23 +161,25 @@ SC_MODULE(TB_ISP) {
if (cnt_flame >= FLAMES) { if (cnt_flame >= FLAMES) {
is_finish = true; is_finish = true;
} }
}
} else { } 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++; 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; cnt = 0;
} }
last_data = im_data.read(); last_data = in_data;
// wait for next clk
wait(); wait();
} }
} }
@ -174,157 +194,53 @@ SC_MODULE(TB_ISP) {
return false; 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 // 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; 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; 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[]) { 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); exit(0);
} else { } 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; uint32_t i = 0;
for (int y = 0; y < IN_HEIGHT; y++) { for (int y = 0; y < IN_HEIGHT; y++) {
for (int x = 0; x < IN_WIDTH; x++) { 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; 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 // This is a more complicated example, please also see the simpler
// examples/make_hello_c. // examples/make_hello_c.
@ -354,113 +270,112 @@ int sc_main(int argc, char *argv[]) {
// Define clocks // 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 // 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_ready;
// sc_signal<bool> in_receive;
sc_signal<uint32_t> in_data[3]; 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_ready;
sc_signal<bool> out_receive;
sc_signal<uint32_t> out_data; sc_signal<uint32_t> out_data;
// ISP Modules Enable Ports
sc_signal<bool> blender_enable; 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_red;
sc_signal<uint32_t> gain_green; sc_signal<uint32_t> gain_green;
sc_signal<uint32_t> gain_blue; 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<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 // 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_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_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)); gain_blue = static_cast<uint32_t>(color_gain.blue * std::pow(2, 8));
// Gamma table
gamma_enable = true; gamma_enable = true;
gamma_inverse = static_cast<uint32_t>((1.0 / gamma_value) * std::pow(2, 8));
for (int i = 0; i < 256; i++) { for (int i = 0; i < 256; i++) {
// calculate gamma table
isp->gamma_table[i](gamma_table[i]);
gamma_table[i] = gamma_table[i] =
static_cast<uint32_t>(255 * pow(i / 255.0, 1.0 / gamma_value)); static_cast<uint32_t>(255 * pow(i / 255.0, 1.0 / gamma_value));
} }
// White Correction
white_enable = true; white_enable = true;
flame_rate = 0; flame_rate = 0;
white_gain[0] = 255; white_gain[0] = 255;
white_gain[1] = 255; white_gain[1] = 255;
white_gain[2] = 255; white_gain[2] = 255;
// Saturation Correction
saturation_enable = true; 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 // You must do one evaluation before enabling waves, in order to allow
// SystemC to interconnect everything for testing. // SystemC to interconnect everything for testing.
@ -473,26 +388,27 @@ int sc_main(int argc, char *argv[]) {
if (flag && 0 == std::strcmp(flag, "+trace")) { if (flag && 0 == std::strcmp(flag, "+trace")) {
std::cout << "Enabling waves into logs/vlt_dump.vcd...\n"; std::cout << "Enabling waves into logs/vlt_dump.vcd...\n";
tfp = new VerilatedVcdSc; tfp = new VerilatedVcdSc;
isp->trace(tfp, 99); // Trace 99 levels of hierarchy isp.trace(tfp, 99); // Trace 99 levels of hierarchy
Verilated::mkdir("logs"); Verilated::mkdir("logs");
tfp->open("logs/vlt_dump.vcd"); tfp->open("logs/vlt_dump.vcd");
} }
// Simulate until $finish // Simulate until $finish
std::cout << "Ready to simulate!\n";
while (!Verilated::gotFinish()) { 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 // Don't do this in "real" programs, do it in an abort() handler instead
if (tfp) if (tfp)
tfp->flush(); tfp->flush();
// Apply inputs // Apply inputs
if (sc_time_stamp() < sc_time(10, SC_NS)) { if (sc_time_stamp() < sc_time(10, SC_NS)) {
reset.write(1); // Assert reset rst.write(1); // Assert reset
} else { } else {
reset.write(0); // Deassert reset rst.write(0); // Deassert reset
} }
if (flag_done.read()) if (tb_isp.is_done)
break; break;
// Simulate 1ns // Simulate 1ns
@ -500,7 +416,7 @@ int sc_main(int argc, char *argv[]) {
} }
// Final model cleanup // Final model cleanup
isp->final(); isp.final();
// Close trace if opened // Close trace if opened
if (tfp) { if (tfp) {

525
src/sc_main.cpp.back Normal file
View File

@ -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;
}

View File

@ -7,6 +7,8 @@
#include <iostream> #include <iostream>
// SystemC global header // SystemC global header
#include "sysc/communication/sc_signal.h"
#include "sysc/kernel/sc_module.h"
#include <systemc> #include <systemc>
// Include common routines // Include common routines
@ -18,12 +20,10 @@
#include <verilated_vcd_sc.h> #include <verilated_vcd_sc.h>
// Include model header, generated from Verilating "isp.v" // Include model header, generated from Verilating "isp.v"
#include "Visp.h" #include "Visp_Pipeline.h"
// Write Pictures // Write Pictures
#include "bmp.hpp" #include "bitmap_image.hpp"
#include "sysc/communication/sc_signal.h"
#include "sysc/kernel/sc_module.h"
// Image Parameters // Image Parameters
static const uint16_t IN_WIDTH = 1936; 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_WIDTH = 1920;
static const uint16_t OUT_HEIGHT = 1080; static const uint16_t OUT_HEIGHT = 1080;
static const uint32_t OUT_SIZE = (OUT_WIDTH * OUT_HEIGHT); 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 // 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 { struct color_gain {
double red; double red;
double green; double green;
@ -101,17 +105,20 @@ SC_MODULE(TB_ISP) {
image[(pos_y + 1) * IN_WIDTH + pos_x]); image[(pos_y + 1) * IN_WIDTH + pos_x]);
std::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]); image[(pos_y + 2) * IN_WIDTH + pos_x]);
pos_x++;
// calculate position and recognize when to finish // calculate position and recognize when to finish
if (++pos_x >= IN_WIDTH) { if (pos_x >= IN_WIDTH) {
pos_x = 0; pos_x = 0;
if (++pos_y >= IN_HEIGHT - 2) { // demosaic window is 3x3 pos_y++;
}
if (pos_y >= IN_HEIGHT - 1) {
pos_y = 0; pos_y = 0;
if (++cnt_flame >= CNT_FLAME) { cnt_flame++;
}
if (cnt_flame >= FLAMES) {
is_finish = true; is_finish = true;
} }
}
}
} else { } else {
out_valid = false; out_valid = false;
} }
@ -139,18 +146,20 @@ SC_MODULE(TB_ISP) {
process_image[pos_y * OUT_WIDTH + pos_x] = in_data; process_image[pos_y * OUT_WIDTH + pos_x] = in_data;
// calculate position // 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) {
pos_x = 0;
pos_y++;
}
if (pos_y >= OUT_HEIGHT) {
pos_y = 0;
saveData( saveData(
("output_img_" + std::to_string(cnt_flame) + ".bmp").c_str()); ("output_img_" + std::to_string(cnt_flame) + ".bmp").c_str());
cnt_flame++;
} }
if (cnt_flame >= FLAMES) {
is_finish = true;
} }
} }
} else { } else {
@ -177,23 +186,27 @@ SC_MODULE(TB_ISP) {
bool saveData(const char *name) { bool saveData(const char *name) {
bool ret = true; 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 // 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; 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; return ret;
} }
}; };
@ -203,7 +216,7 @@ int sc_main(int argc, char *argv[]) {
// Open Image // Open Image
std::ifstream 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 // Check image whether is open
if (!image.is_open()) { if (!image.is_open()) {
std::printf("Open Image Failed!!!\n"); std::printf("Open Image Failed!!!\n");
@ -214,13 +227,13 @@ int sc_main(int argc, char *argv[]) {
// Read and Transform Image // Read and Transform Image
std::vector<uint16_t> in_image(IN_SIZE); 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; uint32_t i = 0;
for (int y = 0; y < IN_HEIGHT; y++) { 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; i += 2;
} }
} }
@ -281,50 +294,24 @@ int sc_main(int argc, char *argv[]) {
sc_signal<uint32_t> white_gain[3]; sc_signal<uint32_t> white_gain[3];
// Construct the Verilated model, from inside Visp.h // 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.clk(clk);
isp.reset(rst); isp.reset(rst);
isp.in_en(in_valid); // Connect input signal
isp.in_valid(in_valid);
isp.in_ready(in_ready); isp.in_ready(in_ready);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
isp.in_data[i](in_data[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_ready(out_ready);
isp.out_data(out_data); isp.out_data(out_data);
// Connect ISP modules enable signal
isp.blender_enable(blender_enable); 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_red(gain_red);
isp.gain_green(gain_green); isp.gain_green(gain_green);
isp.gain_blue(gain_blue); 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 // Construct testbench module
TB_ISP tb_isp("tb_isp"); TB_ISP tb_isp("tb_isp");

View File

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