diff --git a/modules/ocl/perf/perf_opticalflow.cpp b/modules/ocl/perf/perf_opticalflow.cpp
index 936d7a77fc..10763b5b0f 100644
--- a/modules/ocl/perf/perf_opticalflow.cpp
+++ b/modules/ocl/perf/perf_opticalflow.cpp
@@ -48,8 +48,8 @@
 ///////////// PyrLKOpticalFlow ////////////////////////
 PERFTEST(PyrLKOpticalFlow)
 {
-    std::string images1[] = {"rubberwhale1.png", "basketball1.png"};
-    std::string images2[] = {"rubberwhale2.png", "basketball2.png"};
+    std::string images1[] = {"rubberwhale1.png", "aloeL.jpg"};
+    std::string images2[] = {"rubberwhale2.png", "aloeR.jpg"};
 
     for (size_t i = 0; i < sizeof(images1) / sizeof(std::string); i++)
     {
diff --git a/modules/ocl/src/opencl/pyrlk.cl b/modules/ocl/src/opencl/pyrlk.cl
index 40a1993952..02cf3afa44 100644
--- a/modules/ocl/src/opencl/pyrlk.cl
+++ b/modules/ocl/src/opencl/pyrlk.cl
@@ -17,6 +17,7 @@
 // @Authors
 //    Dachuan Zhao, dachuan@multicorewareinc.com
 //    Yao Wang, bitwangyaoyao@gmail.com
+//    Xiaopeng Fu, fuxiaopeng2222@163.com
 //
 // Redistribution and use in source and binary forms, with or without modification,
 // are permitted provided that the following conditions are met:
@@ -47,6 +48,7 @@
 //#pragma OPENCL EXTENSION cl_amd_printf : enable
 
 #define	BUFFER	64
+#define	BUFFER2	BUFFER>>1
 #ifndef WAVE_SIZE
 #define WAVE_SIZE 1
 #endif
@@ -58,53 +60,16 @@ void reduce3(float val1, float val2, float val3,  __local float* smem1,  __local
     smem3[tid] = val3;
     barrier(CLK_LOCAL_MEM_FENCE);
 
-    if (tid < 32)
+    for(int i = BUFFER2; i > 0; i >>= 1)
     {
-        smem1[tid] += smem1[tid + 32];
-        smem2[tid] += smem2[tid + 32];
-        smem3[tid] += smem3[tid + 32];
+        if(tid < i)
+        {
+            smem1[tid] += smem1[tid + i];
+            smem2[tid] += smem2[tid + i];
+            smem3[tid] += smem3[tid + i];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
     }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 16)
-    {
-        smem1[tid] += smem1[tid + 16];
-        smem2[tid] += smem2[tid + 16];
-        smem3[tid] += smem3[tid + 16];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 8)
-    {
-        smem1[tid] += smem1[tid + 8];
-        smem2[tid] += smem2[tid + 8];
-        smem3[tid] += smem3[tid + 8];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 4)
-    {
-        smem1[tid] += smem1[tid + 4];
-        smem2[tid] += smem2[tid + 4];
-        smem3[tid] += smem3[tid + 4];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 2)
-    {
-        smem1[tid] += smem1[tid + 2];
-        smem2[tid] += smem2[tid + 2];
-        smem3[tid] += smem3[tid + 2];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 1)
-    {
-        smem1[BUFFER] = smem1[tid] + smem1[tid + 1];
-        smem2[BUFFER] = smem2[tid] + smem2[tid + 1];
-        smem3[BUFFER] = smem3[tid] + smem3[tid + 1];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
 }
 
 void reduce2(float val1, float val2, volatile __local float* smem1, volatile __local float* smem2, int tid)
@@ -113,47 +78,15 @@ void reduce2(float val1, float val2, volatile __local float* smem1, volatile __l
     smem2[tid] = val2;
     barrier(CLK_LOCAL_MEM_FENCE);
 
-    if (tid < 32)
+    for(int i = BUFFER2; i > 0; i >>= 1)
     {
-        smem1[tid] += smem1[tid + 32];
-        smem2[tid] += smem2[tid + 32];
+        if(tid < i)
+        {
+            smem1[tid] += smem1[tid + i];
+            smem2[tid] += smem2[tid + i];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
     }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 16)
-    {
-        smem1[tid] += smem1[tid + 16];
-        smem2[tid] += smem2[tid + 16];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 8)
-    {
-        smem1[tid] += smem1[tid + 8];
-        smem2[tid] += smem2[tid + 8];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 4)
-    {
-        smem1[tid] += smem1[tid + 4];
-        smem2[tid] += smem2[tid + 4];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 2)
-    {
-        smem1[tid] += smem1[tid + 2];
-        smem2[tid] += smem2[tid + 2];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 1)
-    {
-        smem1[BUFFER] = smem1[tid] + smem1[tid + 1];
-        smem2[BUFFER] = smem2[tid] + smem2[tid + 1];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
 }
 
 void reduce1(float val1, volatile __local float* smem1, int tid)
@@ -161,45 +94,18 @@ void reduce1(float val1, volatile __local float* smem1, int tid)
     smem1[tid] = val1;
     barrier(CLK_LOCAL_MEM_FENCE);
 
-    if (tid < 32)
+    for(int i = BUFFER2; i > 0; i >>= 1)
     {
-        smem1[tid] += smem1[tid + 32];
+        if(tid < i)
+        {
+            smem1[tid] += smem1[tid + i];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
     }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 16)
-    {
-        smem1[tid] += smem1[tid + 16];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 8)
-    {
-        smem1[tid] += smem1[tid + 8];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 4)
-    {
-        smem1[tid] += smem1[tid + 4];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 2)
-    {
-        smem1[tid] += smem1[tid + 2];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
-
-    if (tid < 1)
-    {
-        smem1[BUFFER] = smem1[tid] + smem1[tid + 1];
-    }
-    barrier(CLK_LOCAL_MEM_FENCE);
 }
 #else
-void reduce3(float val1, float val2, float val3, 
-__local volatile float* smem1, __local volatile float* smem2, __local volatile float* smem3, int tid)
+void reduce3(float val1, float val2, float val3,
+             __local volatile float* smem1, __local volatile float* smem2, __local volatile float* smem3, int tid)
 {
     smem1[tid] = val1;
     smem2[tid] = val2;
@@ -212,15 +118,19 @@ __local volatile float* smem1, __local volatile float* smem2, __local volatile f
         smem2[tid] += smem2[tid + 32];
         smem3[tid] += smem3[tid + 32];
 #if WAVE_SIZE < 32
-	} barrier(CLK_LOCAL_MEM_FENCE);
-	if (tid < 16) {
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 16)
+    {
 #endif
         smem1[tid] += smem1[tid + 16];
         smem2[tid] += smem2[tid + 16];
         smem3[tid] += smem3[tid + 16];
 #if WAVE_SIZE <16
-	} barrier(CLK_LOCAL_MEM_FENCE);
-	if (tid < 8) {
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
 #endif
         smem1[tid] += smem1[tid + 8];
         smem2[tid] += smem2[tid + 8];
@@ -238,6 +148,7 @@ __local volatile float* smem1, __local volatile float* smem2, __local volatile f
         smem2[tid] += smem2[tid + 1];
         smem3[tid] += smem3[tid + 1];
     }
+    barrier(CLK_LOCAL_MEM_FENCE);
 }
 
 void reduce2(float val1, float val2, __local volatile float* smem1, __local volatile float* smem2, int tid)
@@ -251,14 +162,18 @@ void reduce2(float val1, float val2, __local volatile float* smem1, __local vola
         smem1[tid] += smem1[tid + 32];
         smem2[tid] += smem2[tid + 32];
 #if WAVE_SIZE < 32
-	} barrier(CLK_LOCAL_MEM_FENCE);
-	if (tid < 16) {
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 16)
+    {
 #endif
         smem1[tid] += smem1[tid + 16];
         smem2[tid] += smem2[tid + 16];
 #if WAVE_SIZE <16
-	} barrier(CLK_LOCAL_MEM_FENCE);
-	if (tid < 8) {
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
 #endif
         smem1[tid] += smem1[tid + 8];
         smem2[tid] += smem2[tid + 8];
@@ -272,6 +187,7 @@ void reduce2(float val1, float val2, __local volatile float* smem1, __local vola
         smem1[tid] += smem1[tid + 1];
         smem2[tid] += smem2[tid + 1];
     }
+    barrier(CLK_LOCAL_MEM_FENCE);
 }
 
 void reduce1(float val1, __local volatile float* smem1, int tid)
@@ -283,19 +199,24 @@ void reduce1(float val1, __local volatile float* smem1, int tid)
     {
         smem1[tid] += smem1[tid + 32];
 #if WAVE_SIZE < 32
-	} barrier(CLK_LOCAL_MEM_FENCE);
-	if (tid < 16) {
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 16)
+    {
 #endif
         smem1[tid] += smem1[tid + 16];
 #if WAVE_SIZE <16
-	} barrier(CLK_LOCAL_MEM_FENCE);
-	if (tid < 8) {
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
 #endif
         smem1[tid] += smem1[tid + 8];
         smem1[tid] += smem1[tid + 4];
         smem1[tid] += smem1[tid + 2];
         smem1[tid] += smem1[tid + 1];
     }
+    barrier(CLK_LOCAL_MEM_FENCE);
 }
 #endif
 
@@ -306,106 +227,100 @@ void reduce1(float val1, __local volatile float* smem1, int tid)
 __constant sampler_t sampler    = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_LINEAR;
 
 void SetPatch(image2d_t I, float x, float y,
-                                float* Pch, float* Dx, float* Dy,
-                                float* A11, float* A12, float* A22)
+              float* Pch, float* Dx, float* Dy,
+              float* A11, float* A12, float* A22)
 {
-            *Pch = read_imagef(I, sampler, (float2)(x, y)).x;
+    *Pch = read_imagef(I, sampler, (float2)(x, y)).x;
 
-            float dIdx = 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x + 1, y)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)).x -
-                             (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x - 1, y)).x + 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)).x);
+    float dIdx = 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x + 1, y)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)).x -
+                 (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x - 1, y)).x + 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)).x);
 
