modules/core/src/split.cpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html
   4
   5
   6 #include "precomp.hpp"
   7 #include "opencl_kernels_core.hpp"
   8
   9 namespace cv { namespace hal {
  10
  11 #if CV_NEON
  12 template<typename T> struct VSplit2;
  13 template<typename T> struct VSplit3;
  14 template<typename T> struct VSplit4;
  15
  16 #define SPLIT2_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
  17     template<>                                                                    \
  18     struct name<data_type>                                                        \
  19     {                                                                             \
  20         void operator()(const data_type* src, data_type* dst0,                    \
  21                         data_type* dst1) const                                    \
  22         {                                                                         \
  23             reg_type r = load_func(src);                                          \
  24             store_func(dst0, r.val[0]);                                           \
  25             store_func(dst1, r.val[1]);                                           \
  26         }                                                                         \
  27     }
  28
  29 #define SPLIT3_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
  30     template<>                                                                    \
  31     struct name<data_type>                                                        \
  32     {                                                                             \
  33         void operator()(const data_type* src, data_type* dst0, data_type* dst1,   \
  34                         data_type* dst2) const                                    \
  35         {                                                                         \
  36             reg_type r = load_func(src);                                          \
  37             store_func(dst0, r.val[0]);                                           \
  38             store_func(dst1, r.val[1]);                                           \
  39             store_func(dst2, r.val[2]);                                           \
  40         }                                                                         \
  41     }
  42
  43 #define SPLIT4_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
  44     template<>                                                                    \
  45     struct name<data_type>                                                        \
  46     {                                                                             \
  47         void operator()(const data_type* src, data_type* dst0, data_type* dst1,   \
  48                         data_type* dst2, data_type* dst3) const                   \
  49         {                                                                         \
  50             reg_type r = load_func(src);                                          \
  51             store_func(dst0, r.val[0]);                                           \
  52             store_func(dst1, r.val[1]);                                           \
  53             store_func(dst2, r.val[2]);                                           \
  54             store_func(dst3, r.val[3]);                                           \
  55         }                                                                         \
  56     }
  57
  58 SPLIT2_KERNEL_TEMPLATE(VSplit2, uchar ,  uint8x16x2_t, vld2q_u8 , vst1q_u8 );
  59 SPLIT2_KERNEL_TEMPLATE(VSplit2, ushort,  uint16x8x2_t, vld2q_u16, vst1q_u16);
  60 SPLIT2_KERNEL_TEMPLATE(VSplit2, int   ,   int32x4x2_t, vld2q_s32, vst1q_s32);
  61 SPLIT2_KERNEL_TEMPLATE(VSplit2, int64 ,   int64x1x2_t, vld2_s64 , vst1_s64 );
  62
  63 SPLIT3_KERNEL_TEMPLATE(VSplit3, uchar ,  uint8x16x3_t, vld3q_u8 , vst1q_u8 );
  64 SPLIT3_KERNEL_TEMPLATE(VSplit3, ushort,  uint16x8x3_t, vld3q_u16, vst1q_u16);
  65 SPLIT3_KERNEL_TEMPLATE(VSplit3, int   ,   int32x4x3_t, vld3q_s32, vst1q_s32);
  66 SPLIT3_KERNEL_TEMPLATE(VSplit3, int64 ,   int64x1x3_t, vld3_s64 , vst1_s64 );
  67
  68 SPLIT4_KERNEL_TEMPLATE(VSplit4, uchar ,  uint8x16x4_t, vld4q_u8 , vst1q_u8 );
  69 SPLIT4_KERNEL_TEMPLATE(VSplit4, ushort,  uint16x8x4_t, vld4q_u16, vst1q_u16);
  70 SPLIT4_KERNEL_TEMPLATE(VSplit4, int   ,   int32x4x4_t, vld4q_s32, vst1q_s32);
  71 SPLIT4_KERNEL_TEMPLATE(VSplit4, int64 ,   int64x1x4_t, vld4_s64 , vst1_s64 );
  72
  73 #elif CV_SSE2
  74
  75 template <typename T>
  76 struct VSplit2
  77 {
  78     VSplit2() : support(false) { }
  79     void operator()(const T *, T *, T *) const { }
  80
  81     bool support;
  82 };
  83
  84 template <typename T>
  85 struct VSplit3
  86 {
  87     VSplit3() : support(false) { }
  88     void operator()(const T *, T *, T *, T *) const { }
  89
  90     bool support;
  91 };
  92
  93 template <typename T>
  94 struct VSplit4
  95 {
  96     VSplit4() : support(false) { }
  97     void operator()(const T *, T *, T *, T *, T *) const { }
  98
  99     bool support;
 100 };
 101
 102 #define SPLIT2_KERNEL_TEMPLATE(data_type, reg_type, cast_type, _mm_deinterleave, flavor)   \
 103 template <>                                                                                \
 104 struct VSplit2<data_type>                                                                  \
 105 {                                                                                          \
 106     enum                                                                                   \
 107     {                                                                                      \
 108         ELEMS_IN_VEC = 16 / sizeof(data_type)                                              \
 109     };                                                                                     \
 110                                                                                            \
 111     VSplit2()                                                                              \
 112     {                                                                                      \
 113         support = checkHardwareSupport(CV_CPU_SSE2);                                       \
 114     }                                                                                      \
 115                                                                                            \
 116     void operator()(const data_type * src,                                                 \
 117                     data_type * dst0, data_type * dst1) const                              \
 118     {                                                                                      \
 119         reg_type v_src0 = _mm_loadu_##flavor((cast_type const *)(src));                    \
 120         reg_type v_src1 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC));     \
 121         reg_type v_src2 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 2)); \
 122         reg_type v_src3 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 3)); \
 123                                                                                            \
 124         _mm_deinterleave(v_src0, v_src1, v_src2, v_src3);                                  \
 125                                                                                            \
 126         _mm_storeu_##flavor((cast_type *)(dst0), v_src0);                                  \
 127         _mm_storeu_##flavor((cast_type *)(dst0 + ELEMS_IN_VEC), v_src1);                   \
 128         _mm_storeu_##flavor((cast_type *)(dst1), v_src2);                                  \
 129         _mm_storeu_##flavor((cast_type *)(dst1 + ELEMS_IN_VEC), v_src3);                   \
 130     }                                                                                      \
 131                                                                                            \
 132     bool support;                                                                          \
 133 }
 134
 135 #define SPLIT3_KERNEL_TEMPLATE(data_type, reg_type, cast_type, _mm_deinterleave, flavor)   \
 136 template <>                                                                                \
 137 struct VSplit3<data_type>                                                                  \
 138 {                                                                                          \
 139     enum                                                                                   \
 140     {                                                                                      \
 141         ELEMS_IN_VEC = 16 / sizeof(data_type)                                              \
 142     };                                                                                     \
 143                                                                                            \
 144     VSplit3()                                                                              \
 145     {                                                                                      \
 146         support = checkHardwareSupport(CV_CPU_SSE2);                                       \
 147     }                                                                                      \
 148                                                                                            \
 149     void operator()(const data_type * src,                                                 \
 150                     data_type * dst0, data_type * dst1, data_type * dst2) const            \
 151     {                                                                                      \
 152         reg_type v_src0 = _mm_loadu_##flavor((cast_type const *)(src));                    \
 153         reg_type v_src1 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC));     \
 154         reg_type v_src2 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 2)); \
 155         reg_type v_src3 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 3)); \
 156         reg_type v_src4 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 4)); \
 157         reg_type v_src5 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 5)); \
 158                                                                                            \
 159         _mm_deinterleave(v_src0, v_src1, v_src2,                                           \
 160                          v_src3, v_src4, v_src5);                                          \
 161                                                                                            \
 162         _mm_storeu_##flavor((cast_type *)(dst0), v_src0);                                  \
 163         _mm_storeu_##flavor((cast_type *)(dst0 + ELEMS_IN_VEC), v_src1);                   \
 164         _mm_storeu_##flavor((cast_type *)(dst1), v_src2);                                  \
 165         _mm_storeu_##flavor((cast_type *)(dst1 + ELEMS_IN_VEC), v_src3);                   \
 166         _mm_storeu_##flavor((cast_type *)(dst2), v_src4);                                  \
 167         _mm_storeu_##flavor((cast_type *)(dst2 + ELEMS_IN_VEC), v_src5);                   \
 168     }                                                                                      \
 169                                                                                            \
 170     bool support;                                                                          \
 171 }
 172
 173 #define SPLIT4_KERNEL_TEMPLATE(data_type, reg_type, cast_type, _mm_deinterleave, flavor)   \
 174 template <>                                                                                \
 175 struct VSplit4<data_type>                                                                  \
 176 {                                                                                          \
 177     enum                                                                                   \
 178     {                                                                                      \
 179         ELEMS_IN_VEC = 16 / sizeof(data_type)                                              \
 180     };                                                                                     \
 181                                                                                            \
 182     VSplit4()                                                                              \
 183     {                                                                                      \
 184         support = checkHardwareSupport(CV_CPU_SSE2);                                       \
 185     }                                                                                      \
 186                                                                                            \
 187     void operator()(const data_type * src, data_type * dst0, data_type * dst1,             \
 188                     data_type * dst2, data_type * dst3) const                              \
 189     {                                                                                      \
 190         reg_type v_src0 = _mm_loadu_##flavor((cast_type const *)(src));                    \
 191         reg_type v_src1 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC));     \
 192         reg_type v_src2 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 2)); \
 193         reg_type v_src3 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 3)); \
 194         reg_type v_src4 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 4)); \
 195         reg_type v_src5 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 5)); \
 196         reg_type v_src6 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 6)); \
 197         reg_type v_src7 = _mm_loadu_##flavor((cast_type const *)(src + ELEMS_IN_VEC * 7)); \
 198                                                                                            \
 199         _mm_deinterleave(v_src0, v_src1, v_src2, v_src3,                                   \
 200                          v_src4, v_src5, v_src6, v_src7);                                  \
 201                                                                                            \
 202         _mm_storeu_##flavor((cast_type *)(dst0), v_src0);                                  \
 203         _mm_storeu_##flavor((cast_type *)(dst0 + ELEMS_IN_VEC), v_src1);                   \
 204         _mm_storeu_##flavor((cast_type *)(dst1), v_src2);                                  \
 205         _mm_storeu_##flavor((cast_type *)(dst1 + ELEMS_IN_VEC), v_src3);                   \
 206         _mm_storeu_##flavor((cast_type *)(dst2), v_src4);                                  \
 207         _mm_storeu_##flavor((cast_type *)(dst2 + ELEMS_IN_VEC), v_src5);                   \
 208         _mm_storeu_##flavor((cast_type *)(dst3), v_src6);                                  \
 209         _mm_storeu_##flavor((cast_type *)(dst3 + ELEMS_IN_VEC), v_src7);                   \
 210     }                                                                                      \
 211                                                                                            \
 212     bool support;                                                                          \
 213 }
 214
 215 SPLIT2_KERNEL_TEMPLATE( uchar, __m128i, __m128i, _mm_deinterleave_epi8, si128);
 216 SPLIT2_KERNEL_TEMPLATE(ushort, __m128i, __m128i, _mm_deinterleave_epi16, si128);
 217 SPLIT2_KERNEL_TEMPLATE(   int,  __m128,   float, _mm_deinterleave_ps, ps);
 218
 219 SPLIT3_KERNEL_TEMPLATE( uchar, __m128i, __m128i, _mm_deinterleave_epi8, si128);
 220 SPLIT3_KERNEL_TEMPLATE(ushort, __m128i, __m128i, _mm_deinterleave_epi16, si128);
 221 SPLIT3_KERNEL_TEMPLATE(   int,  __m128,   float, _mm_deinterleave_ps, ps);
 222
 223 SPLIT4_KERNEL_TEMPLATE( uchar, __m128i, __m128i, _mm_deinterleave_epi8, si128);
 224 SPLIT4_KERNEL_TEMPLATE(ushort, __m128i, __m128i, _mm_deinterleave_epi16, si128);
 225 SPLIT4_KERNEL_TEMPLATE(   int,  __m128,   float, _mm_deinterleave_ps, ps);
 226
 227 #endif
 228
 229 template<typename T> static void
 230 split_( const T* src, T** dst, int len, int cn )
 231 {
 232     int k = cn % 4 ? cn % 4 : 4;
 233     int i, j;
 234     if( k == 1 )
 235     {
 236         T* dst0 = dst[0];
 237
 238         if(cn == 1)
 239         {
 240             memcpy(dst0, src, len * sizeof(T));
 241         }
 242         else
 243         {
 244             for( i = 0, j = 0 ; i < len; i++, j += cn )
 245                 dst0[i] = src[j];
 246         }
 247     }
 248     else if( k == 2 )
 249     {
 250         T *dst0 = dst[0], *dst1 = dst[1];
 251         i = j = 0;
 252
 253 #if CV_NEON
 254         if(cn == 2)
 255         {
 256             int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
 257             int inc_j = 2 * inc_i;
 258
 259             VSplit2<T> vsplit;
 260             for( ; i < len - inc_i; i += inc_i, j += inc_j)
 261                 vsplit(src + j, dst0 + i, dst1 + i);
 262         }
 263 #elif CV_SSE2
 264         if (cn == 2)
 265         {
 266             int inc_i = 32/sizeof(T);
 267             int inc_j = 2 * inc_i;
 268
 269             VSplit2<T> vsplit;
 270             if (vsplit.support)
 271             {
 272                 for( ; i <= len - inc_i; i += inc_i, j += inc_j)
 273                     vsplit(src + j, dst0 + i, dst1 + i);
 274             }
 275         }
 276 #endif
 277         for( ; i < len; i++, j += cn )
 278         {
 279             dst0[i] = src[j];
 280             dst1[i] = src[j+1];
 281         }
 282     }
 283     else if( k == 3 )
 284     {
 285         T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2];
 286         i = j = 0;
 287
 288 #if CV_NEON
 289         if(cn == 3)
 290         {
 291             int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
 292             int inc_j = 3 * inc_i;
 293
 294             VSplit3<T> vsplit;
 295             for( ; i <= len - inc_i; i += inc_i, j += inc_j)
 296                 vsplit(src + j, dst0 + i, dst1 + i, dst2 + i);
 297         }
 298 #elif CV_SSE2
 299         if (cn == 3)
 300         {
 301             int inc_i = 32/sizeof(T);
 302             int inc_j = 3 * inc_i;
 303
 304             VSplit3<T> vsplit;
 305
 306             if (vsplit.support)
 307             {
 308                 for( ; i <= len - inc_i; i += inc_i, j += inc_j)
 309                     vsplit(src + j, dst0 + i, dst1 + i, dst2 + i);
 310             }
 311         }
 312 #endif
 313         for( ; i < len; i++, j += cn )
 314         {
 315             dst0[i] = src[j];
 316             dst1[i] = src[j+1];
 317             dst2[i] = src[j+2];
 318         }
 319     }
 320     else
 321     {
 322         T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2], *dst3 = dst[3];
 323         i = j = 0;
 324
 325 #if CV_NEON
 326         if(cn == 4)
 327         {
 328             int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
 329             int inc_j = 4 * inc_i;
 330
 331             VSplit4<T> vsplit;
 332             for( ; i <= len - inc_i; i += inc_i, j += inc_j)
 333                 vsplit(src + j, dst0 + i, dst1 + i, dst2 + i, dst3 + i);
 334         }
 335 #elif CV_SSE2
 336         if (cn == 4)
 337         {
 338             int inc_i = 32/sizeof(T);
 339             int inc_j = 4 * inc_i;
 340
 341             VSplit4<T> vsplit;
 342             if (vsplit.support)
 343             {
 344                 for( ; i <= len - inc_i; i += inc_i, j += inc_j)
 345                     vsplit(src + j, dst0 + i, dst1 + i, dst2 + i, dst3 + i);
 346             }
 347         }
 348 #endif
 349         for( ; i < len; i++, j += cn )
 350         {
 351             dst0[i] = src[j]; dst1[i] = src[j+1];
 352             dst2[i] = src[j+2]; dst3[i] = src[j+3];
 353         }
 354     }
 355
 356     for( ; k < cn; k += 4 )
 357     {
 358         T *dst0 = dst[k], *dst1 = dst[k+1], *dst2 = dst[k+2], *dst3 = dst[k+3];
 359         for( i = 0, j = k; i < len; i++, j += cn )
 360         {
 361             dst0[i] = src[j]; dst1[i] = src[j+1];
 362             dst2[i] = src[j+2]; dst3[i] = src[j+3];
 363         }
 364     }
 365 }
 366
 367 void split8u(const uchar* src, uchar** dst, int len, int cn )
 368 {
 369     CALL_HAL(split8u, cv_hal_split8u, src,dst, len, cn)
 370     split_(src, dst, len, cn);
 371 }
 372
 373 void split16u(const ushort* src, ushort** dst, int len, int cn )
 374 {
 375     CALL_HAL(split16u, cv_hal_split16u, src,dst, len, cn)
 376     split_(src, dst, len, cn);
 377 }
 378
 379 void split32s(const int* src, int** dst, int len, int cn )
 380 {
 381     CALL_HAL(split32s, cv_hal_split32s, src,dst, len, cn)
 382     split_(src, dst, len, cn);
 383 }
 384
 385 void split64s(const int64* src, int64** dst, int len, int cn )
 386 {
 387     CALL_HAL(split64s, cv_hal_split64s, src,dst, len, cn)
 388     split_(src, dst, len, cn);
 389 }
 390
 391 }} // cv::hal::
 392
 393 /****************************************************************************************\
 394 *                                       split & merge                                    *
 395 \****************************************************************************************/
 396
 397 typedef void (*SplitFunc)(const uchar* src, uchar** dst, int len, int cn);
 398
 399 static SplitFunc getSplitFunc(int depth)
 400 {
 401     static SplitFunc splitTab[] =
 402     {
 403         (SplitFunc)GET_OPTIMIZED(cv::hal::split8u), (SplitFunc)GET_OPTIMIZED(cv::hal::split8u), (SplitFunc)GET_OPTIMIZED(cv::hal::split16u), (SplitFunc)GET_OPTIMIZED(cv::hal::split16u),
 404         (SplitFunc)GET_OPTIMIZED(cv::hal::split32s), (SplitFunc)GET_OPTIMIZED(cv::hal::split32s), (SplitFunc)GET_OPTIMIZED(cv::hal::split64s), 0
 405     };
 406
 407     return splitTab[depth];
 408 }
 409
 410 #ifdef HAVE_IPP
 411
 412 namespace cv {
 413 static bool ipp_split(const Mat& src, Mat* mv, int channels)
 414 {
 415 #ifdef HAVE_IPP_IW
 416     CV_INSTRUMENT_REGION_IPP()
 417
 418     if(channels != 3 && channels != 4)
 419         return false;
 420
 421     if(src.dims <= 2)
 422     {
 423         IppiSize size       = ippiSize(src.size());
 424         void    *dstPtrs[4] = {NULL};
 425         size_t   dstStep    = mv[0].step;
 426         for(int i = 0; i < channels; i++)
 427         {
 428             dstPtrs[i] = mv[i].ptr();
 429             if(dstStep != mv[i].step)
 430                 return false;
 431         }
 432
 433         return CV_INSTRUMENT_FUN_IPP(llwiCopySplit, src.ptr(), (int)src.step, dstPtrs, (int)dstStep, size, (int)src.elemSize1(), channels, 0) >= 0;
 434     }
 435     else
 436     {
 437         const Mat *arrays[5] = {NULL};
 438         uchar     *ptrs[5]   = {NULL};
 439         arrays[0] = &src;
 440
 441         for(int i = 1; i < channels; i++)
 442         {
 443             arrays[i] = &mv[i-1];
 444         }
 445
 446         NAryMatIterator it(arrays, ptrs);
 447         IppiSize size = { (int)it.size, 1 };
 448
 449         for( size_t i = 0; i < it.nplanes; i++, ++it )
 450         {
 451             if(CV_INSTRUMENT_FUN_IPP(llwiCopySplit, ptrs[0], 0, (void**)&ptrs[1], 0, size, (int)src.elemSize1(), channels, 0) < 0)
 452                 return false;
 453         }
 454         return true;
 455     }
 456 #else
 457     CV_UNUSED(src); CV_UNUSED(mv); CV_UNUSED(channels);
 458     return false;
 459 #endif
 460 }
 461 }
 462 #endif
 463
 464 void cv::split(const Mat& src, Mat* mv)
 465 {
 466     CV_INSTRUMENT_REGION()
 467
 468     int k, depth = src.depth(), cn = src.channels();
 469     if( cn == 1 )
 470     {
 471         src.copyTo(mv[0]);
 472         return;
 473     }
 474
 475     for( k = 0; k < cn; k++ )
 476     {
 477         mv[k].create(src.dims, src.size, depth);
 478     }
 479
 480     CV_IPP_RUN_FAST(ipp_split(src, mv, cn));
 481
 482     SplitFunc func = getSplitFunc(depth);
 483     CV_Assert( func != 0 );
 484
 485     size_t esz = src.elemSize(), esz1 = src.elemSize1();
 486     size_t blocksize0 = (BLOCK_SIZE + esz-1)/esz;
 487     AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
 488     const Mat** arrays = (const Mat**)_buf.data();
 489     uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
 490
 491     arrays[0] = &src;
 492     for( k = 0; k < cn; k++ )
 493     {
 494         arrays[k+1] = &mv[k];
 495     }
 496
 497     NAryMatIterator it(arrays, ptrs, cn+1);
 498     size_t total = it.size;
 499     size_t blocksize = std::min((size_t)CV_SPLIT_MERGE_MAX_BLOCK_SIZE(cn), cn <= 4 ? total : std::min(total, blocksize0));
 500
 501     for( size_t i = 0; i < it.nplanes; i++, ++it )
 502     {
 503         for( size_t j = 0; j < total; j += blocksize )
 504         {
 505             size_t bsz = std::min(total - j, blocksize);
 506             func( ptrs[0], &ptrs[1], (int)bsz, cn );
 507
 508             if( j + blocksize < total )
 509             {
 510                 ptrs[0] += bsz*esz;
 511                 for( k = 0; k < cn; k++ )
 512                     ptrs[k+1] += bsz*esz1;
 513             }
 514         }
 515     }
 516 }
 517
 518 #ifdef HAVE_OPENCL
 519
 520 namespace cv {
 521
 522 static bool ocl_split( InputArray _m, OutputArrayOfArrays _mv )
 523 {
 524     int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type),
 525             rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
 526
 527     String dstargs, processelem, indexdecl;
 528     for (int i = 0; i < cn; ++i)
 529     {
 530         dstargs += format("DECLARE_DST_PARAM(%d)", i);
 531         indexdecl += format("DECLARE_INDEX(%d)", i);
 532         processelem += format("PROCESS_ELEM(%d)", i);
 533     }
 534
 535     ocl::Kernel k("split", ocl::core::split_merge_oclsrc,
 536                   format("-D T=%s -D OP_SPLIT -D cn=%d -D DECLARE_DST_PARAMS=%s"
 537                          " -D PROCESS_ELEMS_N=%s -D DECLARE_INDEX_N=%s",
 538                          ocl::memopTypeToStr(depth), cn, dstargs.c_str(),
 539                          processelem.c_str(), indexdecl.c_str()));
 540     if (k.empty())
 541         return false;
 542
 543     Size size = _m.size();
 544     _mv.create(cn, 1, depth);
 545     for (int i = 0; i < cn; ++i)
 546         _mv.create(size, depth, i);
 547
 548     std::vector<UMat> dst;
 549     _mv.getUMatVector(dst);
 550
 551     int argidx = k.set(0, ocl::KernelArg::ReadOnly(_m.getUMat()));
 552     for (int i = 0; i < cn; ++i)
 553         argidx = k.set(argidx, ocl::KernelArg::WriteOnlyNoSize(dst[i]));
 554     k.set(argidx, rowsPerWI);
 555
 556     size_t globalsize[2] = { (size_t)size.width, ((size_t)size.height + rowsPerWI - 1) / rowsPerWI };
 557     return k.run(2, globalsize, NULL, false);
 558 }
 559
 560 }
 561
 562 #endif
 563
 564 void cv::split(InputArray _m, OutputArrayOfArrays _mv)
 565 {
 566     CV_INSTRUMENT_REGION()
 567
 568     CV_OCL_RUN(_m.dims() <= 2 && _mv.isUMatVector(),
 569                ocl_split(_m, _mv))
 570
 571     Mat m = _m.getMat();
 572     if( m.empty() )
 573     {
 574         _mv.release();
 575         return;
 576     }
 577
 578     CV_Assert( !_mv.fixedType() || _mv.empty() || _mv.type() == m.depth() );
 579
 580     int depth = m.depth(), cn = m.channels();
 581     _mv.create(cn, 1, depth);
 582     for (int i = 0; i < cn; ++i)
 583         _mv.create(m.dims, m.size.p, depth, i);
 584
 585     std::vector<Mat> dst;
 586     _mv.getMatVector(dst);
 587
 588     split(m, &dst[0]);
 589 }