uchar* dst, size_t dst_step,

Size size, size_t pix_size )

{

int j;

size.width *= (int)(pix_size / sizeof(int));

for( ; size.height--; src += src_step, dst += dst_step )

{

j=0;

#if CV_ENABLE_UNROLLED

for( ; j <= size.width - 4; j += 4 )

{

int t0 = ((const int*)src)[j];

int t1 = ((const int*)src)[j+1];

((int*)dst)[j] = t0;

((int*)dst)[j+1] = t1;

t0 = ((const int*)src)[j+2];

t1 = ((const int*)src)[j+3];

((int*)dst)[j+2] = t0;

((int*)dst)[j+3] = t1;

}

#endif

for( ; j < size.width; j++ )

((int*)dst)[j] = ((const int*)src)[j];

}

uchar* dst, size_t dst_step,

Size size, size_t pix_size )

{

int i, j;

for( i = 0; i < size.width; i++, dst += dst_step, src += pix_size )

{

const uchar* _src = src;

switch( pix_size )

{

case sizeof(int):

for( j = 0; j < size.height; j++, _src += src_step )

((int*)dst)[j] = ((int*)_src)[0];

break;

case sizeof(int)*2:

for( j = 0; j < size.height*2; j += 2, _src += src_step )

{

int t0 = ((int*)_src)[0];

int t1 = ((int*)_src)[1];

((int*)dst)[j] = t0;

((int*)dst)[j+1] = t1;

}

break;

case sizeof(int)*4:

for( j = 0; j < size.height*4; j += 4, _src += src_step )

{

int t0 = ((int*)_src)[0];

int t1 = ((int*)_src)[1];

((int*)dst)[j] = t0;

((int*)dst)[j+1] = t1;

t0 = ((int*)_src)[2];

t1 = ((int*)_src)[3];

((int*)dst)[j+2] = t0;

((int*)dst)[j+3] = t1;

}

break;

default:

assert(0);

return;

}

}

const T* b_data, size_t b_step,

const T* c_data, size_t c_step,

T* d_data, size_t d_step,

Size a_size, Size d_size,

double alpha, double beta, int flags )