-            float dIdy = 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x, y + 1)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)).x -
-                            (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x, y - 1)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)).x);
+    float dIdy = 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x, y + 1)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)).x -
+                 (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x, y - 1)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)).x);
 
 
-            *Dx = dIdx;
-            *Dy = dIdy;
+    *Dx = dIdx;
+    *Dy = dIdy;
 
-            *A11 += dIdx * dIdx;
-            *A12 += dIdx * dIdy;
-            *A22 += dIdy * dIdy;
+    *A11 += dIdx * dIdx;
+    *A12 += dIdx * dIdy;
+    *A22 += dIdy * dIdy;
 }
 
 void GetPatch(image2d_t J, float x, float y,
-                                float* Pch, float* Dx, float* Dy,
-                                float* b1, float* b2)
+              float* Pch, float* Dx, float* Dy,
+              float* b1, float* b2)
 {
-                float J_val = read_imagef(J, sampler, (float2)(x, y)).x;
-                float diff = (J_val - *Pch) * 32.0f;
-                *b1 += diff**Dx;
-                *b2 += diff**Dy;
+    float J_val = read_imagef(J, sampler, (float2)(x, y)).x;
+    float diff = (J_val - *Pch) * 32.0f;
+    *b1 += diff**Dx;
+    *b2 += diff**Dy;
 }
 
 void GetError(image2d_t J, const float x, const float y, const float* Pch, float* errval)
 {
-        float diff = read_imagef(J, sampler, (float2)(x,y)).x-*Pch;
-        *errval += fabs(diff);
+    float diff = read_imagef(J, sampler, (float2)(x,y)).x-*Pch;
+    *errval += fabs(diff);
 }
 
 void SetPatch4(image2d_t I, const float x, const float y,
-                                float4* Pch, float4* Dx, float4* Dy,
-                                float* A11, float* A12, float* A22)
+               float4* Pch, float4* Dx, float4* Dy,
+               float* A11, float* A12, float* A22)
 {
-            *Pch = read_imagef(I, sampler, (float2)(x, y));
+    *Pch = read_imagef(I, sampler, (float2)(x, y));
 
-            float4 dIdx = 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)) + 10.0f * read_imagef(I, sampler, (float2)(x + 1, y)) + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)) -
-                             (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)) + 10.0f * read_imagef(I, sampler, (float2)(x - 1, y)) + 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)));
+    float4 dIdx = 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)) + 10.0f * read_imagef(I, sampler, (float2)(x + 1, y)) + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)) -
+                  (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)) + 10.0f * read_imagef(I, sampler, (float2)(x - 1, y)) + 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)));
 
