SikongJueluo
/
ISP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
CMakeLists.txt
View File

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

2
rtl/Color/ColorBlender_Pipeline.sv
View File

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

2
rtl/Crop/Crop_Pipeline.sv
View File

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

127
rtl/Demosaic/Demosaic2.sv
View File

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

2
rtl/Demosaic/Demosaic_Pipeline.sv
View File

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

8
rtl/isp_Pipeline.sv
View File

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

5002
src/img_process/bitmap_image.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

87
src/img_process/bmp.cpp
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;
}

43
src/img_process/bmp.hpp
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

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

@ -1,26 +1,31 @@
// For std::unique_ptr
#include <memory>
// For read and write
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <ios>
#include <iostream>
// SystemC global header
#include "sysc/communication/sc_signal.h"
#include "sysc/kernel/sc_module.h"
#include <systemc>
// Include common routines
#include <string>
#include <sys/stat.h> // mkdir
#include <utility>
#include <vector>
#include <verilated.h>
#include <verilated_vcd_sc.h>
// Include model header, generated from Verilating "isp.v"
#include "Visp.h"
// Handle file
#include <fstream>
#include <iostream>
// math
#include <cmath>
#include "bmp.hpp"
// Write Pictures
#include "bitmap_image.hpp"
// Image Parameters
static const uint16_t IN_WIDTH = 1936;
static const uint16_t IN_HEIGHT = 1088;
static const uint32_t IN_SIZE = (IN_WIDTH * IN_HEIGHT);
@ -45,65 +50,69 @@ struct color_gain {
} color_gain{1.1, 0.7, 1.3}, white_gain;
static const double gamma_value = 2.2;
static const double saturation_inc = 0.5;
static const double sat_inc = 0.5;
static const double contrast = 1.2;
// static const double white_radio = 0.1;
using namespace sc_core;
using namespace sc_dt;
bool picProcess(uint32_t *image, uint16_t number);
SC_MODULE(TB_ISP) {
sc_in_clk clk;
sc_in<bool> reset;
sc_in<bool> rst;
sc_in<bool> in_ready;
sc_in<bool> in_receive;
sc_out<bool> out_en;
sc_out<uint32_t> out_data[3];
sc_in<bool> in_ready; // next module ready to receive data
sc_out<bool> out_valid; // next module data valid signal
sc_out<uint32_t> out_data[3]; // next module receive data
sc_in<bool> im_en;
sc_out<bool> out_ready;
// sc_out<bool> out_receceive;
sc_in<uint32_t> im_data;
sc_in<bool> in_valid; // this module receive data valid signal
sc_out<bool> out_ready; // this module ready to receive data
sc_in<uint32_t> in_data; // this module receive data
sc_out<bool> is_done;
std::unique_ptr<uint16_t[]> image = std::make_unique<uint16_t[]>(IN_SIZE);
bool is_done; // when receive all data
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(sendData, clk.pos()); // when clk posedge, exec sendData
reset_signal_is(rst, true); // set rst signal
SC_CTHREAD(read_Data, clk.pos());
SC_CTHREAD(readData, clk.pos());
reset_signal_is(rst, true); // set rst signal
}
void send_Data(void) {
void sendData(void) {
// init var
uint16_t pos_x = 0, pos_y = 0, cnt_flame = 0;
bool is_finish = false;
bool is_finish = false; // when send all data
// reset
out_valid = false;
for (auto &data : out_data)
data = 0;
while (true) {
if (in_ready.read() && !is_finish) {
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]);
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]);
std::printf("x=%4d, y=%4d, data=0x%04x\t", pos_x, pos_y,
image[(pos_y + 1) * IN_WIDTH + pos_x]);
std::printf("x=%4d, y=%4d, data=0x%04x\n", pos_x, pos_y,
image[(pos_y + 2) * IN_WIDTH + pos_x]);
pos_x++;
// calculate position and recognize when to finish
if (pos_x >= IN_WIDTH) {
pos_x = 0;
pos_y++;
}
if (pos_y >= IN_HEIGHT - 2) {
if (pos_y >= IN_HEIGHT - 1) {
pos_y = 0;
cnt_flame++;
}
@ -111,55 +120,66 @@ SC_MODULE(TB_ISP) {
is_finish = true;
}
} else {
out_en.write(0);
out_valid = false;
}
// wait for next clk
wait();
}
}
void read_Data(void) {
is_done.write(0);
uint32_t pos_x = 0, pos_y = 0, cnt_flame = 0;
void readData(void) {
// 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) {
if (im_en.read() && !is_finish) {
out_ready.write(false);
if (!is_finish) {
out_ready = true;
process_image[pos_y * OUT_WIDTH + pos_x] = im_data.read();
pos_x++;
// when data valid, write it down
if (in_valid) {
process_image[pos_y * OUT_WIDTH + pos_x] = in_data;
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;
// calculate position
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);
out_ready = false;
}
// when data didn't change some time, it end
if (last_data == im_data.read() && is_finish) {
// when no data send, give finish signal
if (is_finish && (last_data == in_data)) {
cnt++;
if (cnt >= 100000L) {
is_done.write(1);
printf("x=%d, y=%d\n", pos_x, pos_y);
if (cnt >= 100000L) { // when receive many times the same data
is_done = true;
std::printf("Finish Reading data; pos_x = %d, pos_y = %d\n", pos_x,
pos_y);
}
} else {
cnt = 0;
}
last_data = im_data.read();
last_data = in_data;
// wait for next clk
wait();
}
}
@ -174,157 +194,53 @@ SC_MODULE(TB_ISP) {
return false;
}
// Transform isp image
std::vector<uint8_t> bmp_image(3 * OUT_SIZE);
for (int i = 0; i < OUT_SIZE; i++) {
bmp_image[3 * i + 0] = (process_image[i] & 0x00ff0000) >> 16;
bmp_image[3 * i + 1] = (process_image[i] & 0x0000ff00) >> 8;
bmp_image[3 * i + 2] = (process_image[i] & 0x000000ff) >> 0;
}
// Write BMP image
std::ofstream bmp;
bmp.open(std::string(OUTPUT_DIR) + name);
if (!bmp.is_open()) {
std::cout << "Output File Open Failed!!!\n";
bitmap_image bmp(OUT_WIDTH, OUT_HEIGHT);
if (!bmp) {
std::cout << "Output Image Open Failed!!!\n";
return false;
}
ret = writeBMP(bmp, bmp_image, OUT_WIDTH, OUT_HEIGHT);
bmp.close();
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::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;
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::cout << "Ready to sim" << std::endl;
std::printf("Open Image Successfully!!!\n");
}
// 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);
// 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++) {
image[y * IN_WIDTH + x] = (uint16_t)buf[i] + ((uint16_t)buf[i + 1] << 8);
in_image[y * IN_WIDTH + x] =
(uint16_t)buf[i] + ((uint16_t)buf[i + 1] << 8);
i += 2;
}
}
std::cout << "Finish Reading data" << std::endl;
// Close and delete image
image.close();
delete[] buf;
std::printf("Finish Reading Image\n");
// This is a more complicated example, please also see the simpler
// examples/make_hello_c.
@ -354,113 +270,112 @@ int sc_main(int argc, char *argv[]) {
// Define clocks
sc_clock clk{"clk", 10, SC_NS, 0.5, 3, SC_NS, true};
// Define interconnect
sc_signal<bool> reset;
sc_signal<bool> in_en;
sc_signal<bool> rst;
// ISP Modules in ports
sc_signal<bool> in_valid;
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;
// ISP Modules out ports
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<bool> saturation_enable;
sc_signal<uint32_t> saturation_increase;
sc_signal<bool> flag_done;
sc_signal<uint32_t> saturation_inc;
sc_signal<uint32_t> gamma_table[256];
sc_signal<uint32_t> white_gain[3];
// 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);
Visp 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->gain_red(gain_red);
isp->gain_green(gain_green);
isp->gain_blue(gain_blue);
isp->blender_enable(blender_enable);
// ISP Old Version
isp.clk(clk);
isp.reset(rst);
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);
// isp->gamma_inverse(gamma_inverse);
// Construct testbench module
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);
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
// Set ISP modules parameters
// Color Blender
blender_enable = true;
gain_red = static_cast<uint32_t>(color_gain.red * std::pow(2, 8));
gain_green = static_cast<uint32_t>(color_gain.green * std::pow(2, 8));
gain_blue = static_cast<uint32_t>(color_gain.blue * std::pow(2, 8));
// Gamma table
gamma_enable = true;
gamma_inverse = static_cast<uint32_t>((1.0 / gamma_value) * std::pow(2, 8));
for (int i = 0; i < 256; i++) {
// calculate gamma table
isp->gamma_table[i](gamma_table[i]);
gamma_table[i] =
static_cast<uint32_t>(255 * pow(i / 255.0, 1.0 / gamma_value));
}
// White Correction
white_enable = true;
flame_rate = 0;
white_gain[0] = 255;
white_gain[1] = 255;
white_gain[2] = 255;
// Saturation Correction
saturation_enable = true;
saturation_increase =
(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);
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.
@ -473,26 +388,27 @@ int sc_main(int argc, char *argv[]) {
if (flag && 0 == std::strcmp(flag, "+trace")) {
std::cout << "Enabling waves into logs/vlt_dump.vcd...\n";
tfp = new VerilatedVcdSc;
isp->trace(tfp, 99); // Trace 99 levels of hierarchy
isp.trace(tfp, 99); // Trace 99 levels of hierarchy
Verilated::mkdir("logs");
tfp->open("logs/vlt_dump.vcd");
}
// Simulate until $finish
std::cout << "Ready to simulate!\n";
while (!Verilated::gotFinish()) {
// Flush the wave files each cycle so we can immediately see the OUTPUT_DIR
// Flush the wave files each cycle so we can immediately see the output
// Don't do this in "real" programs, do it in an abort() handler instead
if (tfp)
tfp->flush();
// Apply inputs
if (sc_time_stamp() < sc_time(10, SC_NS)) {
reset.write(1); // Assert reset
rst.write(1); // Assert reset
} else {
reset.write(0); // Deassert reset
rst.write(0); // Deassert reset
}
if (flag_done.read())
if (tb_isp.is_done)
break;
// Simulate 1ns
@ -500,7 +416,7 @@ int sc_main(int argc, char *argv[]) {
}
// Final model cleanup
isp->final();
isp.final();
// Close trace if opened
if (tfp) {

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

141
src/sc_main.cpp.bak → src/sc_main_pipeline.cpp
View File

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

3
xmake.lua
View File

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