{

int i, j, k, n = a_size.width, m = d_size.width, drows = d_size.height;

const T *_a_data = a_data, *_b_data = b_data, *_c_data = c_data;

cv::AutoBuffer<T> _a_buf;

T* a_buf = 0;

size_t a_step0, a_step1, c_step0, c_step1, t_step;

a_step /= sizeof(a_data[0]);

b_step /= sizeof(b_data[0]);

c_step /= sizeof(c_data[0]);

d_step /= sizeof(d_data[0]);

a_step0 = a_step;

a_step1 = 1;

if( !c_data )

c_step0 = c_step1 = 0;

else if( !(flags & GEMM_3_T) )

c_step0 = c_step, c_step1 = 1;

else

c_step0 = 1, c_step1 = c_step;

if( flags & GEMM_1_T )

{

CV_SWAP( a_step0, a_step1, t_step );

n = a_size.height;

if( a_step > 1 && n > 1 )

{

_a_buf.allocate(n);

a_buf = _a_buf.data();

}

}

if( n == 1 ) /* external product */

{

cv::AutoBuffer<T> _b_buf;

T* b_buf = 0;

if( a_step > 1 && a_size.height > 1 )

{

_a_buf.allocate(drows);

a_buf = _a_buf.data();

for( k = 0; k < drows; k++ )

a_buf[k] = a_data[a_step*k];

a_data = a_buf;

}

if( b_step > 1 )

{

_b_buf.allocate(d_size.width);

b_buf = _b_buf.data();

for( j = 0; j < d_size.width; j++ )

b_buf[j] = b_data[j*b_step];

b_data = b_buf;

}

for( i = 0; i < drows; i++, _c_data += c_step0, d_data += d_step )

{

WT al = WT(a_data[i])*alpha;

c_data = _c_data;

for( j = 0; j <= d_size.width - 2; j += 2, c_data += 2*c_step1 )

{

WT s0 = al*WT(b_data[j]);

WT s1 = al*WT(b_data[j+1]);

if( !c_data )

{

d_data[j] = T(s0);

d_data[j+1] = T(s1);

}

else

{

d_data[j] = T(s0 + WT(c_data[0])*beta);

d_data[j+1] = T(s1 + WT(c_data[c_step1])*beta);

}

}

for( ; j < d_size.width; j++, c_data += c_step1 )

{

WT s0 = al*WT(b_data[j]);

if( !c_data )

d_data[j] = T(s0);

else

d_data[j] = T(s0 + WT(c_data[0])*beta);

}

}

}

else if( flags & GEMM_2_T ) /* A * Bt */

{

for( i = 0; i < drows; i++, _a_data += a_step0, _c_data += c_step0, d_data += d_step )

{

a_data = _a_data;

b_data = _b_data;

c_data = _c_data;

if( a_buf )

{

for( k = 0; k < n; k++ )

a_buf[k] = a_data[a_step1*k];

a_data = a_buf;

}

for( j = 0; j < d_size.width; j++, b_data += b_step,

c_data += c_step1 )

{

WT s0(0), s1(0), s2(0), s3(0);

k = 0;

#if CV_ENABLE_UNROLLED

for( ; k <= n - 4; k += 4 )

{

s0 += WT(a_data[k])*WT(b_data[k]);

s1 += WT(a_data[k+1])*WT(b_data[k+1]);

s2 += WT(a_data[k+2])*WT(b_data[k+2]);

s3 += WT(a_data[k+3])*WT(b_data[k+3]);

}

#endif

for( ; k < n; k++ )

s0 += WT(a_data[k])*WT(b_data[k]);

s0 = (s0+s1+s2+s3)*alpha;

if( !c_data )

d_data[j] = T(s0);

else

d_data[j] = T(s0 + WT(c_data[0])*beta);

}

}

}

else if( d_size.width*sizeof(d_data[0]) <= 1600 )

{

for( i = 0; i < drows; i++, _a_data += a_step0,

_c_data += c_step0,

d_data += d_step )

{

a_data = _a_data, c_data = _c_data;

if( a_buf )

{

for( k = 0; k < n; k++ )

a_buf[k] = a_data[a_step1*k];

a_data = a_buf;

}

for( j = 0; j <= m - 4; j += 4, c_data += 4*c_step1 )

{

const T* b = _b_data + j;

WT s0(0), s1(0), s2(0), s3(0);

for( k = 0; k < n; k++, b += b_step )

{

WT a(a_data[k]);

s0 += a * WT(b[0]); s1 += a * WT(b[1]);

s2 += a * WT(b[2]); s3 += a * WT(b[3]);

}

if( !c_data )

{

d_data[j] = T(s0*alpha);

d_data[j+1] = T(s1*alpha);

d_data[j+2] = T(s2*alpha);

d_data[j+3] = T(s3*alpha);

}

else

{

s0 = s0*alpha; s1 = s1*alpha;

s2 = s2*alpha; s3 = s3*alpha;

d_data[j] = T(s0 + WT(c_data[0])*beta);

d_data[j+1] = T(s1 + WT(c_data[c_step1])*beta);

d_data[j+2] = T(s2 + WT(c_data[c_step1*2])*beta);

d_data[j+3] = T(s3 + WT(c_data[c_step1*3])*beta);

}

}

for( ; j < m; j++, c_data += c_step1 )

{

const T* b = _b_data + j;

WT s0(0);

for( k = 0; k < n; k++, b += b_step )

s0 += WT(a_data[k]) * WT(b[0]);

s0 = s0*alpha;

if( !c_data )

d_data[j] = T(s0);

else

d_data[j] = T(s0 + WT(c_data[0])*beta);

}

}

}

else

{

cv::AutoBuffer<WT> _d_buf(m);

WT* d_buf = _d_buf.data();

for( i = 0; i < drows; i++, _a_data += a_step0, _c_data += c_step0, d_data += d_step )

{

a_data = _a_data;

b_data = _b_data;

c_data = _c_data;

if( a_buf )

{

for( k = 0; k < n; k++ )

a_buf[k] = _a_data[a_step1*k];

a_data = a_buf;

}

for( j = 0; j < m; j++ )

d_buf[j] = WT(0);

for( k = 0; k < n; k++, b_data += b_step )

{

WT al(a_data[k]);

j=0;

#if CV_ENABLE_UNROLLED

for(; j <= m - 4; j += 4 )

{

WT t0 = d_buf[j] + WT(b_data[j])*al;

WT t1 = d_buf[j+1] + WT(b_data[j+1])*al;

d_buf[j] = t0;

d_buf[j+1] = t1;

t0 = d_buf[j+2] + WT(b_data[j+2])*al;

t1 = d_buf[j+3] + WT(b_data[j+3])*al;

d_buf[j+2] = t0;

d_buf[j+3] = t1;

}

#endif

for( ; j < m; j++ )

d_buf[j] += WT(b_data[j])*al;

}

if( !c_data )

for( j = 0; j < m; j++ )

d_data[j] = T(d_buf[j]*alpha);

else

for( j = 0; j < m; j++, c_data += c_step1 )

{

WT t = d_buf[j]*alpha;

d_data[j] = T(t + WT(c_data[0])*beta);

}

}

}

const T* b_data, size_t b_step,

WT* d_data, size_t d_step,

Size a_size, Size d_size, int flags )