-            float4 dIdy = 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)) + 10.0f * read_imagef(I, sampler, (float2)(x, y + 1)) + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)) -
-                            (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)) + 10.0f * read_imagef(I, sampler, (float2)(x, y - 1)) + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)));
+    float4 dIdy = 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)) + 10.0f * read_imagef(I, sampler, (float2)(x, y + 1)) + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)) -
+                  (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)) + 10.0f * read_imagef(I, sampler, (float2)(x, y - 1)) + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)));
 
 
-            *Dx = dIdx;
-            *Dy = dIdy;
-                        float4 sqIdx = dIdx * dIdx;
-                        *A11 += sqIdx.x + sqIdx.y + sqIdx.z;
-                        sqIdx = dIdx * dIdy;
-                        *A12 += sqIdx.x + sqIdx.y + sqIdx.z;
-                        sqIdx = dIdy * dIdy;
-                        *A22 += sqIdx.x + sqIdx.y + sqIdx.z;
+    *Dx = dIdx;
+    *Dy = dIdy;
+    float4 sqIdx = dIdx * dIdx;
+    *A11 += sqIdx.x + sqIdx.y + sqIdx.z;
+    sqIdx = dIdx * dIdy;
+    *A12 += sqIdx.x + sqIdx.y + sqIdx.z;
+    sqIdx = dIdy * dIdy;
+    *A22 += sqIdx.x + sqIdx.y + sqIdx.z;
 }
 
 void GetPatch4(image2d_t J, const float x, const float y,
-                                const float4* Pch, const float4* Dx, const float4* Dy,
-                                float* b1, float* b2)
+               const float4* Pch, const float4* Dx, const float4* Dy,
+               float* b1, float* b2)
 {
-                float4 J_val = read_imagef(J, sampler, (float2)(x, y));
-                float4 diff = (J_val - *Pch) * 32.0f;
-                                float4 xdiff = diff* *Dx;
-                                *b1 += xdiff.x + xdiff.y + xdiff.z;
-                                xdiff = diff* *Dy;
-                                *b2 += xdiff.x + xdiff.y + xdiff.z;
+    float4 J_val = read_imagef(J, sampler, (float2)(x, y));
+    float4 diff = (J_val - *Pch) * 32.0f;
+    float4 xdiff = diff* *Dx;
+    *b1 += xdiff.x + xdiff.y + xdiff.z;
+    xdiff = diff* *Dy;
+    *b2 += xdiff.x + xdiff.y + xdiff.z;
 }
 
 void GetError4(image2d_t J, const float x, const float y, const float4* Pch, float* errval)
 {
-        float4 diff = read_imagef(J, sampler, (float2)(x,y))-*Pch;
-        *errval += fabs(diff.x) + fabs(diff.y) + fabs(diff.z);
+    float4 diff = read_imagef(J, sampler, (float2)(x,y))-*Pch;
+    *errval += fabs(diff.x) + fabs(diff.y) + fabs(diff.z);
 }
 
 #define	GRIDSIZE	3
 __kernel void lkSparse_C1_D5(image2d_t I, image2d_t J,
-    __global const float2* prevPts, int prevPtsStep, __global float2* nextPts, int nextPtsStep, __global uchar* status, __global float* err,
-        const int level, const int rows, const int cols, int PATCH_X, int PATCH_Y, int cn, int c_winSize_x, int c_winSize_y, int c_iters, char calcErr)
+                             __global const float2* prevPts, int prevPtsStep, __global float2* nextPts, int nextPtsStep, __global uchar* status, __global float* err,
+                             const int level, const int rows, const int cols, int PATCH_X, int PATCH_Y, int cn, int c_winSize_x, int c_winSize_y, int c_iters, char calcErr)
 {
-#ifdef CPU
-    __local float smem1[BUFFER+1];
-    __local float smem2[BUFFER+1];
-    __local float smem3[BUFFER+1];
-#else
     __local float smem1[BUFFER];
     __local float smem2[BUFFER];
     __local float smem3[BUFFER];
-#endif
 
-        unsigned int xid=get_local_id(0);
-        unsigned int yid=get_local_id(1);
-        unsigned int gid=get_group_id(0);
-        unsigned int xsize=get_local_size(0);
-        unsigned int ysize=get_local_size(1);
-        int xBase, yBase, i, j, k;
+    unsigned int xid=get_local_id(0);
+    unsigned int yid=get_local_id(1);
+    unsigned int gid=get_group_id(0);
+    unsigned int xsize=get_local_size(0);
+    unsigned int ysize=get_local_size(1);
+    int xBase, yBase, i, j, k;
 
-        float2 c_halfWin = (float2)((c_winSize_x - 1)>>1, (c_winSize_y - 1)>>1);
+    float2 c_halfWin = (float2)((c_winSize_x - 1)>>1, (c_winSize_y - 1)>>1);
 
     const int tid = mad24(yid, xsize, xid);
 
@@ -432,77 +347,71 @@ __kernel void lkSparse_C1_D5(image2d_t I, image2d_t J,
     float dIdx_patch[GRIDSIZE][GRIDSIZE];
     float dIdy_patch[GRIDSIZE][GRIDSIZE];
 
-        yBase=yid;
-        {
-                xBase=xid;
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[0][0], &dIdx_patch[0][0], &dIdy_patch[0][0],
-                                        &A11, &A12, &A22);
+    yBase=yid;
+    {
+        xBase=xid;
+        SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                 &I_patch[0][0], &dIdx_patch[0][0], &dIdy_patch[0][0],
+                 &A11, &A12, &A22);
 
 
-                xBase+=xsize;
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[0][1], &dIdx_patch[0][1], &dIdy_patch[0][1],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                 &I_patch[0][1], &dIdx_patch[0][1], &dIdy_patch[0][1],
+                 &A11, &A12, &A22);
 
-                xBase+=xsize;
-                if(xBase<c_winSize_x)
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[0][2], &dIdx_patch[0][2], &dIdy_patch[0][2],
-                                        &A11, &A12, &A22);
-        }
-        yBase+=ysize;
-        {
-                xBase=xid;
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[1][0], &dIdx_patch[1][0], &dIdy_patch[1][0],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        if(xBase<c_winSize_x)
+            SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[0][2], &dIdx_patch[0][2], &dIdy_patch[0][2],
+                     &A11, &A12, &A22);
+    }
+    yBase+=ysize;
+    {
+        xBase=xid;
+        SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                 &I_patch[1][0], &dIdx_patch[1][0], &dIdy_patch[1][0],
+                 &A11, &A12, &A22);
 
 
-                xBase+=xsize;
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[1][1], &dIdx_patch[1][1], &dIdy_patch[1][1],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                 &I_patch[1][1], &dIdx_patch[1][1], &dIdy_patch[1][1],
+                 &A11, &A12, &A22);
 
