modules/core/src/merge.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 VMerge2;
  13 template<typename T> struct VMerge3;
  14 template<typename T> struct VMerge4;
  15
  16 #define MERGE2_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
  17     template<>                                                                    \
  18     struct name<data_type>{                                                       \
  19         void operator()(const data_type* src0, const data_type* src1,             \
  20                         data_type* dst){                                          \
  21             reg_type r;                                                           \
  22             r.val[0] = load_func(src0);                                           \
  23             r.val[1] = load_func(src1);                                           \
  24             store_func(dst, r);                                                   \
  25         }                                                                         \
  26     }
  27
  28 #define MERGE3_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
  29     template<>                                                                    \
  30     struct name<data_type>{                                                       \
  31         void operator()(const data_type* src0, const data_type* src1,             \
  32                         const data_type* src2, data_type* dst){                   \
  33             reg_type r;                                                           \
  34             r.val[0] = load_func(src0);                                           \
  35             r.val[1] = load_func(src1);                                           \
  36             r.val[2] = load_func(src2);                                           \
  37             store_func(dst, r);                                                   \
  38         }                                                                         \
  39     }
  40
  41 #define MERGE4_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func)  \
  42     template<>                                                                    \
  43     struct name<data_type>{                                                       \
  44         void operator()(const data_type* src0, const data_type* src1,             \
  45                         const data_type* src2, const data_type* src3,             \
  46                         data_type* dst){                                          \
  47             reg_type r;                                                           \
  48             r.val[0] = load_func(src0);                                           \
  49             r.val[1] = load_func(src1);                                           \
  50             r.val[2] = load_func(src2);                                           \
  51             r.val[3] = load_func(src3);                                           \
  52             store_func(dst, r);                                                   \
  53         }                                                                         \
  54     }
  55
  56 MERGE2_KERNEL_TEMPLATE(VMerge2, uchar ,  uint8x16x2_t, vld1q_u8 , vst2q_u8 );
  57 MERGE2_KERNEL_TEMPLATE(VMerge2, ushort,  uint16x8x2_t, vld1q_u16, vst2q_u16);
  58 MERGE2_KERNEL_TEMPLATE(VMerge2, int   ,   int32x4x2_t, vld1q_s32, vst2q_s32);
  59 MERGE2_KERNEL_TEMPLATE(VMerge2, int64 ,   int64x1x2_t, vld1_s64 , vst2_s64 );
  60
  61 MERGE3_KERNEL_TEMPLATE(VMerge3, uchar ,  uint8x16x3_t, vld1q_u8 , vst3q_u8 );
  62 MERGE3_KERNEL_TEMPLATE(VMerge3, ushort,  uint16x8x3_t, vld1q_u16, vst3q_u16);
  63 MERGE3_KERNEL_TEMPLATE(VMerge3, int   ,   int32x4x3_t, vld1q_s32, vst3q_s32);
  64 MERGE3_KERNEL_TEMPLATE(VMerge3, int64 ,   int64x1x3_t, vld1_s64 , vst3_s64 );
  65
  66 MERGE4_KERNEL_TEMPLATE(VMerge4, uchar ,  uint8x16x4_t, vld1q_u8 , vst4q_u8 );
  67 MERGE4_KERNEL_TEMPLATE(VMerge4, ushort,  uint16x8x4_t, vld1q_u16, vst4q_u16);
  68 MERGE4_KERNEL_TEMPLATE(VMerge4, int   ,   int32x4x4_t, vld1q_s32, vst4q_s32);
  69 MERGE4_KERNEL_TEMPLATE(VMerge4, int64 ,   int64x1x4_t, vld1_s64 , vst4_s64 );
  70
  71 #elif CV_SSE2
  72
  73 template <typename T>
  74 struct VMerge2
  75 {
  76     VMerge2() : support(false) { }
  77     void operator()(const T *, const T *, T *) const { }
  78
  79     bool support;
  80 };
  81
  82 template <typename T>
  83 struct VMerge3
  84 {
  85     VMerge3() : support(false) { }
  86     void operator()(const T *, const T *, const T *, T *) const { }
  87
  88     bool support;
  89 };
  90
  91 template <typename T>
  92 struct VMerge4
  93 {
  94     VMerge4() : support(false) { }
  95     void operator()(const T *, const T *, const T *, const T *, T *) const { }
  96
  97     bool support;
  98 };
  99
 100 #define MERGE2_KERNEL_TEMPLATE(data_type, reg_type, cast_type, _mm_interleave, flavor, se) \
 101 template <>                                                                                \
 102 struct VMerge2<data_type>                                                                  \
 103 {                                                                                          \
 104     enum                                                                                   \
 105     {                                                                                      \
 106         ELEMS_IN_VEC = 16 / sizeof(data_type)                                              \
 107     };                                                                                     \
 108                                                                                            \
 109     VMerge2()                                                                              \
 110     {                                                                                      \
 111         support = checkHardwareSupport(se);                                                \
 112     }                                                                                      \
 113                                                                                            \
 114     void operator()(const data_type * src0, const data_type * src1,                        \
 115                     data_type * dst) const                                                 \
 116     {                                                                                      \
 117         reg_type v_src0 = _mm_loadu_##flavor((const cast_type *)(src0));                   \
 118         reg_type v_src1 = _mm_loadu_##flavor((const cast_type *)(src0 + ELEMS_IN_VEC));    \
 119         reg_type v_src2 = _mm_loadu_##flavor((const cast_type *)(src1));                   \
 120         reg_type v_src3 = _mm_loadu_##flavor((const cast_type *)(src1 + ELEMS_IN_VEC));    \
 121                                                                                            \
 122         _mm_interleave(v_src0, v_src1, v_src2, v_src3);                                    \
 123                                                                                            \
 124         _mm_storeu_##flavor((cast_type *)(dst), v_src0);                                   \
 125         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC), v_src1);                    \
 126         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 2), v_src2);                \
 127         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 3), v_src3);                \
 128     }                                                                                      \
 129                                                                                            \
 130     bool support;                                                                          \
 131 }
 132
 133 #define MERGE3_KERNEL_TEMPLATE(data_type, reg_type, cast_type, _mm_interleave, flavor, se) \
 134 template <>                                                                                \
 135 struct VMerge3<data_type>                                                                  \
 136 {                                                                                          \
 137     enum                                                                                   \
 138     {                                                                                      \
 139         ELEMS_IN_VEC = 16 / sizeof(data_type)                                              \
 140     };                                                                                     \
 141                                                                                            \
 142     VMerge3()                                                                              \
 143     {                                                                                      \
 144         support = checkHardwareSupport(se);                                                \
 145     }                                                                                      \
 146                                                                                            \
 147     void operator()(const data_type * src0, const data_type * src1, const data_type * src2,\
 148                     data_type * dst) const                                                 \
 149     {                                                                                      \
 150         reg_type v_src0 = _mm_loadu_##flavor((const cast_type *)(src0));                   \
 151         reg_type v_src1 = _mm_loadu_##flavor((const cast_type *)(src0 + ELEMS_IN_VEC));    \
 152         reg_type v_src2 = _mm_loadu_##flavor((const cast_type *)(src1));                   \
 153         reg_type v_src3 = _mm_loadu_##flavor((const cast_type *)(src1 + ELEMS_IN_VEC));    \
 154         reg_type v_src4 = _mm_loadu_##flavor((const cast_type *)(src2));                   \
 155         reg_type v_src5 = _mm_loadu_##flavor((const cast_type *)(src2 + ELEMS_IN_VEC));    \
 156                                                                                            \
 157         _mm_interleave(v_src0, v_src1, v_src2,                                             \
 158                        v_src3, v_src4, v_src5);                                            \
 159                                                                                            \
 160         _mm_storeu_##flavor((cast_type *)(dst), v_src0);                                   \
 161         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC), v_src1);                    \
 162         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 2), v_src2);                \
 163         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 3), v_src3);                \
 164         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 4), v_src4);                \
 165         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 5), v_src5);                \
 166     }                                                                                      \
 167                                                                                            \
 168     bool support;                                                                          \
 169 }
 170
 171 #define MERGE4_KERNEL_TEMPLATE(data_type, reg_type, cast_type, _mm_interleave, flavor, se) \
 172 template <>                                                                                \
 173 struct VMerge4<data_type>                                                                  \
 174 {                                                                                          \
 175     enum                                                                                   \
 176     {                                                                                      \
 177         ELEMS_IN_VEC = 16 / sizeof(data_type)                                              \
 178     };                                                                                     \
 179                                                                                            \
 180     VMerge4()                                                                              \
 181     {                                                                                      \
 182         support = checkHardwareSupport(se);                                                \
 183     }                                                                                      \
 184                                                                                            \
 185     void operator()(const data_type * src0, const data_type * src1,                        \
 186                     const data_type * src2, const data_type * src3,                        \
 187                     data_type * dst) const                                                 \
 188     {                                                                                      \
 189         reg_type v_src0 = _mm_loadu_##flavor((const cast_type *)(src0));                   \
 190         reg_type v_src1 = _mm_loadu_##flavor((const cast_type *)(src0 + ELEMS_IN_VEC));    \
 191         reg_type v_src2 = _mm_loadu_##flavor((const cast_type *)(src1));                   \
 192         reg_type v_src3 = _mm_loadu_##flavor((const cast_type *)(src1 + ELEMS_IN_VEC));    \
 193         reg_type v_src4 = _mm_loadu_##flavor((const cast_type *)(src2));                   \
 194         reg_type v_src5 = _mm_loadu_##flavor((const cast_type *)(src2 + ELEMS_IN_VEC));    \
 195         reg_type v_src6 = _mm_loadu_##flavor((const cast_type *)(src3));                   \
 196         reg_type v_src7 = _mm_loadu_##flavor((const cast_type *)(src3 + ELEMS_IN_VEC));    \
 197                                                                                            \
 198         _mm_interleave(v_src0, v_src1, v_src2, v_src3,                                     \
 199                        v_src4, v_src5, v_src6, v_src7);                                    \
 200                                                                                            \
 201         _mm_storeu_##flavor((cast_type *)(dst), v_src0);                                   \
 202         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC), v_src1);                    \
 203         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 2), v_src2);                \
 204         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 3), v_src3);                \
 205         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 4), v_src4);                \
 206         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 5), v_src5);                \
 207         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 6), v_src6);                \
 208         _mm_storeu_##flavor((cast_type *)(dst + ELEMS_IN_VEC * 7), v_src7);                \
 209     }                                                                                      \
 210                                                                                            \
 211     bool support;                                                                          \
 212 }
 213
 214 MERGE2_KERNEL_TEMPLATE( uchar, __m128i, __m128i, _mm_interleave_epi8, si128, CV_CPU_SSE2);
 215 MERGE3_KERNEL_TEMPLATE( uchar, __m128i, __m128i, _mm_interleave_epi8, si128, CV_CPU_SSE2);
 216 MERGE4_KERNEL_TEMPLATE( uchar, __m128i, __m128i, _mm_interleave_epi8, si128, CV_CPU_SSE2);
 217
 218 #if CV_SSE4_1
 219 MERGE2_KERNEL_TEMPLATE(ushort, __m128i, __m128i, _mm_interleave_epi16, si128, CV_CPU_SSE4_1);
 220 MERGE3_KERNEL_TEMPLATE(ushort, __m128i, __m128i, _mm_interleave_epi16, si128, CV_CPU_SSE4_1);
 221 MERGE4_KERNEL_TEMPLATE(ushort, __m128i, __m128i, _mm_interleave_epi16, si128, CV_CPU_SSE4_1);
 222 #endif
 223
 224 MERGE2_KERNEL_TEMPLATE(   int,  __m128,   float, _mm_interleave_ps, ps, CV_CPU_SSE2);
 225 MERGE3_KERNEL_TEMPLATE(   int,  __m128,   float, _mm_interleave_ps, ps, CV_CPU_SSE2);
 226 MERGE4_KERNEL_TEMPLATE(   int,  __m128,   float, _mm_interleave_ps, ps, CV_CPU_SSE2);
 227
 228 #endif
 229
 230 template<typename T> static void
 231 merge_( const T** src, T* dst, int len, int cn )
 232 {
 233     int k = cn % 4 ? cn % 4 : 4;
 234     int i, j;
 235     if( k == 1 )
 236     {
 237         const T* src0 = src[0];
 238         for( i = j = 0; i < len; i++, j += cn )
 239             dst[j] = src0[i];
 240     }
 241     else if( k == 2 )
 242     {
 243         const T *src0 = src[0], *src1 = src[1];
 244         i = j = 0;
 245 #if CV_NEON
 246         if(cn == 2)
 247         {
 248             int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
 249             int inc_j = 2 * inc_i;
 250
 251             VMerge2<T> vmerge;
 252             for( ; i < len - inc_i; i += inc_i, j += inc_j)
 253                 vmerge(src0 + i, src1 + i, dst + j);
 254         }
 255 #elif CV_SSE2
 256         if(cn == 2)
 257         {
 258             int inc_i = 32/sizeof(T);
 259             int inc_j = 2 * inc_i;
 260
 261             VMerge2<T> vmerge;
 262             if (vmerge.support)
 263                 for( ; i < len - inc_i; i += inc_i, j += inc_j)
 264                     vmerge(src0 + i, src1 + i, dst + j);
 265         }
 266 #endif
 267         for( ; i < len; i++, j += cn )
 268         {
 269             dst[j] = src0[i];
 270             dst[j+1] = src1[i];
 271         }
 272     }
 273     else if( k == 3 )
 274     {
 275         const T *src0 = src[0], *src1 = src[1], *src2 = src[2];
 276         i = j = 0;
 277 #if CV_NEON
 278         if(cn == 3)
 279         {
 280             int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
 281             int inc_j = 3 * inc_i;
 282
 283             VMerge3<T> vmerge;
 284             for( ; i < len - inc_i; i += inc_i, j += inc_j)
 285                 vmerge(src0 + i, src1 + i, src2 + i, dst + j);
 286         }
 287 #elif CV_SSE2
 288         if(cn == 3)
 289         {
 290             int inc_i = 32/sizeof(T);
 291             int inc_j = 3 * inc_i;
 292
 293             VMerge3<T> vmerge;
 294             if (vmerge.support)
 295                 for( ; i < len - inc_i; i += inc_i, j += inc_j)
 296                     vmerge(src0 + i, src1 + i, src2 + i, dst + j);
 297         }
 298 #endif
 299         for( ; i < len; i++, j += cn )
 300         {
 301             dst[j] = src0[i];
 302             dst[j+1] = src1[i];
 303             dst[j+2] = src2[i];
 304         }
 305     }
 306     else
 307     {
 308         const T *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
 309         i = j = 0;
 310 #if CV_NEON
 311         if(cn == 4)
 312         {
 313             int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
 314             int inc_j = 4 * inc_i;
 315
 316             VMerge4<T> vmerge;
 317             for( ; i < len - inc_i; i += inc_i, j += inc_j)
 318                 vmerge(src0 + i, src1 + i, src2 + i, src3 + i, dst + j);
 319         }
 320 #elif CV_SSE2
 321         if(cn == 4)
 322         {
 323             int inc_i = 32/sizeof(T);
 324             int inc_j = 4 * inc_i;
 325
 326             VMerge4<T> vmerge;
 327             if (vmerge.support)
 328                 for( ; i < len - inc_i; i += inc_i, j += inc_j)
 329                     vmerge(src0 + i, src1 + i, src2 + i, src3 + i, dst + j);
 330         }
 331 #endif
 332         for( ; i < len; i++, j += cn )
 333         {
 334             dst[j] = src0[i]; dst[j+1] = src1[i];
 335             dst[j+2] = src2[i]; dst[j+3] = src3[i];
 336         }
 337     }
 338
 339     for( ; k < cn; k += 4 )
 340     {
 341         const T *src0 = src[k], *src1 = src[k+1], *src2 = src[k+2], *src3 = src[k+3];
 342         for( i = 0, j = k; i < len; i++, j += cn )
 343         {
 344             dst[j] = src0[i]; dst[j+1] = src1[i];
 345             dst[j+2] = src2[i]; dst[j+3] = src3[i];
 346         }
 347     }
 348 }
 349
 350
 351 void merge8u(const uchar** src, uchar* dst, int len, int cn )
 352 {
 353     CALL_HAL(merge8u, cv_hal_merge8u, src, dst, len, cn)
 354     merge_(src, dst, len, cn);
 355 }
 356
 357 void merge16u(const ushort** src, ushort* dst, int len, int cn )
 358 {
 359     CALL_HAL(merge16u, cv_hal_merge16u, src, dst, len, cn)
 360     merge_(src, dst, len, cn);
 361 }
 362
 363 void merge32s(const int** src, int* dst, int len, int cn )
 364 {
 365     CALL_HAL(merge32s, cv_hal_merge32s, src, dst, len, cn)
 366     merge_(src, dst, len, cn);
 367 }
 368
 369 void merge64s(const int64** src, int64* dst, int len, int cn )
 370 {
 371     CALL_HAL(merge64s, cv_hal_merge64s, src, dst, len, cn)
 372     merge_(src, dst, len, cn);
 373 }
 374
 375 }} // cv::hal::
 376
 377
 378 typedef void (*MergeFunc)(const uchar** src, uchar* dst, int len, int cn);
 379
 380 static MergeFunc getMergeFunc(int depth)
 381 {
 382     static MergeFunc mergeTab[] =
 383     {
 384         (MergeFunc)GET_OPTIMIZED(cv::hal::merge8u), (MergeFunc)GET_OPTIMIZED(cv::hal::merge8u), (MergeFunc)GET_OPTIMIZED(cv::hal::merge16u), (MergeFunc)GET_OPTIMIZED(cv::hal::merge16u),
 385         (MergeFunc)GET_OPTIMIZED(cv::hal::merge32s), (MergeFunc)GET_OPTIMIZED(cv::hal::merge32s), (MergeFunc)GET_OPTIMIZED(cv::hal::merge64s), 0
 386     };
 387
 388     return mergeTab[depth];
 389 }
 390
 391 #ifdef HAVE_IPP
 392
 393 namespace cv {
 394 static bool ipp_merge(const Mat* mv, Mat& dst, int channels)
 395 {
 396 #ifdef HAVE_IPP_IW
 397     CV_INSTRUMENT_REGION_IPP()
 398
 399     if(channels != 3 && channels != 4)
 400         return false;
 401
 402     if(mv[0].dims <= 2)
 403     {
 404         IppiSize    size       = ippiSize(mv[0].size());
 405         const void *srcPtrs[4] = {NULL};
 406         size_t      srcStep    = mv[0].step;
 407         for(int i = 0; i < channels; i++)
 408         {
 409             srcPtrs[i] = mv[i].ptr();
 410             if(srcStep != mv[i].step)
 411                 return false;
 412         }
 413
 414         return CV_INSTRUMENT_FUN_IPP(llwiCopyMerge, srcPtrs, (int)srcStep, dst.ptr(), (int)dst.step, size, (int)mv[0].elemSize1(), channels, 0) >= 0;
 415     }
 416     else
 417     {
 418         const Mat *arrays[5] = {NULL};
 419         uchar     *ptrs[5]   = {NULL};
 420         arrays[0] = &dst;
 421
 422         for(int i = 1; i < channels; i++)
 423         {
 424             arrays[i] = &mv[i-1];
 425         }
 426
 427         NAryMatIterator it(arrays, ptrs);
 428         IppiSize size = { (int)it.size, 1 };
 429
 430         for( size_t i = 0; i < it.nplanes; i++, ++it )
 431         {
 432             if(CV_INSTRUMENT_FUN_IPP(llwiCopyMerge, (const void**)&ptrs[1], 0, ptrs[0], 0, size, (int)mv[0].elemSize1(), channels, 0) < 0)
 433                 return false;
 434         }
 435         return true;
 436     }
 437 #else
 438     CV_UNUSED(dst); CV_UNUSED(mv); CV_UNUSED(channels);
 439     return false;
 440 #endif
 441 }
 442 }
 443 #endif
 444
 445 void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
 446 {
 447     CV_INSTRUMENT_REGION()
 448
 449     CV_Assert( mv && n > 0 );
 450
 451     int depth = mv[0].depth();
 452     bool allch1 = true;
 453     int k, cn = 0;
 454     size_t i;
 455
 456     for( i = 0; i < n; i++ )
 457     {
 458         CV_Assert(mv[i].size == mv[0].size && mv[i].depth() == depth);
 459         allch1 = allch1 && mv[i].channels() == 1;
 460         cn += mv[i].channels();
 461     }
 462
 463     CV_Assert( 0 < cn && cn <= CV_CN_MAX );
 464     _dst.create(mv[0].dims, mv[0].size, CV_MAKETYPE(depth, cn));
 465     Mat dst = _dst.getMat();
 466
 467     if( n == 1 )
 468     {
 469         mv[0].copyTo(dst);
 470         return;
 471     }
 472
 473     CV_IPP_RUN_FAST(ipp_merge(mv, dst, (int)n));
 474
 475     if( !allch1 )
 476     {
 477         AutoBuffer<int> pairs(cn*2);
 478         int j, ni=0;
 479
 480         for( i = 0, j = 0; i < n; i++, j += ni )
 481         {
 482             ni = mv[i].channels();
 483             for( k = 0; k < ni; k++ )
 484             {
 485                 pairs[(j+k)*2] = j + k;
 486                 pairs[(j+k)*2+1] = j + k;
 487             }
 488         }
 489         mixChannels( mv, n, &dst, 1, &pairs[0], cn );
 490         return;
 491     }
 492
 493     MergeFunc func = getMergeFunc(depth);
 494     CV_Assert( func != 0 );
 495
 496     size_t esz = dst.elemSize(), esz1 = dst.elemSize1();
 497     size_t blocksize0 = (int)((BLOCK_SIZE + esz-1)/esz);
 498     AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
 499     const Mat** arrays = (const Mat**)_buf.data();
 500     uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
 501
 502     arrays[0] = &dst;
 503     for( k = 0; k < cn; k++ )
 504         arrays[k+1] = &mv[k];
 505
 506     NAryMatIterator it(arrays, ptrs, cn+1);
 507     size_t total = (int)it.size;
 508     size_t blocksize = std::min((size_t)CV_SPLIT_MERGE_MAX_BLOCK_SIZE(cn), cn <= 4 ? total : std::min(total, blocksize0));
 509
 510     for( i = 0; i < it.nplanes; i++, ++it )
 511     {
 512         for( size_t j = 0; j < total; j += blocksize )
 513         {
 514             size_t bsz = std::min(total - j, blocksize);
 515             func( (const uchar**)&ptrs[1], ptrs[0], (int)bsz, cn );
 516
 517             if( j + blocksize < total )
 518             {
 519                 ptrs[0] += bsz*esz;
 520                 for( int t = 0; t < cn; t++ )
 521                     ptrs[t+1] += bsz*esz1;
 522             }
 523         }
 524     }
 525 }
 526
 527 #ifdef HAVE_OPENCL
 528
 529 namespace cv {
 530
 531 static bool ocl_merge( InputArrayOfArrays _mv, OutputArray _dst )
 532 {
 533     std::vector<UMat> src, ksrc;
 534     _mv.getUMatVector(src);
 535     CV_Assert(!src.empty());
 536
 537     int type = src[0].type(), depth = CV_MAT_DEPTH(type),
 538             rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
 539     Size size = src[0].size();
 540
 541     for (size_t i = 0, srcsize = src.size(); i < srcsize; ++i)
 542     {
 543         int itype = src[i].type(), icn = CV_MAT_CN(itype), idepth = CV_MAT_DEPTH(itype),
 544                 esz1 = CV_ELEM_SIZE1(idepth);
 545         if (src[i].dims > 2)
 546             return false;
 547
 548         CV_Assert(size == src[i].size() && depth == idepth);
 549
 550         for (int cn = 0; cn < icn; ++cn)
 551         {
 552             UMat tsrc = src[i];
 553             tsrc.offset += cn * esz1;
 554             ksrc.push_back(tsrc);
 555         }
 556     }
 557     int dcn = (int)ksrc.size();
 558
 559     String srcargs, processelem, cndecl, indexdecl;
 560     for (int i = 0; i < dcn; ++i)
 561     {
 562         srcargs += format("DECLARE_SRC_PARAM(%d)", i);
 563         processelem += format("PROCESS_ELEM(%d)", i);
 564         indexdecl += format("DECLARE_INDEX(%d)", i);
 565         cndecl += format(" -D scn%d=%d", i, ksrc[i].channels());
 566     }
 567
 568     ocl::Kernel k("merge", ocl::core::split_merge_oclsrc,
 569                   format("-D OP_MERGE -D cn=%d -D T=%s -D DECLARE_SRC_PARAMS_N=%s"
 570                          " -D DECLARE_INDEX_N=%s -D PROCESS_ELEMS_N=%s%s",
 571                          dcn, ocl::memopTypeToStr(depth), srcargs.c_str(),
 572                          indexdecl.c_str(), processelem.c_str(), cndecl.c_str()));
 573     if (k.empty())
 574         return false;
 575
 576     _dst.create(size, CV_MAKE_TYPE(depth, dcn));
 577     UMat dst = _dst.getUMat();
 578
 579     int argidx = 0;
 580     for (int i = 0; i < dcn; ++i)
 581         argidx = k.set(argidx, ocl::KernelArg::ReadOnlyNoSize(ksrc[i]));
 582     argidx = k.set(argidx, ocl::KernelArg::WriteOnly(dst));
 583     k.set(argidx, rowsPerWI);
 584
 585     size_t globalsize[2] = { (size_t)dst.cols, ((size_t)dst.rows + rowsPerWI - 1) / rowsPerWI };
 586     return k.run(2, globalsize, NULL, false);
 587 }
 588
 589 }
 590
 591 #endif
 592
 593 void cv::merge(InputArrayOfArrays _mv, OutputArray _dst)
 594 {
 595     CV_INSTRUMENT_REGION()
 596
 597     CV_OCL_RUN(_mv.isUMatVector() && _dst.isUMat(),
 598                ocl_merge(_mv, _dst))
 599
 600     std::vector<Mat> mv;
 601     _mv.getMatVector(mv);
 602     merge(!mv.empty() ? &mv[0] : 0, mv.size(), _dst);
 603 }