{

int i, j, k, n = a_size.width, m = d_size.width;

const T *_a_data = a_data, *_b_data = b_data;

cv::AutoBuffer<T> _a_buf;

T* a_buf = 0;

size_t a_step0, a_step1, t_step;

int do_acc = flags & 16;

a_step /= sizeof(a_data[0]);

b_step /= sizeof(b_data[0]);

d_step /= sizeof(d_data[0]);

a_step0 = a_step;

a_step1 = 1;

if( flags & GEMM_1_T )

{

CV_SWAP( a_step0, a_step1, t_step );

n = a_size.height;

_a_buf.allocate(n);

a_buf = _a_buf.data();

}

if( flags & GEMM_2_T )

{

/* second operand is transposed */

for( i = 0; i < d_size.height; i++, _a_data += a_step0, d_data += d_step )

{

a_data = _a_data; b_data = _b_data;

if( a_buf )

{

for( k = 0; k < n; k++ )

a_buf[k] = a_data[a_step1*k];

a_data = a_buf;

}

for( j = 0; j < d_size.width; j++, b_data += b_step )

{

WT s0 = do_acc ? d_data[j]:WT(0), s1(0);

for( k = 0; k <= n - 2; k += 2 )

{

s0 += WT(a_data[k])*WT(b_data[k]);

s1 += WT(a_data[k+1])*WT(b_data[k+1]);

}

for( ; k < n; k++ )

s0 += WT(a_data[k])*WT(b_data[k]);

d_data[j] = s0 + s1;

}

}

}

else

{

for( i = 0; i < d_size.height; i++, _a_data += a_step0, d_data += d_step )

{

a_data = _a_data, b_data = _b_data;

if( a_buf )

{

for( k = 0; k < n; k++ )

a_buf[k] = a_data[a_step1*k];

a_data = a_buf;

}

for( j = 0; j <= m - 4; j += 4 )

{

WT s0, s1, s2, s3;

const T* b = b_data + j;

if( do_acc )

{

s0 = d_data[j]; s1 = d_data[j+1];

s2 = d_data[j+2]; s3 = d_data[j+3];

}

else

s0 = s1 = s2 = s3 = WT(0);

for( k = 0; k < n; k++, b += b_step )

{

WT a(a_data[k]);

s0 += a * WT(b[0]); s1 += a * WT(b[1]);

s2 += a * WT(b[2]); s3 += a * WT(b[3]);

}

d_data[j] = s0; d_data[j+1] = s1;

d_data[j+2] = s2; d_data[j+3] = s3;

}

for( ; j < m; j++ )

{

const T* b = b_data + j;

WT s0 = do_acc ? d_data[j] : WT(0);

for( k = 0; k < n; k++, b += b_step )

s0 += WT(a_data[k]) * WT(b[0]);

d_data[j] = s0;

}

}

}

const WT* d_buf, size_t d_buf_step,

T* d_data, size_t d_step, Size d_size,

double alpha, double beta, int flags )