-                xBase+=xsize;
-                if(xBase<c_winSize_x)
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[1][2], &dIdx_patch[1][2], &dIdy_patch[1][2],
-                                        &A11, &A12, &A22);
-        }
-        yBase+=ysize;
-        if(yBase<c_winSize_y)
-        {
-                xBase=xid;
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[2][0], &dIdx_patch[2][0], &dIdy_patch[2][0],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        if(xBase<c_winSize_x)
+            SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[1][2], &dIdx_patch[1][2], &dIdy_patch[1][2],
+                     &A11, &A12, &A22);
+    }
+    yBase+=ysize;
+    if(yBase<c_winSize_y)
+    {
+        xBase=xid;
+        SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                 &I_patch[2][0], &dIdx_patch[2][0], &dIdy_patch[2][0],
+                 &A11, &A12, &A22);
 
 
-                xBase+=xsize;
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[2][1], &dIdx_patch[2][1], &dIdy_patch[2][1],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                 &I_patch[2][1], &dIdx_patch[2][1], &dIdy_patch[2][1],
+                 &A11, &A12, &A22);
 
-                xBase+=xsize;
-                if(xBase<c_winSize_x)
-                SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                        &I_patch[2][2], &dIdx_patch[2][2], &dIdy_patch[2][2],
-                                        &A11, &A12, &A22);
-        }
+        xBase+=xsize;
+        if(xBase<c_winSize_x)
+            SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[2][2], &dIdx_patch[2][2], &dIdy_patch[2][2],
+                     &A11, &A12, &A22);
+    }
 
     reduce3(A11, A12, A22, smem1, smem2, smem3, tid);
-    barrier(CLK_LOCAL_MEM_FENCE);
 
-#ifdef CPU
-    A11 = smem1[BUFFER];
-    A12 = smem2[BUFFER];
-    A22 = smem3[BUFFER];
-#else
     A11 = smem1[0];
     A12 = smem2[0];
     A22 = smem3[0];
