292 lines
8.1 KiB
C++
292 lines
8.1 KiB
C++
|
||
#include <fstream>
|
||
#include <cstring>
|
||
#include <stdio.h>
|
||
//#include "ap_utils.h"
|
||
#include <iostream>
|
||
#include "subPix.h"
|
||
#include "../../globals/tbGlobals.h"
|
||
|
||
std::vector<Luma_convolveData> readConvolveDataFile(
|
||
const char* file){
|
||
std::ifstream inputFile(file);
|
||
|
||
std::string strLineTxt;
|
||
int size = 0;
|
||
std::vector<Luma_convolveData> testData;
|
||
Luma_convolveData a_line;
|
||
while(getline(inputFile, strLineTxt))
|
||
{
|
||
if (strLineTxt.empty())
|
||
continue;
|
||
|
||
if(0 == size)
|
||
{
|
||
int winRdx, y, Rid, Flag, pkValue;
|
||
sscanf(strLineTxt.c_str(), "%04x %04x %04x %01x %02x", &winRdx, &y, &Rid, &Flag, &pkValue);
|
||
a_line.WinRdx = (uint16_t)winRdx;
|
||
a_line.y = (uint16_t)y;
|
||
a_line.Rid = (uint16_t)Rid;
|
||
a_line.Flag = (uint8_t)Flag;
|
||
a_line.pkValue = (uint8_t)pkValue;
|
||
a_line.nD1 = 0;
|
||
a_line.nD2 = 0;
|
||
size = 1 ;
|
||
}
|
||
else //receive Data
|
||
{
|
||
int data;
|
||
sscanf(strLineTxt.c_str(), "%d", &data);
|
||
if(1 == size)
|
||
a_line.nD1 = data;
|
||
else if(2 == size)
|
||
a_line.nD2 = data;
|
||
|
||
if(size >= 2)
|
||
{
|
||
testData.push_back(a_line);
|
||
size = 0;
|
||
}
|
||
else
|
||
size ++;
|
||
}
|
||
|
||
}
|
||
inputFile.close();
|
||
return testData;
|
||
}
|
||
|
||
void genTestSream(
|
||
std::vector<Luma_convolveData>& convolveData,
|
||
hls::stream<RgnPixConvolve>& convolveStream,
|
||
int LRflag, //0-left image; 1-right image
|
||
const Luma_frameInfo frameInfo)
|
||
{
|
||
RgnPixConvolve VSync = {0,0,0,0,0,0,0, 0, 0};
|
||
ap_uint<32> data_32;
|
||
//1st:FrmNo
|
||
data_32 = frameInfo.FrmNo;
|
||
VSync.Sync = 0b10;
|
||
VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH-1,0);
|
||
VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH*2-1, CAM4K_Y_WIDTH);
|
||
VSync.LazerWinRid(CAM4K_Y_RSV_BITS*2-1,0) = data_32.range(31,CAM4K_Y_WIDTH*2);
|
||
VSync.LazerWinRid(10, CAM4K_Y_RSV_BITS*2) = 0;
|
||
convolveStream.write(VSync);
|
||
//2nd:FrmNo
|
||
data_32 = frameInfo.TimeStamp;
|
||
VSync.Sync = 0b00;
|
||
VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH-1,0);
|
||
VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH*2-1,CAM4K_Y_WIDTH);
|
||
VSync.LazerWinRid(CAM4K_Y_RSV_BITS*2-1,0) = data_32.range(31,CAM4K_Y_WIDTH*2);
|
||
VSync.LazerWinRid(10, CAM4K_Y_RSV_BITS*2) = 0;
|
||
convolveStream.write(VSync);
|
||
//3rd:encInfo
|
||
data_32 = frameInfo.encInfo;
|
||
VSync.Sync = 0b00;
|
||
VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH-1,0);
|
||
VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data_32.range(CAM4K_Y_WIDTH*2-1,CAM4K_Y_WIDTH);
|
||
VSync.LazerWinRid(CAM4K_Y_RSV_BITS*2-1,0) = data_32.range(31,CAM4K_Y_WIDTH*2);
|
||
VSync.LazerWinRid(10, CAM4K_Y_RSV_BITS*2) = 0;
|
||
convolveStream.write(VSync);
|
||
//4th:frmW(12bit), frmH(12bit)
|
||
ap_uint<16> data16_1, data16_2;
|
||
data16_1 = frameInfo.W;
|
||
data16_2 = frameInfo.H;
|
||
VSync.Sync = 0b00;
|
||
VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data16_1.range(CAM4K_Y_WIDTH-1,0);
|
||
VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data16_2.range(CAM4K_Y_WIDTH-1,0);
|
||
VSync.LazerWinRid(10, 0) = 0;
|
||
convolveStream.write(VSync);
|
||
//5th: frmX, WinNum
|
||
int winNum = (int)convolveData.size()+12;
|
||
if(LRflag == 0)
|
||
data16_1 = frameInfo.left_L;
|
||
else
|
||
data16_1 = frameInfo.right_L;
|
||
data16_2 = (uint16_t)winNum;
|
||
VSync.Sync = 0b00;
|
||
VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data16_1.range(CAM4K_Y_WIDTH-1,0);
|
||
VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = data16_2.range(CAM4K_Y_WIDTH-1,0);
|
||
VSync.LazerWinRid(10, 0) = 0;
|
||
convolveStream.write(VSync);
|
||
//6th: frmY
|
||
if(LRflag == 0)
|
||
data16_1 = frameInfo.left_T;
|
||
else
|
||
data16_1 = frameInfo.right_T;
|
||
VSync.Sync = 0b00;
|
||
VSync.LazerWinX(CAM4K_Y_WIDTH-1,0) = data16_1.range(CAM4K_Y_WIDTH-1,0);
|
||
VSync.LazerWinY(CAM4K_Y_WIDTH-1,0) = 0;
|
||
VSync.LazerWinRid(10, 0) = 0;
|
||
convolveStream.write(VSync);
|
||
//output data
|
||
for(int i = 0, i_max=(int)convolveData.size(); i < i_max; i ++)
|
||
{
|
||
Luma_convolveData* a_line = &convolveData[i];
|
||
RgnPixConvolve conData;
|
||
conData.LazerWinX = (ap_uint<12>)a_line->WinRdx;
|
||
conData.LazerWinY = (ap_uint<12>)a_line->y;
|
||
conData.LazerWinRid = (ap_uint<11>)a_line->Rid;
|
||
conData.LazerWinFlag = (ap_uint<4>)a_line->Flag;
|
||
conData.LazerWinRsv = 0;
|
||
conData.value = (ap_uint<8>)a_line->pkValue;
|
||
if(i == 0)
|
||
conData.Sync = 0b01;
|
||
else if(i == (i_max-1))
|
||
conData.Sync = 0b11;
|
||
else
|
||
conData.Sync = 0b00;
|
||
conData.nD1 = a_line->nD1;
|
||
conData.nD2 = a_line->nD2;
|
||
convolveStream.write(conData);
|
||
}
|
||
return;
|
||
}
|
||
|
||
void convertSubpixStreamToArray(
|
||
hls::stream<RgnSubPix>& streamData,
|
||
std::vector<Luma_rgnSubpix>& arrayData,
|
||
uint32_t* FrmNo,
|
||
uint32_t* timeStamp,
|
||
uint32_t* encInfo,
|
||
uint16_t* frameROI_w,
|
||
uint16_t* frameROI_h,
|
||
uint16_t* frameROI_x,
|
||
uint16_t* frameROI_y)
|
||
{
|
||
//1st:FrmNo
|
||
RgnSubPix VSync = streamData.read();
|
||
UintFloat tmp;
|
||
tmp.fdata = VSync.x;
|
||
*FrmNo = (uint32_t)tmp.unData;
|
||
//2nd:timeStamp
|
||
VSync = streamData.read();
|
||
tmp.fdata = VSync.x;
|
||
*timeStamp = (uint32_t)tmp.unData;
|
||
//3rd:encInfo
|
||
VSync = streamData.read();
|
||
tmp.fdata = VSync.x;
|
||
*encInfo = (uint32_t)tmp.unData;
|
||
//4th:frmW(12bit), frmH(12bit)
|
||
VSync = streamData.read();
|
||
tmp.fdata = VSync.x;
|
||
*frameROI_w = tmp.unData & 0xffff;
|
||
*frameROI_h = tmp.unData >> 16;
|
||
//5th: frmX, WinNum
|
||
VSync = streamData.read();
|
||
tmp.fdata = VSync.x;
|
||
*frameROI_x = tmp.unData & 0xffff;
|
||
uint16_t winNum = tmp.unData >> 16;
|
||
//6th: frmY
|
||
VSync = streamData.read();
|
||
tmp.fdata = VSync.x;
|
||
*frameROI_y = tmp.unData & 0xffff;
|
||
//output data
|
||
for(int i = 0; i < winNum*2; i ++)
|
||
{
|
||
RgnSubPix data_in = streamData.read();
|
||
Luma_rgnSubpix a_pnt;
|
||
a_pnt.x = data_in.x;
|
||
a_pnt.y = (uint16_t)data_in.y;
|
||
a_pnt.Rid = (uint16_t)data_in.rid;
|
||
a_pnt.Flag = (uint8_t)data_in.flag;
|
||
a_pnt.pkValue = (uint8_t)data_in.value;
|
||
a_pnt.Sync = (uint8_t)data_in.Sync;
|
||
arrayData.push_back(a_pnt);
|
||
}
|
||
return;
|
||
}
|
||
|
||
void writeSubpixData(
|
||
const char* fileName,
|
||
std::vector<Luma_rgnSubpix>& outData)
|
||
{
|
||
std::ofstream sw(fileName);
|
||
int i_max = outData.size();
|
||
for (int i = 0; i < i_max; i++)
|
||
{
|
||
char data[250];
|
||
#if defined(__linux__)
|
||
sprintf(data, "%.2f %04d %04d %01x %02d %01x",
|
||
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue, outData[i].Sync);
|
||
#else
|
||
sprintf_s(data, "%.2f %04d %04d %01x %02d %01x",
|
||
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue, outData[i].Sync);
|
||
#endif
|
||
sw << data << std::endl;
|
||
}
|
||
sw.close();
|
||
}
|
||
|
||
int main()
|
||
{
|
||
setvbuf(stdout, NULL, _IONBF, 0); // _IONBF = <20><EFBFBD><DEBB>壬<EFBFBD><E5A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
TbModule currModule = TB_3_subPix;
|
||
|
||
for(int n = 0; n < tb_group_count; n ++)
|
||
{
|
||
int winSize = 0;
|
||
int fileStart = tb_groups[n].start_id;
|
||
int fileEnd = tb_groups[n].end_id;
|
||
for(int fi = fileStart; fi <= fileEnd; fi++)
|
||
{
|
||
TbPaths test_path_L;
|
||
int rcode_L = tb_get_paths(currModule, n, fi, 0, &test_path_L);
|
||
TbPaths test_path_R;
|
||
int rcode_R = tb_get_paths(currModule, n, fi, 1, &test_path_R);
|
||
|
||
Luma_frameInfo frameInfo = readParaFile(test_path_L.paras, fi);
|
||
std::vector<Luma_convolveData> testData_L = readConvolveDataFile(test_path_L.input);
|
||
std::vector<Luma_convolveData> testData_R = readConvolveDataFile(test_path_R.input);
|
||
|
||
//gen test stream
|
||
hls::stream<RgnPixConvolve> inStream_L;
|
||
genTestSream(testData_L, inStream_L, 0, frameInfo);
|
||
hls::stream<RgnPixConvolve> inStream_R;
|
||
genTestSream(testData_R, inStream_R, 1, frameInfo);
|
||
|
||
hls::stream<RgnSubPix> outStream_L;
|
||
subpix(inStream_L, outStream_L);
|
||
hls::stream<RgnSubPix> outStream_R;
|
||
subpix(inStream_R, outStream_R);
|
||
|
||
//output
|
||
//left image
|
||
std::vector<Luma_rgnSubpix> outData_L;
|
||
uint32_t outFrmNo_L, outTimeStamp_L, outEncInfo_L;
|
||
uint16_t outROI_w_L, outROI_h_L, outROI_x_L, outROI_y_L;
|
||
convertSubpixStreamToArray(
|
||
outStream_L,
|
||
outData_L,
|
||
&outFrmNo_L,
|
||
&outTimeStamp_L,
|
||
&outEncInfo_L,
|
||
&outROI_w_L,
|
||
&outROI_h_L,
|
||
&outROI_x_L,
|
||
&outROI_y_L);
|
||
writeSubpixData(test_path_L.output, outData_L);
|
||
|
||
//right image
|
||
std::vector<Luma_rgnSubpix> outData_R;
|
||
uint32_t outFrmNo_R, outTimeStamp_R, outEncInfo_R;
|
||
uint16_t outROI_w_R, outROI_h_R, outROI_x_R, outROI_y_R;
|
||
convertSubpixStreamToArray(
|
||
outStream_R,
|
||
outData_R,
|
||
&outFrmNo_R,
|
||
&outTimeStamp_R,
|
||
&outEncInfo_R,
|
||
&outROI_w_R,
|
||
&outROI_h_R,
|
||
&outROI_x_R,
|
||
&outROI_y_R);
|
||
writeSubpixData(test_path_R.output, outData_R);
|
||
|
||
printf("%s ... done\n", test_path_L.input);
|
||
}
|
||
}
|
||
printf("done!\n");
|
||
|
||
}
|