{

const T* _c_data = c_data;

int j;

size_t c_step0, c_step1;

c_step /= sizeof(c_data[0]);

d_buf_step /= sizeof(d_buf[0]);

d_step /= sizeof(d_data[0]);

if( !c_data )

c_step0 = c_step1 = 0;

else if( !(flags & GEMM_3_T) )

c_step0 = c_step, c_step1 = 1;

else

c_step0 = 1, c_step1 = c_step;

for( ; d_size.height--; _c_data += c_step0, d_buf += d_buf_step, d_data += d_step )

{

if( _c_data )

{

c_data = _c_data;

j=0;

#if CV_ENABLE_UNROLLED

for(; j <= d_size.width - 4; j += 4, c_data += 4*c_step1 )

{

WT t0 = alpha*d_buf[j];

WT t1 = alpha*d_buf[j+1];

t0 += beta*WT(c_data[0]);

t1 += beta*WT(c_data[c_step1]);

d_data[j] = T(t0);

d_data[j+1] = T(t1);

t0 = alpha*d_buf[j+2];

t1 = alpha*d_buf[j+3];

t0 += beta*WT(c_data[c_step1*2]);

t1 += beta*WT(c_data[c_step1*3]);

d_data[j+2] = T(t0);

d_data[j+3] = T(t1);

}

#endif

for( ; j < d_size.width; j++, c_data += c_step1 )

{

WT t0 = alpha*d_buf[j];

d_data[j] = T(t0 + WT(c_data[0])*beta);

}

}

else

{

j = 0;

#if CV_ENABLE_UNROLLED

for( ; j <= d_size.width - 4; j += 4 )

{

WT t0 = alpha*d_buf[j];

WT t1 = alpha*d_buf[j+1];

d_data[j] = T(t0);

d_data[j+1] = T(t1);

t0 = alpha*d_buf[j+2];

t1 = alpha*d_buf[j+3];

d_data[j+2] = T(t0);

d_data[j+3] = T(t1);

}

#endif

for( ; j < d_size.width; j++ )

d_data[j] = T(alpha*d_buf[j]);

}

}

const float* b_data, size_t b_step,

const float* c_data, size_t c_step,

float* d_data, size_t d_step,

Size a_size, Size d_size,

double alpha, double beta, int flags )

{

GEMMSingleMul<float,double>(a_data, a_step, b_data, b_step, c_data,

c_step, d_data, d_step, a_size, d_size,

alpha, beta, flags);

const double* b_data, size_t b_step,

const double* c_data, size_t c_step,

double* d_data, size_t d_step,

Size a_size, Size d_size,

double alpha, double beta, int flags )

{

GEMMSingleMul<double,double>(a_data, a_step, b_data, b_step, c_data,

c_step, d_data, d_step, a_size, d_size,

alpha, beta, flags);

const Complexf* b_data, size_t b_step,

const Complexf* c_data, size_t c_step,

Complexf* d_data, size_t d_step,

Size a_size, Size d_size,

double alpha, double beta, int flags )

{

GEMMSingleMul<Complexf,Complexd>(a_data, a_step, b_data, b_step, c_data,

c_step, d_data, d_step, a_size, d_size,

alpha, beta, flags);

const Complexd* b_data, size_t b_step,

const Complexd* c_data, size_t c_step,

Complexd* d_data, size_t d_step,

Size a_size, Size d_size,

double alpha, double beta, int flags )

{

GEMMSingleMul<Complexd,Complexd>(a_data, a_step, b_data, b_step, c_data,

c_step, d_data, d_step, a_size, d_size,

alpha, beta, flags);

const float* b_data, size_t b_step,

double* d_data, size_t d_step,

Size a_size, Size d_size, int flags )

{

GEMMBlockMul(a_data, a_step, b_data, b_step, d_data, d_step, a_size, d_size, flags);

const double* b_data, size_t b_step,

double* d_data, size_t d_step,

Size a_size, Size d_size, int flags )

{

GEMMBlockMul(a_data, a_step, b_data, b_step, d_data, d_step, a_size, d_size, flags);

const Complexf* b_data, size_t b_step,

Complexd* d_data, size_t d_step,

Size a_size, Size d_size, int flags )

{

GEMMBlockMul(a_data, a_step, b_data, b_step, d_data, d_step, a_size, d_size, flags);

const Complexd* b_data, size_t b_step,

Complexd* d_data, size_t d_step,

Size a_size, Size d_size, int flags )