-#endif
+    barrier(CLK_LOCAL_MEM_FENCE);
 
     float D = A11 * A22 - A12 * A12;
 
@@ -532,81 +441,76 @@ __kernel void lkSparse_C1_D5(image2d_t I, image2d_t J,
         float b1 = 0;
         float b2 = 0;
 
-                yBase=yid;
-                {
-                        xBase=xid;
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[0][0], &dIdx_patch[0][0], &dIdy_patch[0][0],
-                                                &b1, &b2);
+        yBase=yid;
+        {
+            xBase=xid;
+            GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[0][0], &dIdx_patch[0][0], &dIdy_patch[0][0],
+                     &b1, &b2);
 
 
-                        xBase+=xsize;
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[0][1], &dIdx_patch[0][1], &dIdy_patch[0][1],
-                                                &b1, &b2);
+            xBase+=xsize;
+            GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[0][1], &dIdx_patch[0][1], &dIdy_patch[0][1],
+                     &b1, &b2);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[0][2], &dIdx_patch[0][2], &dIdy_patch[0][2],
-                                                &b1, &b2);
-                }
-                yBase+=ysize;
-                {
-                        xBase=xid;
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[1][0], &dIdx_patch[1][0], &dIdy_patch[1][0],
-                                                &b1, &b2);
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                         &I_patch[0][2], &dIdx_patch[0][2], &dIdy_patch[0][2],
+                         &b1, &b2);
+        }
+        yBase+=ysize;
+        {
+            xBase=xid;
+            GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[1][0], &dIdx_patch[1][0], &dIdy_patch[1][0],
+                     &b1, &b2);
 
 
-                        xBase+=xsize;
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[1][1], &dIdx_patch[1][1], &dIdy_patch[1][1],
-                                                &b1, &b2);
+            xBase+=xsize;
+            GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[1][1], &dIdx_patch[1][1], &dIdy_patch[1][1],
+                     &b1, &b2);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[1][2], &dIdx_patch[1][2], &dIdy_patch[1][2],
-                                                &b1, &b2);
-                }
-                yBase+=ysize;
-                if(yBase<c_winSize_y)
-                {
-                        xBase=xid;
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[2][0], &dIdx_patch[2][0], &dIdy_patch[2][0],
-                                                &b1, &b2);
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                         &I_patch[1][2], &dIdx_patch[1][2], &dIdy_patch[1][2],
+                         &b1, &b2);
+        }
+        yBase+=ysize;
+        if(yBase<c_winSize_y)
+        {
+            xBase=xid;
+            GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[2][0], &dIdx_patch[2][0], &dIdy_patch[2][0],
+                     &b1, &b2);
 
 
-                        xBase+=xsize;
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[2][1], &dIdx_patch[2][1], &dIdy_patch[2][1],
-                                                &b1, &b2);
+            xBase+=xsize;
+            GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[2][1], &dIdx_patch[2][1], &dIdy_patch[2][1],
+                     &b1, &b2);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[2][2], &dIdx_patch[2][2], &dIdy_patch[2][2],
-                                                &b1, &b2);
-                }
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetPatch(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                         &I_patch[2][2], &dIdx_patch[2][2], &dIdy_patch[2][2],
+                         &b1, &b2);
+        }
 
         reduce2(b1, b2, smem1, smem2, tid);
-        barrier(CLK_LOCAL_MEM_FENCE);
 
-#ifdef CPU
-        b1 = smem1[BUFFER];
-        b2 = smem2[BUFFER];
-#else
         b1 = smem1[0];
         b2 = smem2[0];
-#endif
+        barrier(CLK_LOCAL_MEM_FENCE);
 
         float2 delta;
         delta.x = A12 * b2 - A22 * b1;
         delta.y = A12 * b1 - A11 * b2;
 
-                prevPt += delta;
+        prevPt += delta;
 
         if (fabs(delta.x) < THRESHOLD && fabs(delta.y) < THRESHOLD)
             break;
