Matched with Java output (54b1382d) · Commits · Elphel / imagej-elphel

src/main/resources/TileProcessor.cuh

+146 −72

Original line number	Diff line number	Diff line
		@@ -53,15 +53,29 @@
		#define KERNELS_VERT 123
		#define IMAGE_TILE_SIDE 18
		//#define KERNEL_OFFSETS 8
		#define KERNELS_STEP (1 >> KERNELS_LSTEP)
		#define KERNELS_STEP (1 << KERNELS_LSTEP)
		#define TILESX (IMG_WIDTH / DTT_SIZE)
		#define TILESY (IMG_HEIGHT / DTT_SIZE)
		// increase row length by 1 so vertical passes will use different ports
		#define THREADSX (DTT_SIZE)
		#define DTT_SIZE1 (DTT_SIZE + 1)

		#define DBG_TILE (174*324 +118)
		#define BAYER_RED 0
		#define BAYER_BLUE 1
		#define BAYER_GREEN 2
		// assuming GR/BG as now
		#define BAYER_RED_ROW 0
		#define BAYER_RED_COL 1
		//#define BAYER_BLUE_ROW (1 - BAYER_RED_ROW)
		//#define BAYER_BLUE_COL (1 - BAYER_RED_COL)


		#define DBG_TILE_X 174
		#define DBG_TILE_Y 118

		#define DBG_TILE (DBG_TILE_Y * 324 + DBG_TILE_X)
		#define DEBUG1 1
		#undef DEBUG2
		//56494
		// struct tp_task
		//#define TASK_SIZE 12
		@@ -190,14 +204,6 @@ __constant__ int zi[4][4] = {{ 0, -1, -2, 3},
		{ 2, -3, 0, -1},
		{ 3, 2, 1, 0}};

		#define BAYER_RED 0
		#define BAYER_BLUE 1
		#define BAYER_GREEN 2
		// assuming GR/BG as now
		#define BAYER_RED_ROW 0
		#define BAYER_RED_COL 1
		//#define BAYER_BLUE_ROW (1 - BAYER_RED_ROW)
		//#define BAYER_BLUE_COL (1 - BAYER_RED_COL)


		__device__ void convertCorrectTile(
		@@ -324,7 +330,7 @@ __device__ void shiftTileHor(

		}
		// Fractional pixel shift (phase rotation), vertical. In-place.
		__device__ void shiftTileVert(
		__device__ void shiftTileVert0(
		float clt_tile [4][DTT_SIZE][DTT_SIZE1], // +1 to alternate column ports
		float residual_shift)
		{
		@@ -344,6 +350,27 @@ __device__ void shiftTileVert(
		}
		}

		__device__ void shiftTileVert(
		float clt_tile [4][DTT_SIZE][DTT_SIZE1], // +1 to alternate column ports
		float residual_shift)
		{
		int j = threadIdx.x;
		float x = residual_shift * ((j << 1 ) +1) * (0.5f/ DTT_SIZE);
		float ch = cospif(x);
		float sh = sinpif(x);
		#pragma unroll
		for (int i = 0; i < DTT_SIZE; i++) {
		float t = clt_tile[0][j][i] * ch - clt_tile[2][j][i] * sh;
		clt_tile[2][j][i] = clt_tile[0][j][i] * sh + clt_tile[2][j][i] * ch;
		clt_tile[0][j][i] = t;

		t = clt_tile[1][j][i] * ch - clt_tile[3][j][i] * sh;
		clt_tile[3][j][i] = clt_tile[1][j][i] * sh + clt_tile[3][j][i] * ch;
		clt_tile[1][j][i] = t;
		}
		}


		// Fractional pixel shift (phase rotation), vertical. In-place.
		__device__ void convolveTiles(
		float clt_tile [4][DTT_SIZE][DTT_SIZE1], // 4 quadrants of the clt data, rows extended to optimize shared ports
		@@ -357,16 +384,16 @@ __device__ void convolveTiles(
		float r3 = 0;
		for (int k = 0; k < 4; k++){
		if (zi[0][k] < 0) r0 -= clt_tile[-zi[0][k]][j][i] * kernel[k][j][i];
		else r0 += clt_tile[-zi[0][k]][j][i] * kernel[k][j][i];
		else r0 += clt_tile[ zi[0][k]][j][i] * kernel[k][j][i];

		if (zi[1][k] < 0) r0 -= clt_tile[-zi[1][k]][j][i] * kernel[k][j][i];
		else r0 += clt_tile[-zi[1][k]][j][i] * kernel[k][j][i];
		if (zi[1][k] < 0) r1 -= clt_tile[-zi[1][k]][j][i] * kernel[k][j][i];
		else r1 += clt_tile[ zi[1][k]][j][i] * kernel[k][j][i];

		if (zi[2][k] < 0) r0 -= clt_tile[-zi[2][k]][j][i] * kernel[k][j][i];
		else r0 += clt_tile[-zi[2][k]][j][i] * kernel[k][j][i];
		if (zi[2][k] < 0) r2 -= clt_tile[-zi[2][k]][j][i] * kernel[k][j][i];
		else r2 += clt_tile[ zi[2][k]][j][i] * kernel[k][j][i];

		if (zi[3][k] < 0) r0 -= clt_tile[-zi[3][k]][j][i] * kernel[k][j][i];
		else r0 += clt_tile[-zi[3][k]][j][i] * kernel[k][j][i];
		if (zi[3][k] < 0) r3 -= clt_tile[-zi[3][k]][j][i] * kernel[k][j][i];
		else r3 += clt_tile[ zi[3][k]][j][i] * kernel[k][j][i];
		}
		clt_tile[0][j][i]= r0;
		clt_tile[1][j][i]= r1;
		@@ -398,8 +425,8 @@ __device__ void debug_print_clt(

		// Uses 32 threads
		__device__ void convertCorrectTile(
		struct CltExtra * gpu_kernel_offsets,
		float * gpu_kernels,
		struct CltExtra * gpu_kernel_offsets, // [tileY][tileX][color]
		float * gpu_kernels, // [tileY][tileX][color]
		float * gpu_images,
		// struct tp_task * tt,
		float centerX,
		@@ -427,12 +454,14 @@ __device__ void convertCorrectTile(
		float kdx, kdy;
		switch (threadIdx.x){
		case 0:
		ktileX = min(KERNELS_HOR-1, max(0, (((int) lrintf(centerX))+ (1<< (KERNELS_LSTEP-1)) >> KERNELS_LSTEP)+1));
		// ktileX = min(KERNELS_HOR-1, max(0, (((int) lrintf(centerX))+ (1<< (KERNELS_LSTEP-1)) >> KERNELS_LSTEP)+1));
		ktileX = min(KERNELS_HOR-1, max(0, ((int) lrintf(centerX * (1.0/KERNELS_STEP)+1))));
		// kdx = centerX - (ktileX -1 +0.5) * KERNELS_STEP; // difference in pixel
		kdx = centerX - (ktileX << KERNELS_LSTEP) + (1 << (KERNELS_LSTEP -1)); // difference in pixel
		break;
		case 1:
		ktileY = min(KERNELS_HOR-1, max(0, (((int) lrintf(centerY))+ (1<< (KERNELS_LSTEP-1)) >> KERNELS_LSTEP)+1));
		// ktileY = min(KERNELS_HOR-1, max(0, (((int) lrintf(centerY))+ (1<< (KERNELS_LSTEP-1)) >> KERNELS_LSTEP)+1));
		ktileY = min(KERNELS_HOR-1, max(0, ((int) lrintf(centerY * (1.0/KERNELS_STEP)+1))));
		kdy = centerY - (ktileY << KERNELS_LSTEP) + (1 << (KERNELS_LSTEP -1)); // difference in pixel
		break;
		}
		@@ -445,7 +474,8 @@ __device__ void convertCorrectTile(
		THREADS_PER_TILE); // int width=warpSize);
		switch (threadIdx.x){
		case 0:
		kernel_index = ktileX + ktileY * KERNELS_HOR;
		// kernel_index = ktileX + ktileY * KERNELS_HOR;
		kernel_index = (ktileX + ktileY * KERNELS_HOR) * NUM_COLORS;
		break;
		}
		__syncthreads();
		@@ -474,9 +504,8 @@ __device__ void convertCorrectTile(
		// int dbg_y = threadIdx.y;
		// int dbg_x = threadIdx.x;
		if (color < 3){ // 3*8 threads cooperating on this
		// kernel_index += color * (KERNELS_HOR * KERNELS_VERT);
		// float * kernel_src = &gpu_kernels[ kernel_index * (DTT_SIZE * DTT_SIZE * 4)];
		float * kernel_src = &gpu_kernels[ (kernel_index + color * (KERNELS_HOR * KERNELS_VERT))* (DTT_SIZE * DTT_SIZE * 4)];
		// float * kernel_src = &gpu_kernels[ (kernel_index + color * (KERNELS_HOR * KERNELS_VERT))* (DTT_SIZE * DTT_SIZE * 4)];
		float * kernel_src = &gpu_kernels[ (kernel_index + color )* (DTT_SIZE * DTT_SIZE * 4)];
		float * kernelp = (float *) clt_kernels[color];
		kernel_src += threadIdx.x; // lsb;
		kernelp += threadIdx.x; // lsb;
		@@ -492,8 +521,10 @@ __device__ void convertCorrectTile(
		int bayer_color = min((NUM_COLORS-1),threadIdx.x >> 1);
		int bayer_g2 = threadIdx.x >= (NUM_COLORS << 1); // second pass of green
		int lsb = threadIdx.x & 1;
		int kernel_full_index = kernel_index + bayer_color(KERNELS_HOR KERNELS_VERT);
		// int kernel_full_index = kernel_index + bayer_color(KERNELS_HOR KERNELS_VERT);
		int kernel_full_index = kernel_index + bayer_color;
		// struct CltExtra * clt_extra = &gpu_kernel_offsets[kernel_index + bayer_color(KERNELS_HOR KERNELS_VERT)];
		// struct CltExtra * clt_extra = &gpu_kernel_offsets[kernel_index + bayer_color];
		struct CltExtra * clt_extra = &gpu_kernel_offsets[kernel_full_index];
		// both threads will calculate same x,y components - dont'y know how to sync just them not with other copying kernels
		if (bayer_g2){ // threads 30,31
		@@ -501,21 +532,22 @@ __device__ void convertCorrectTile(
		px = centerX - DTT_SIZE - (clt_extra->data_x + clt_extra->dxc_dx * kdx + clt_extra->dxc_dy * kdy) ; // fractional left corner Warp Illegal Address
		int itlx = (int) floorf(px +0.5f);
		int_topleft [bayer_color][0] = itlx;
		float shift_hor = px - itlx;
		/// float shift_hor = px - itlx;
		float shift_hor = itlx - px;
		residual_shift[bayer_color][0] = shift_hor;
		float x = shift_hor *(1.0f/16);
		float ahc = cospif(x);
		float ahs = sinpif(x);
		int i1 = DTT_SIZE;
		int i = 0;
		// embedd sign for cosine and sine branches into window coefficients
		// embed sign for cosine and sine branches into window coefficients
		for (; i < (DTT_SIZE/2); i++ ){
		int ri = (DTT_SIZE-1) - i;
		window_hor_sin[bayer_color][i] = HWINDOW[i ]ahc + HWINDOW[ri]ahs; // bayer_color== 2
		window_hor_sin[bayer_color][i1] = HWINDOW[ri]ahc - HWINDOW[ i]ahs;
		i1++;
		}
		// embedd sign for cosine and sine branches into window coefficients
		// embed sign for cosine and sine branches into window coefficients
		for (; i < DTT_SIZE; i++ ){
		int ri = (DTT_SIZE-1) - i;
		window_hor_sin[bayer_color][i] = HWINDOW[i ]ahc + HWINDOW[ri]ahs;
		@@ -528,21 +560,22 @@ __device__ void convertCorrectTile(
		px = centerX - DTT_SIZE - (clt_extra->data_x + clt_extra->dxc_dx * kdx + clt_extra->dxc_dy * kdy) ; // fractional left corner
		int itlx = (int) floorf(px +0.5f);
		int_topleft [bayer_color][0] = itlx;
		float shift_hor = px - itlx;
		/// float shift_hor = px - itlx;
		float shift_hor = itlx - px;
		residual_shift[bayer_color][0] = shift_hor;
		float x = shift_hor *(1.0f/16);
		float ahc = cospif(x);
		float ahs = sinpif(x);
		int i1 = DTT_SIZE;
		int i = 0;
		// embedd sign for cosine and sine branches into window coefficients
		// embed sign for cosine and sine branches into window coefficients
		for (; i < (DTT_SIZE/2); i++ ){
		int ri = (DTT_SIZE-1) - i;
		window_hor_cos[bayer_color][i] = HWINDOW[i ]ahc + HWINDOW[ri]ahs;
		window_hor_cos[bayer_color][i1] = HWINDOW[ i]ahs - HWINDOW[ri]ahc;
		i1++;
		}
		// embedd sign for cosine and sine branches into window coefficients
		// embed sign for cosine and sine branches into window coefficients
		for (; i < DTT_SIZE; i++ ){
		int ri = (DTT_SIZE-1) - i;
		window_hor_cos[bayer_color][i] = -HWINDOW[i ]ahc - HWINDOW[ri]ahs;
		@@ -553,13 +586,14 @@ __device__ void convertCorrectTile(
		py = centerY - DTT_SIZE - (clt_extra->data_y + clt_extra->dyc_dx * kdx + clt_extra->dyc_dy * kdy) ; // fractional top corner
		int itly = (int) floorf(py +0.5f);
		int_topleft[bayer_color][1] = itly;
		float shift_vert = py - itly;
		/// float shift_vert = py - itly;
		float shift_vert = itly - py;
		residual_shift[bayer_color][1] = shift_vert;
		float x = shift_vert *(1.0f/16);
		float avc = cospif(x);
		float avs = sinpif(x);
		int i1 = DTT_SIZE;
		// embedd sign for cosine branch only into window coefficients (for R,B only CC is needed, for G - CC and SC
		// embed sign for cosine branch only into window coefficients (for R,B only CC is needed, for G - CC and SC
		int i = 0;
		for (; i < DTT_SIZE/2; i++ ){
		int ri = (DTT_SIZE-1) - i;
		@@ -575,6 +609,21 @@ __device__ void convertCorrectTile(
		}
		} // if (color < 3) else
		__syncthreads();
		#ifdef DEBUG1
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("centerX=%f, centerY=%f\n",centerX, centerY);
		printf("ktileX=%d, ktileY=%d\n", ktileX, ktileY);
		printf("kdx=%f, kdy=%f\n", kdx, kdy);
		for (int i = 0; i < NUM_COLORS; i++){
		printf("int_topleft[%d][0]=%d, int_topleft[%d][1]=%d\n",i,int_topleft[i][0],i,int_topleft[i][1]);
		printf("residual_shift[%d][0]=%f, residual_shift[%d][1]=%f\n",i,residual_shift[i][0],i,residual_shift[i][1]);
		}
		}
		__syncthreads();
		#endif



		// threads 0..23 loaded 3 color kernels, threads 24-27 - prepared hor and vert windows for R and B, threads 28..31 - for G
		// prepare, fold and write data to DTT buffers
		int dstride2 = dstride <<1; // in floats (pixels)
		@@ -626,8 +675,8 @@ __device__ void convertCorrectTile(
		float d = (image_p) window_vert_cos[BAYER_GREEN][local_row];
		float dbg_pix = (*image_p);
		int dtt_offset1 = dtt_offset + (dtt_offset >> 3); // converting for 9-long rows
		dct_buf[dtt_offset1] += d * hwind_cos;
		dst_buf[dtt_offset1] += d * hwind_sin;
		dct_buf[dtt_offset1] = d * hwind_cos; // was +=
		dst_buf[dtt_offset1] = d * hwind_sin; // was +=
		dtt_offset = ( dtt_offset + ((dtt_offset_inc & 0xf) << 3)) & 0x3f;
		dtt_offset_inc >>= 4;
		local_row += 2;
		@@ -635,6 +684,15 @@ __device__ void convertCorrectTile(
		}
		}
		__syncthreads();
		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nFOLDED DTT Tiles Green before reduction\n");
		debug_print_clt(clt_tile, 0xf00); // all quadrants for green only
		}
		__syncthreads();
		#endif



		// reduce 4 green DTT buffers into 2 (so free future rotated green that were borrowed)
		// Uses all 32 threads.
		@@ -649,9 +707,9 @@ __device__ void convertCorrectTile(
		(dtt_buf) += (dtt_buf1);
		__syncthreads();

		#ifdef DEBUG1
		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nFOLDED DTT Tiles");
		printf("\nFOLDED DTT Tiles\n");
		debug_print_clt(clt_tile, 0x311); // only 1 quadrant for R,B and 2 - for G
		}
		__syncthreads();
		@@ -659,37 +717,44 @@ __device__ void convertCorrectTile(

		// Run DCT-IV/DCT-IV for all colors, DST-IV/DCT-IV for green only
		if (threadIdx.y < NUM_COLORS) { // run DCTIV for all colors
		// horizontal pass
		// horizontal pass float clt_tile [NUM_COLORS][4][DTT_SIZE][DTT_SIZE1], // +1 to alternate column ports
		dttiv_shared_mem(
		clt_tile[0][threadIdx.y][threadIdx.x], // pointer to start of row
		clt_tile[threadIdx.y][0][threadIdx.x], // pointer to start of row
		1, // int inc,
		0); // int dst_not_dct)
		// vertical pass
		} else { // if (threadIdx.y < NUM_COLORS) { // run DSTIV for green only
		dttiv_shared_mem(
		clt_tile[0][NUM_COLORS][threadIdx.x], // pointer to start of row
		clt_tile[BAYER_GREEN][1][threadIdx.x], // pointer to start of row
		1, // int inc,
		1); // int dst_not_dct)

		}
		__syncthreads();
		#ifdef DEBUG1
		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nDTT Tiles after horizontal pass");
		printf("\nDTT Tiles after horizontal pass\n");
		debug_print_clt(clt_tile, 0x311); // only 1 quadrant for R,B and 2 - for G
		}
		__syncthreads();
		#endif

		if (threadIdx.y < NUM_COLORS) { // run DCTIV for all colors
		// vertical pass // common for all 4 (DCT/DCT of RGB, and DST/DCT of G)
		dttiv_shared_mem(
		&clt_tile[0][threadIdx.y][0][threadIdx.x], // pointer to start of column
		&clt_tile[threadIdx.y][0][0][threadIdx.x], // pointer to start of column
		DTT_SIZE1, // int inc,
		0); // int dst_not_dct)
		} else {
		dttiv_shared_mem(
		&clt_tile[BAYER_GREEN][1][0][threadIdx.x], // pointer to start of column
		DTT_SIZE1, // int inc,
		0); // int dst_not_dct)
		}
		__syncthreads();
		#ifdef DEBUG1
		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nDTT Tiles after vertical pass");
		printf("\nDTT Tiles after vertical pass (both passes)\n");
		debug_print_clt(clt_tile, 0x311); // only 1 quadrant for R,B and 2 - for G
		}
		__syncthreads();
		@@ -712,13 +777,13 @@ __device__ void convertCorrectTile(
		dst_inc = DTT_SIZE1;
		break;
		case 2:// Green CC -> SS
		negate = (int_topleft[BAYER_GREEN][0] & 1) ^ (int_topleft[2][1] & 1) ^ (BAYER_RED_COL ^ BAYER_RED_ROW); // 1 - invert
		negate = (int_topleft[BAYER_GREEN][0] & 1) ^ (int_topleft[2][1] & 1) ^ (BAYER_RED_COL ^ BAYER_RED_ROW ^ 1); // 1 - invert (had to invert - verify)
		src = &clt_tile[BAYER_GREEN][0][0][threadIdx.x ];
		dst = &clt_tile[BAYER_GREEN][3][7][threadIdx.x ^ 7];
		dst_inc = -DTT_SIZE1;
		break;
		case 3:// Green SC -> CS
		negate = (int_topleft[BAYER_GREEN][0] & 1) ^ (int_topleft[2][1] & 1) ^ (BAYER_RED_COL ^ BAYER_RED_ROW); // 1 - invert
		negate = (int_topleft[BAYER_GREEN][0] & 1) ^ (int_topleft[2][1] & 1) ^ (BAYER_RED_COL ^ BAYER_RED_ROW ^ 1); // 1 - invert (had to invert - verify)
		src = &clt_tile[BAYER_GREEN][1][0][threadIdx.x ];
		dst = &clt_tile[BAYER_GREEN][2][7][threadIdx.x ^ 7];
		dst_inc = -DTT_SIZE1;
		@@ -727,23 +792,23 @@ __device__ void convertCorrectTile(
		if (negate){
		#pragma unroll
		for (int i = 0; i < DTT_SIZE; i++){
		src = -(dst);
		dst = -(src);
		src += DTT_SIZE1;
		dst += dst_inc;
		}
		} else {
		#pragma unroll
		for (int i = 0; i < DTT_SIZE; i++){
		src = (dst);
		dst = (src);
		src += DTT_SIZE1;
		dst += dst_inc;
		}
		}
		__syncthreads();

		#ifdef DEBUG1
		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nDTT Tiles after first replicating");
		printf("\nDTT Tiles after first replicating\n");
		debug_print_clt(clt_tile, 0xf33); // only 1 quadrant for R,B and 2 - for G
		}
		__syncthreads();
		@@ -754,54 +819,63 @@ __device__ void convertCorrectTile(
		case 0:// Red CC -> CS
		negate = (int_topleft[BAYER_RED][1] & 1) ^ BAYER_RED_ROW; // 1 - invert
		src = &clt_tile[BAYER_RED][0][0][threadIdx.x ];
		dst = &clt_tile[BAYER_RED][2][7][threadIdx.x ^ 7];
		dst = &clt_tile[BAYER_RED][2][7][threadIdx.x ];
		dst_inc = -DTT_SIZE1;
		break;
		case 1:// Red SC -> SS
		negate = (int_topleft[BAYER_RED][1] & 1) ^ BAYER_RED_ROW; // 1 - invert
		src = &clt_tile[BAYER_RED][1][0][threadIdx.x ];
		dst = &clt_tile[BAYER_RED][3][7][threadIdx.x ^ 7];
		dst = &clt_tile[BAYER_RED][3][7][threadIdx.x ];
		dst_inc = -DTT_SIZE1;
		break;
		case 2:// Blue CC -> CS
		negate = (int_topleft[BAYER_BLUE][1] & 1) ^ (BAYER_RED_ROW ^ 1); // 1 - invert
		src = &clt_tile[BAYER_BLUE][0][0][threadIdx.x ];
		dst = &clt_tile[BAYER_BLUE][2][7][threadIdx.x ^ 7];
		dst = &clt_tile[BAYER_BLUE][2][7][threadIdx.x ];
		dst_inc = -DTT_SIZE1;
		break;
		case 3:// Blue SC -> SS
		negate = (int_topleft[BAYER_BLUE][1] & 1) ^ (BAYER_RED_ROW ^ 1); // 1 - invert
		src = &clt_tile[BAYER_BLUE][1][0][threadIdx.x ];
		dst = &clt_tile[BAYER_BLUE][3][7][threadIdx.x ^ 7];
		dst = &clt_tile[BAYER_BLUE][3][7][threadIdx.x ];
		dst_inc = -DTT_SIZE1;
		break;
		}
		if (negate){
		#pragma unroll
		for (int i = 0; i < DTT_SIZE; i++){
		src = -(dst);
		dst = -(src);
		src += DTT_SIZE1;
		dst += dst_inc;
		}
		} else {
		#pragma unroll
		for (int i = 0; i < DTT_SIZE; i++){
		src = (dst);
		dst = (src);
		src += DTT_SIZE1;
		dst += dst_inc;
		}
		}
		__syncthreads();

		#ifdef DEBUG1
		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nDTT Tiles after second replicating");
		printf("\nDTT Tiles after second replicating\n");
		debug_print_clt(clt_tile, 0xfff); // only 1 quadrant for R,B and 2 - for G
		}
		__syncthreads();
		#endif


		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nKernel tiles to convolve\n");
		debug_print_clt(clt_kernels, 0xfff); // all colors, all quadrants
		}
		__syncthreads();
		#endif


		if (threadIdx.y < NUM_COLORS) {
		// convolve first, then rotate to match Java and make it easier to verify
		convolveTiles(
		@@ -809,10 +883,10 @@ __device__ void convertCorrectTile(
		clt_kernels[threadIdx.y]); // float kernel [4][DTT_SIZE][DTT_SIZE1]); // 4 quadrants of the CLT kernel (DTT3 converted)
		__syncthreads();
		}
		#ifdef DEBUG1
		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nDTT Tiles after convolution");
		debug_print_clt(clt_tile, 0xfff); // only 1 quadrant for R,B and 2 - for G
		printf("\nDTT Tiles after convolution\n");
		debug_print_clt(clt_tile, 0xfff); // all colors, all quadrants
		}
		__syncthreads();
		#endif
		@@ -825,9 +899,9 @@ __device__ void convertCorrectTile(
		residual_shift[threadIdx.y][0]); // float residual_shift);
		__syncthreads();
		}
		#ifdef DEBUG1
		#ifdef DEBUG2
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nDTT Tiles after horizontal shift");
		printf("\nDTT Tiles after horizontal shift\n");
		debug_print_clt(clt_tile, 0xfff); // only 1 quadrant for R,B and 2 - for G
		}
		__syncthreads();
		@@ -842,9 +916,9 @@ __device__ void convertCorrectTile(
		}
		#ifdef DEBUG1
		if ((threadIdx.x + threadIdx.y) == 0){
		printf("\nDTT Tiles after vertical shift");
		printf("\nDTT Tiles after vertical shift\n");
		debug_print_clt(clt_tile, 0xfff); // only 1 quadrant for R,B and 2 - for G
		printf("\nDTT All done");
		printf("\nDTT All done\n");
		}
		__syncthreads();
		#endif

Admin message