{

GEMMBlockMul(a_data, a_step, b_data, b_step, d_data, d_step, a_size, d_size, flags);

const double* d_buf, size_t d_buf_step,

float* d_data, size_t d_step, Size d_size,

double alpha, double beta, int flags )

{

GEMMStore(c_data, c_step, d_buf, d_buf_step, d_data, d_step, d_size, alpha, beta, flags);

const double* d_buf, size_t d_buf_step,

double* d_data, size_t d_step, Size d_size,

double alpha, double beta, int flags )

{

GEMMStore(c_data, c_step, d_buf, d_buf_step, d_data, d_step, d_size, alpha, beta, flags);

const Complexd* d_buf, size_t d_buf_step,

Complexf* d_data, size_t d_step, Size d_size,

double alpha, double beta, int flags )

{

GEMMStore(c_data, c_step, d_buf, d_buf_step, d_data, d_step, d_size, alpha, beta, flags);

const Complexd* d_buf, size_t d_buf_step,

Complexd* d_data, size_t d_step, Size d_size,

double alpha, double beta, int flags )

{

GEMMStore(c_data, c_step, d_buf, d_buf_step, d_data, d_step, d_size, alpha, beta, flags);

InputArray matC, double beta, OutputArray matD, int flags )

{

int type = matA.type(), esz = CV_ELEM_SIZE(type);

bool haveC = matC.kind() != cv::_InputArray::NONE;

Size sizeA = matA.size(), sizeB = matB.size(), sizeC = haveC ? matC.size() : Size(0, 0);

bool atrans = (flags & GEMM_1_T) != 0, btrans = (flags & GEMM_2_T) != 0, ctrans = (flags & GEMM_3_T) != 0;

if (atrans)

sizeA = Size(sizeA.height, sizeA.width);

if (btrans)

sizeB = Size(sizeB.height, sizeB.width);

if (haveC && ctrans)

sizeC = Size(sizeC.height, sizeC.width);

Size sizeD(sizeB.width, sizeA.height);

CV_Assert( matB.type() == type && (!haveC || matC.type() == type) );

CV_Assert( sizeA.width == sizeB.height && (!haveC || sizeC == sizeD) );

matD.create(sizeD, type);

if ( matA.offset() % esz != 0 || matA.step() % esz != 0 ||

matB.offset() % esz != 0 || matB.step() % esz != 0 ||

(haveC && (matC.offset() % esz != 0 || matC.step() % esz != 0)) )

return false;

UMat A = matA.getUMat(), B = matB.getUMat(), D = matD.getUMat();

if (!ocl::internal::isCLBuffer(A) || !ocl::internal::isCLBuffer(B) || !ocl::internal::isCLBuffer(D))

{

return false;

}

if (haveC)

{

UMat C = matC.getUMat();

if (!ocl::internal::isCLBuffer(C))

return false;

}

if (haveC)

ctrans ? transpose(matC, D) : matC.copyTo(D);

else

D.setTo(Scalar::all(0));

int M = sizeD.height, N = sizeD.width, K = sizeA.width;

int lda = (int)A.step / esz, ldb = (int)B.step / esz, ldc = (int)D.step / esz;

int offa = (int)A.offset / esz, offb = (int)B.offset / esz, offc = (int)D.offset / esz;

cl_command_queue clq = (cl_command_queue)ocl::Queue::getDefault().ptr();

clAmdBlasTranspose transA = atrans ? clAmdBlasTrans : clAmdBlasNoTrans;

clAmdBlasTranspose transB = btrans ? clAmdBlasTrans : clAmdBlasNoTrans;

clAmdBlasOrder order = clAmdBlasRowMajor;

clAmdBlasStatus status = clAmdBlasSuccess;

if (type == CV_32FC1)

status = clAmdBlasSgemmEx(order, transA, transB, M, N, K,

(cl_float)alpha, (const cl_mem)A.handle(ACCESS_READ), offa, lda,

(const cl_mem)B.handle(ACCESS_READ), offb, ldb,

(cl_float)beta, (cl_mem)D.handle(ACCESS_RW), offc, ldc,

1, &clq, 0, NULL, NULL);

else if (type == CV_64FC1)

status = clAmdBlasDgemmEx(order, transA, transB, M, N, K,

alpha, (const cl_mem)A.handle(ACCESS_READ), offa, lda,

(const cl_mem)B.handle(ACCESS_READ), offb, ldb,

beta, (cl_mem)D.handle(ACCESS_RW), offc, ldc,

1, &clq, 0, NULL, NULL);

else if (type == CV_32FC2)

{

cl_float2 alpha_2 = { { (cl_float)alpha, 0 } };

cl_float2 beta_2 = { { (cl_float)beta, 0 } };

status = clAmdBlasCgemmEx(order, transA, transB, M, N, K,

alpha_2, (const cl_mem)A.handle(ACCESS_READ), offa, lda,

(const cl_mem)B.handle(ACCESS_READ), offb, ldb,

beta_2, (cl_mem)D.handle(ACCESS_RW), offc, ldc,

1, &clq, 0, NULL, NULL);

}

else if (type == CV_64FC2)

{

cl_double2 alpha_2 = { { alpha, 0 } };

cl_double2 beta_2 = { { beta, 0 } };

status = clAmdBlasZgemmEx(order, transA, transB, M, N, K,

alpha_2, (const cl_mem)A.handle(ACCESS_READ), offa, lda,

(const cl_mem)B.handle(ACCESS_READ), offb, ldb,

beta_2, (cl_mem)D.handle(ACCESS_RW), offc, ldc,

1, &clq, 0, NULL, NULL);

}

else

CV_Error(Error::StsUnsupportedFormat, "");

return status == clAmdBlasSuccess;

InputArray matC, double beta, OutputArray matD, int flags )