@@ -615,97 +519,87 @@ __kernel void lkSparse_C1_D5(image2d_t I, image2d_t J,
     D = 0.0f;
     if (calcErr)
     {
-                yBase=yid;
-                {
-                        xBase=xid;
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[0][0], &D);
+        yBase=yid;
+        {
+            xBase=xid;
+            GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[0][0], &D);
 
 
-                        xBase+=xsize;
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[0][1], &D);
+            xBase+=xsize;
+            GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[0][1], &D);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[0][2], &D);
-                }
-                yBase+=ysize;
-                {
-                        xBase=xid;
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[1][0], &D);
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                         &I_patch[0][2], &D);
+        }
+        yBase+=ysize;
+        {
+            xBase=xid;
+            GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[1][0], &D);
 
 
-                        xBase+=xsize;
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[1][1], &D);
+            xBase+=xsize;
+            GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[1][1], &D);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[1][2], &D);
-                }
-                yBase+=ysize;
-                if(yBase<c_winSize_y)
-                {
-                        xBase=xid;
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[2][0], &D);
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                         &I_patch[1][2], &D);
+        }
+        yBase+=ysize;
+        if(yBase<c_winSize_y)
+        {
+            xBase=xid;
+            GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[2][0], &D);
 
 
-                        xBase+=xsize;
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[2][1], &D);
+            xBase+=xsize;
+            GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                     &I_patch[2][1], &D);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
-                                                &I_patch[2][2], &D);
-                }
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetError(J, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f,
+                         &I_patch[2][2], &D);
+        }
 
         reduce1(D, smem1, tid);
     }
 
     if (tid == 0)
     {
-                prevPt += c_halfWin;
+        prevPt += c_halfWin;
 
         nextPts[gid] = prevPt;
 
         if (calcErr)
-#ifdef CPU
-            err[gid] = smem1[BUFFER] / (float)(c_winSize_x * c_winSize_y);
-#else
             err[gid] = smem1[0] / (float)(c_winSize_x * c_winSize_y);
-#endif
     }
 }
 
 
 __kernel void lkSparse_C4_D5(image2d_t I, image2d_t J,
-    __global const float2* prevPts, int prevPtsStep, __global float2* nextPts, int nextPtsStep, __global uchar* status, __global float* err,
-        const int level, const int rows, const int cols, int PATCH_X, int PATCH_Y, int cn, int c_winSize_x, int c_winSize_y, int c_iters, char calcErr)
+                             __global const float2* prevPts, int prevPtsStep, __global float2* nextPts, int nextPtsStep, __global uchar* status, __global float* err,
+                             const int level, const int rows, const int cols, int PATCH_X, int PATCH_Y, int cn, int c_winSize_x, int c_winSize_y, int c_iters, char calcErr)
 {
-#ifdef CPU
-     __local float smem1[BUFFER+1];
-     __local float smem2[BUFFER+1];
-     __local float smem3[BUFFER+1];
-#else
-     __local float smem1[BUFFER];
-     __local float smem2[BUFFER];
-     __local float smem3[BUFFER];
-#endif
+    __local float smem1[BUFFER];
+    __local float smem2[BUFFER];
+    __local float smem3[BUFFER];
 
-        unsigned int xid=get_local_id(0);
-        unsigned int yid=get_local_id(1);
-        unsigned int gid=get_group_id(0);
-        unsigned int xsize=get_local_size(0);
-        unsigned int ysize=get_local_size(1);
-        int xBase, yBase, i, j, k;
+    unsigned int xid=get_local_id(0);
+    unsigned int yid=get_local_id(1);
+    unsigned int gid=get_group_id(0);
+    unsigned int xsize=get_local_size(0);
+    unsigned int ysize=get_local_size(1);
+    int xBase, yBase, i, j, k;
 
-        float2 c_halfWin = (float2)((c_winSize_x - 1)>>1, (c_winSize_y - 1)>>1);
+    float2 c_halfWin = (float2)((c_winSize_x - 1)>>1, (c_winSize_y - 1)>>1);
 
     const int tid = mad24(yid, xsize, xid);
 
@@ -721,7 +615,7 @@ __kernel void lkSparse_C4_D5(image2d_t I, image2d_t J,
         return;
     }
 
-        nextPt -= c_halfWin;
+    nextPt -= c_halfWin;
 
     // extract the patch from the first image, compute covariation matrix of derivatives
 
@@ -732,80 +626,74 @@ __kernel void lkSparse_C4_D5(image2d_t I, image2d_t J,
     float4 I_patch[8];
     float4 dIdx_patch[8];
     float4 dIdy_patch[8];
-        float4 I_add,Dx_add,Dy_add;
+    float4 I_add,Dx_add,Dy_add;
 
-        yBase=yid;
-        {
-                xBase=xid;
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_patch[0], &dIdx_patch[0], &dIdy_patch[0],
-                                        &A11, &A12, &A22);
+    yBase=yid;
+    {
+        xBase=xid;
+        SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                  &I_patch[0], &dIdx_patch[0], &dIdy_patch[0],
+                  &A11, &A12, &A22);
 
 
-                xBase+=xsize;
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_patch[1], &dIdx_patch[1], &dIdy_patch[1],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                  &I_patch[1], &dIdx_patch[1], &dIdy_patch[1],
+                  &A11, &A12, &A22);
 
-                xBase+=xsize;
-                if(xBase<c_winSize_x)
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_patch[2], &dIdx_patch[2], &dIdy_patch[2],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        if(xBase<c_winSize_x)
+            SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[2], &dIdx_patch[2], &dIdy_patch[2],
+                      &A11, &A12, &A22);
 
-        }
-        yBase+=ysize;
-        {
-                xBase=xid;
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_patch[3], &dIdx_patch[3], &dIdy_patch[3],
-                                        &A11, &A12, &A22);
+    }
+    yBase+=ysize;
+    {
+        xBase=xid;
+        SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                  &I_patch[3], &dIdx_patch[3], &dIdy_patch[3],
+                  &A11, &A12, &A22);
 
 
-                xBase+=xsize;
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_patch[4], &dIdx_patch[4], &dIdy_patch[4],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                  &I_patch[4], &dIdx_patch[4], &dIdy_patch[4],
+                  &A11, &A12, &A22);
 
-                xBase+=xsize;
-                if(xBase<c_winSize_x)
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_patch[5], &dIdx_patch[5], &dIdy_patch[5],
-                                        &A11, &A12, &A22);
-        }
-        yBase+=ysize;
-        if(yBase<c_winSize_y)
-        {
-                xBase=xid;
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_patch[6], &dIdx_patch[6], &dIdy_patch[6],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        if(xBase<c_winSize_x)
+            SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[5], &dIdx_patch[5], &dIdy_patch[5],
+                      &A11, &A12, &A22);
+    }
+    yBase+=ysize;
+    if(yBase<c_winSize_y)
+    {
+        xBase=xid;
+        SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                  &I_patch[6], &dIdx_patch[6], &dIdy_patch[6],
+                  &A11, &A12, &A22);
 
 
-                xBase+=xsize;
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_patch[7], &dIdx_patch[7], &dIdy_patch[7],
-                                        &A11, &A12, &A22);
+        xBase+=xsize;
+        SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                  &I_patch[7], &dIdx_patch[7], &dIdy_patch[7],
+                  &A11, &A12, &A22);
 