{

int depth = matA.depth(), cn = matA.channels();

int type = CV_MAKETYPE(depth, cn);

CV_Assert( type == matB.type(), (type == CV_32FC1 || type == CV_64FC1 || type == CV_32FC2 || type == CV_64FC2) );

const ocl::Device & dev = ocl::Device::getDefault();

bool doubleSupport = dev.doubleFPConfig() > 0;

if (!doubleSupport && depth == CV_64F)

return false;

bool haveC = matC.kind() != cv::_InputArray::NONE;

Size sizeA = matA.size(), sizeB = matB.size(), sizeC = haveC ? matC.size() : Size(0, 0);

bool atrans = (flags & GEMM_1_T) != 0, btrans = (flags & GEMM_2_T) != 0, ctrans = (flags & GEMM_3_T) != 0;

CV_Assert( !haveC || matC.type() == type );

Size sizeD(((btrans)? sizeB.height : sizeB.width),

((atrans)? sizeA.width : sizeA.height));

matD.create(sizeD, type);

UMat A = matA.getUMat(), B = matB.getUMat(), D = matD.getUMat();

if (!dev.intelSubgroupsSupport() || (depth == CV_64F) || cn != 1)

{

String opts;

if (atrans)

sizeA = Size(sizeA.height, sizeA.width);

if (btrans)

sizeB = Size(sizeB.height, sizeB.width);

if (haveC && ctrans)

sizeC = Size(sizeC.height, sizeC.width);

CV_Assert( sizeA.width == sizeB.height && (!haveC || sizeC == sizeD) );

int max_wg_size = (int)dev.maxWorkGroupSize();

int block_size = (max_wg_size / (32*cn) < 32) ? (max_wg_size / (16*cn) < 16) ? (max_wg_size / (8*cn) < 8) ? 1 : 8 : 16 : 32;

if (atrans)

A = A.t();

if (btrans)

B = B.t();

if (haveC)

ctrans ? transpose(matC, D) : matC.copyTo(D);

int vectorWidths[] = { 4, 4, 2, 2, 1, 4, cn, -1 };

int kercn = ocl::checkOptimalVectorWidth(vectorWidths, B, D);

opts += format(" -D T=%s -D T1=%s -D WT=%s -D cn=%d -D kercn=%d -D LOCAL_SIZE=%d%s%s%s",

ocl::typeToStr(type), ocl::typeToStr(depth), ocl::typeToStr(CV_MAKETYPE(depth, kercn)),

cn, kercn, block_size,

(sizeA.width % block_size !=0) ? " -D NO_MULT" : "",

haveC ? " -D HAVE_C" : "",

doubleSupport ? " -D DOUBLE_SUPPORT" : "");

ocl::Kernel k("gemm", cv::ocl::core::gemm_oclsrc, opts);

if (k.empty())

return false;

if (depth == CV_64F)

k.args(ocl::KernelArg::ReadOnlyNoSize(A),

ocl::KernelArg::ReadOnlyNoSize(B, cn, kercn),

ocl::KernelArg::ReadWrite(D, cn, kercn),

sizeA.width, alpha, beta);

else

k.args(ocl::KernelArg::ReadOnlyNoSize(A),

ocl::KernelArg::ReadOnlyNoSize(B, cn, kercn),

ocl::KernelArg::ReadWrite(D, cn, kercn),

sizeA.width, (float)alpha, (float)beta);

size_t globalsize[2] = { (size_t)sizeD.width * cn / kercn, (size_t)sizeD.height};

size_t localsize[2] = { (size_t)block_size, (size_t)block_size};

return k.run(2, globalsize, block_size!=1 ? localsize : NULL, false);

}

else

{

if (haveC && beta != 0.0)

{

ctrans ? transpose(matC, D) : matC.copyTo(D);

}

else

{

beta = 0.0;

}

return intel_gpu_gemm(A, sizeA,

B, sizeB,

D, sizeD,

alpha,

beta,

atrans, btrans);

}

Mat C, double beta, Mat D, int flags )