-                xBase+=xsize;
-                if(xBase<c_winSize_x)
-                SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                        &I_add, &Dx_add, &Dy_add,
-                                        &A11, &A12, &A22);
-        }
+        xBase+=xsize;
+        if(xBase<c_winSize_x)
+            SetPatch4(I, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_add, &Dx_add, &Dy_add,
+                      &A11, &A12, &A22);
+    }
 
     reduce3(A11, A12, A22, smem1, smem2, smem3, tid);
-    barrier(CLK_LOCAL_MEM_FENCE);
 
-#ifdef CPU
-    A11 = smem1[BUFFER];
-    A12 = smem2[BUFFER];
-    A22 = smem3[BUFFER];
-#else
     A11 = smem1[0];
     A12 = smem2[0];
     A22 = smem3[0];
-#endif
+    barrier(CLK_LOCAL_MEM_FENCE);
 
     float D = A11 * A22 - A12 * A12;
 
@@ -821,7 +709,7 @@ __kernel void lkSparse_C4_D5(image2d_t I, image2d_t J,
     A12 /= D;
     A22 /= D;
 
-        nextPt = nextPts[gid] * 2.0f - c_halfWin;
+    nextPt = nextPts[gid] * 2.0f - c_halfWin;
 
     for (k = 0; k < c_iters; ++k)
     {
@@ -835,81 +723,76 @@ __kernel void lkSparse_C4_D5(image2d_t I, image2d_t J,
         float b1 = 0;
         float b2 = 0;
 
-                yBase=yid;
-                {
-                        xBase=xid;
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[0], &dIdx_patch[0], &dIdy_patch[0],
-                                                &b1, &b2);
+        yBase=yid;
+        {
+            xBase=xid;
+            GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[0], &dIdx_patch[0], &dIdy_patch[0],
+                      &b1, &b2);
 
 
-                        xBase+=xsize;
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[1], &dIdx_patch[1], &dIdy_patch[1],
-                                                &b1, &b2);
+            xBase+=xsize;
+            GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[1], &dIdx_patch[1], &dIdy_patch[1],
+                      &b1, &b2);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[2], &dIdx_patch[2], &dIdy_patch[2],
-                                                &b1, &b2);
-                }
-                yBase+=ysize;
-                {
-                        xBase=xid;
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[3], &dIdx_patch[3], &dIdy_patch[3],
-                                                &b1, &b2);
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                          &I_patch[2], &dIdx_patch[2], &dIdy_patch[2],
+                          &b1, &b2);
+        }
+        yBase+=ysize;
+        {
+            xBase=xid;
+            GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[3], &dIdx_patch[3], &dIdy_patch[3],
+                      &b1, &b2);
 
 
-                        xBase+=xsize;
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[4], &dIdx_patch[4], &dIdy_patch[4],
-                                                &b1, &b2);
+            xBase+=xsize;
+            GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[4], &dIdx_patch[4], &dIdy_patch[4],
+                      &b1, &b2);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[5], &dIdx_patch[5], &dIdy_patch[5],
-                                                &b1, &b2);
-                }
-                yBase+=ysize;
-                if(yBase<c_winSize_y)
-                {
-                        xBase=xid;
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[6], &dIdx_patch[6], &dIdy_patch[6],
-                                                &b1, &b2);
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                          &I_patch[5], &dIdx_patch[5], &dIdy_patch[5],
+                          &b1, &b2);
+        }
+        yBase+=ysize;
+        if(yBase<c_winSize_y)
+        {
+            xBase=xid;
+            GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[6], &dIdx_patch[6], &dIdy_patch[6],
+                      &b1, &b2);
 
 
-                        xBase+=xsize;
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[7], &dIdx_patch[7], &dIdy_patch[7],
-                                                &b1, &b2);
+            xBase+=xsize;
+            GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[7], &dIdx_patch[7], &dIdy_patch[7],
+                      &b1, &b2);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_add, &Dx_add, &Dy_add,
-                                                &b1, &b2);
-                }
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetPatch4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                          &I_add, &Dx_add, &Dy_add,
+                          &b1, &b2);
+        }
 
         reduce2(b1, b2, smem1, smem2, tid);
-        barrier(CLK_LOCAL_MEM_FENCE);
 
-#ifdef CPU
-        b1 = smem1[BUFFER];
-        b2 = smem2[BUFFER];
-#else
         b1 = smem1[0];
         b2 = smem2[0];
-#endif
+        barrier(CLK_LOCAL_MEM_FENCE);
 
         float2 delta;
         delta.x = A12 * b2 - A22 * b1;
         delta.y = A12 * b1 - A11 * b2;
 
-                nextPt +=delta;
+        nextPt +=delta;
 
         if (fabs(delta.x) < THRESHOLD && fabs(delta.y) < THRESHOLD)
             break;
@@ -918,78 +801,74 @@ __kernel void lkSparse_C4_D5(image2d_t I, image2d_t J,
     D = 0.0f;
     if (calcErr)
     {
-                yBase=yid;
-                {
-                        xBase=xid;
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[0], &D);
+        yBase=yid;
+        {
+            xBase=xid;
+            GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[0], &D);
 
 
-                        xBase+=xsize;
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[1], &D);
+            xBase+=xsize;
+            GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[1], &D);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[2], &D);
-                }
-                yBase+=ysize;
-                {
-                        xBase=xid;
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[3], &D);
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                          &I_patch[2], &D);
+        }
+        yBase+=ysize;
+        {
+            xBase=xid;
+            GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[3], &D);
 
 
-                        xBase+=xsize;
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[4], &D);
+            xBase+=xsize;
+            GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[4], &D);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[5], &D);
-                }
-                yBase+=ysize;
-                if(yBase<c_winSize_y)
-                {
-                        xBase=xid;
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[6], &D);
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                          &I_patch[5], &D);
+        }
+        yBase+=ysize;
+        if(yBase<c_winSize_y)
+        {
+            xBase=xid;
+            GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[6], &D);
 
 
-                        xBase+=xsize;
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_patch[7], &D);
+            xBase+=xsize;
+            GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                      &I_patch[7], &D);
 
-                        xBase+=xsize;
-                        if(xBase<c_winSize_x)
-                        GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
-                                                &I_add, &D);
-                }
+            xBase+=xsize;
+            if(xBase<c_winSize_x)
+                GetError4(J, nextPt.x + xBase + 0.5f, nextPt.y + yBase + 0.5f,
+                          &I_add, &D);
+        }
 
         reduce1(D, smem1, tid);
     }
 
     if (tid == 0)
     {
-                nextPt += c_halfWin;
+        nextPt += c_halfWin;
         nextPts[gid] = nextPt;
 
         if (calcErr)
-#ifdef CPU
-            err[gid] = smem1[BUFFER] / (float)(3 * c_winSize_x * c_winSize_y);
-#else
             err[gid] = smem1[0] / (float)(3 * c_winSize_x * c_winSize_y);
-#endif
     }
 }
 
 __kernel void lkDense_C1_D0(image2d_t I, image2d_t J, __global float* u, int uStep, __global float* v, int vStep, __global const float* prevU, int prevUStep, __global const float* prevV, int prevVStep,
-    const int rows, const int cols, /*__global float* err, int errStep, int cn,*/ int c_winSize_x, int c_winSize_y, int c_iters, char calcErr)
+                            const int rows, const int cols, /*__global float* err, int errStep, int cn,*/ int c_winSize_x, int c_winSize_y, int c_iters, char calcErr)
 {
-        int c_halfWin_x = (c_winSize_x - 1) / 2;
-        int c_halfWin_y = (c_winSize_y - 1) / 2;
+    int c_halfWin_x = (c_winSize_x - 1) / 2;
+    int c_halfWin_y = (c_winSize_y - 1) / 2;
 
     const int patchWidth  = get_local_size(0) + 2 * c_halfWin_x;
     const int patchHeight = get_local_size(1) + 2 * c_halfWin_y;
@@ -1003,7 +882,7 @@ __kernel void lkDense_C1_D0(image2d_t I, image2d_t J, __global float* u, int uSt
     const int xBase = get_group_id(0) * get_local_size(0);
     const int yBase = get_group_id(1) * get_local_size(1);
 
-        sampler_t sampleri    = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+    sampler_t sampleri    = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
 
     for (int i = get_local_id(1); i < patchHeight; i += get_local_size(1))
     {
@@ -1017,10 +896,10 @@ __kernel void lkDense_C1_D0(image2d_t I, image2d_t J, __global float* u, int uSt
             // Sharr Deriv
 
             dIdx_patch[i * patchWidth + j] = 3 * read_imagei(I, sampleri, (float2)(x+1, y-1)).x + 10 * read_imagei(I, sampleri, (float2)(x+1, y)).x + 3 * read_imagei(I, sampleri, (float2)(x+1, y+1)).x -
-                                            (3 * read_imagei(I, sampleri, (float2)(x-1, y-1)).x + 10 * read_imagei(I, sampleri, (float2)(x-1, y)).x + 3 * read_imagei(I, sampleri, (float2)(x-1, y+1)).x);
+                                             (3 * read_imagei(I, sampleri, (float2)(x-1, y-1)).x + 10 * read_imagei(I, sampleri, (float2)(x-1, y)).x + 3 * read_imagei(I, sampleri, (float2)(x-1, y+1)).x);
 
             dIdy_patch[i * patchWidth + j] = 3 * read_imagei(I, sampleri, (float2)(x-1, y+1)).x + 10 * read_imagei(I, sampleri, (float2)(x, y+1)).x + 3 * read_imagei(I, sampleri, (float2)(x+1, y+1)).x -
-                                            (3 * read_imagei(I, sampleri, (float2)(x-1, y-1)).x + 10 * read_imagei(I, sampleri, (float2)(x, y-1)).x + 3 * read_imagei(I, sampleri, (float2)(x+1, y-1)).x);
+                                             (3 * read_imagei(I, sampleri, (float2)(x-1, y-1)).x + 10 * read_imagei(I, sampleri, (float2)(x, y-1)).x + 3 * read_imagei(I, sampleri, (float2)(x+1, y-1)).x);
         }
     }
     barrier(CLK_LOCAL_MEM_FENCE);