{

CV_INSTRUMENT_REGION()

const int block_lin_size = 128;

const int block_size = block_lin_size * block_lin_size;

static double zero[] = {0,0,0,0};

static float zerof[] = {0,0,0,0};

Size a_size = A.size(), d_size;

int i, len = 0, type = A.type();

switch( flags & (GEMM_1_T|GEMM_2_T) )

{

case 0:

d_size = Size( B.cols, a_size.height );

len = B.rows;

break;

case 1:

d_size = Size( B.cols, a_size.width );

len = B.rows;

break;

case 2:

d_size = Size( B.rows, a_size.height );

len = B.cols;

break;

case 3:

d_size = Size( B.rows, a_size.width );

len = B.cols;

break;

}

if( flags == 0 && 2 <= len && len <= 4 && (len == d_size.width || len == d_size.height) )

{

if( type == CV_32F )

{

float* d = D.ptr<float>();

const float *a = A.ptr<float>(),

*b = B.ptr<float>(),

*c = (const float*)C.data;

size_t d_step = D.step/sizeof(d[0]),

a_step = A.step/sizeof(a[0]),

b_step = B.step/sizeof(b[0]),

c_step = C.data ? C.step/sizeof(c[0]) : 0;

if( !c )

c = zerof;

switch( len )

{

case 2:

if( len == d_size.width && b != d )

{

for( i = 0; i < d_size.height; i++, d += d_step, a += a_step, c += c_step )

{

float t0 = a[0]*b[0] + a[1]*b[b_step];

float t1 = a[0]*b[1] + a[1]*b[b_step+1];

d[0] = (float)(t0*alpha + c[0]*beta);

d[1] = (float)(t1*alpha + c[1]*beta);

}

}

else if( a != d )

{

int c_step0 = 1;

if( c == zerof )

{

c_step0 = 0;

c_step = 1;

}

for( i = 0; i < d_size.width; i++, d++, b++, c += c_step0 )

{

float t0 = a[0]*b[0] + a[1]*b[b_step];

float t1 = a[a_step]*b[0] + a[a_step+1]*b[b_step];

d[0] = (float)(t0*alpha + c[0]*beta);

d[d_step] = (float)(t1*alpha + c[c_step]*beta);

}

}

else

break;

return;

case 3:

if( len == d_size.width && b != d )

{

for( i = 0; i < d_size.height; i++, d += d_step, a += a_step, c += c_step )

{

float t0 = a[0]*b[0] + a[1]*b[b_step] + a[2]*b[b_step*2];

float t1 = a[0]*b[1] + a[1]*b[b_step+1] + a[2]*b[b_step*2+1];

float t2 = a[0]*b[2] + a[1]*b[b_step+2] + a[2]*b[b_step*2+2];

d[0] = (float)(t0*alpha + c[0]*beta);

d[1] = (float)(t1*alpha + c[1]*beta);

d[2] = (float)(t2*alpha + c[2]*beta);

}

}

else if( a != d )

{

int c_step0 = 1;

if( c == zerof )

{

c_step0 = 0;

c_step = 1;

}