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_SIMD
  12 // see the comments for vecmerge_ in merge.cpp
  13 template<typename T, typename VecT> static void
  14 vecsplit_( const T* src, T** dst, int len, int cn )
  15 {
  16     const int VECSZ = VecT::nlanes;
  17     int i, i0 = 0;
  18     T* dst0 = dst[0];
  19     T* dst1 = dst[1];
  20
  21     int r0 = (int)((size_t)(void*)dst0 % (VECSZ*sizeof(T)));
  22     int r1 = (int)((size_t)(void*)dst1 % (VECSZ*sizeof(T)));
  23     int r2 = cn > 2 ? (int)((size_t)(void*)dst[2] % (VECSZ*sizeof(T))) : r0;
  24     int r3 = cn > 3 ? (int)((size_t)(void*)dst[3] % (VECSZ*sizeof(T))) : r0;
  25
  26     hal::StoreMode mode = hal::STORE_ALIGNED_NOCACHE;
  27     if( (r0|r1|r2|r3) != 0 )
  28     {
  29         mode = hal::STORE_UNALIGNED;
  30         if( r0 == r1 && r0 == r2 && r0 == r3 && r0 % cn == 0 && len > VECSZ )
  31             i0 = VECSZ - (r0 / cn);
  32     }
  33
  34     if( cn == 2 )
  35     {
  36         for( i = 0; i < len; i += VECSZ )
  37         {
  38             if( i > len - VECSZ )
  39             {
  40                 i = len - VECSZ;
  41                 mode = hal::STORE_UNALIGNED;
  42             }
  43             VecT a, b;
  44             v_load_deinterleave(src + i*cn, a, b);
  45             v_store(dst0 + i, a, mode);
  46             v_store(dst1 + i, b, mode);
  47             if( i < i0 )
  48             {
  49                 i = i0 - VECSZ;
  50                 mode = hal::STORE_ALIGNED_NOCACHE;
  51             }
  52         }
  53     }
  54     else if( cn == 3 )
  55     {
  56         T* dst2 = dst[2];
  57         for( i = 0; i < len; i += VECSZ )
  58         {
  59             if( i > len - VECSZ )
  60             {
  61                 i = len - VECSZ;
  62                 mode = hal::STORE_UNALIGNED;
  63             }
  64             VecT a, b, c;
  65             v_load_deinterleave(src + i*cn, a, b, c);
  66             v_store(dst0 + i, a, mode);
  67             v_store(dst1 + i, b, mode);
  68             v_store(dst2 + i, c, mode);
  69             if( i < i0 )
  70             {
  71                 i = i0 - VECSZ;
  72                 mode = hal::STORE_ALIGNED_NOCACHE;
  73             }
  74         }
  75     }
  76     else
  77     {
  78         CV_Assert( cn == 4 );
  79         T* dst2 = dst[2];
  80         T* dst3 = dst[3];
  81         for( i = 0; i < len; i += VECSZ )
  82         {
  83             if( i > len - VECSZ )
  84             {
  85                 i = len - VECSZ;
  86                 mode = hal::STORE_UNALIGNED;
  87             }
  88             VecT a, b, c, d;
  89             v_load_deinterleave(src + i*cn, a, b, c, d);
  90             v_store(dst0 + i, a, mode);
  91             v_store(dst1 + i, b, mode);
  92             v_store(dst2 + i, c, mode);
  93             v_store(dst3 + i, d, mode);
  94             if( i < i0 )
  95             {
  96                 i = i0 - VECSZ;
  97                 mode = hal::STORE_ALIGNED_NOCACHE;
  98             }
  99         }
 100     }
 101     vx_cleanup();
 102 }
 103 #endif
 104
 105 template<typename T> static void
 106 split_( const T* src, T** dst, int len, int cn )
 107 {
 108     int k = cn % 4 ? cn % 4 : 4;
 109     int i, j;
 110     if( k == 1 )
 111     {
 112         T* dst0 = dst[0];
 113
 114         if(cn == 1)
 115         {
 116             memcpy(dst0, src, len * sizeof(T));
 117         }
 118         else
 119         {
 120             for( i = 0, j = 0 ; i < len; i++, j += cn )
 121                 dst0[i] = src[j];
 122         }
 123     }
 124     else if( k == 2 )
 125     {
 126         T *dst0 = dst[0], *dst1 = dst[1];
 127         i = j = 0;
 128
 129         for( ; i < len; i++, j += cn )
 130         {
 131             dst0[i] = src[j];
 132             dst1[i] = src[j+1];
 133         }
 134     }
 135     else if( k == 3 )
 136     {
 137         T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2];
 138         i = j = 0;
 139
 140         for( ; i < len; i++, j += cn )
 141         {
 142             dst0[i] = src[j];
 143             dst1[i] = src[j+1];
 144             dst2[i] = src[j+2];
 145         }
 146     }
 147     else
 148     {
 149         T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2], *dst3 = dst[3];
 150         i = j = 0;
 151
 152         for( ; i < len; i++, j += cn )
 153         {
 154             dst0[i] = src[j]; dst1[i] = src[j+1];
 155             dst2[i] = src[j+2]; dst3[i] = src[j+3];
 156         }
 157     }
 158
 159     for( ; k < cn; k += 4 )
 160     {
 161         T *dst0 = dst[k], *dst1 = dst[k+1], *dst2 = dst[k+2], *dst3 = dst[k+3];
 162         for( i = 0, j = k; i < len; i++, j += cn )
 163         {
 164             dst0[i] = src[j]; dst1[i] = src[j+1];
 165             dst2[i] = src[j+2]; dst3[i] = src[j+3];
 166         }
 167     }
 168 }
 169
 170 void split8u(const uchar* src, uchar** dst, int len, int cn )
 171 {
 172     CALL_HAL(split8u, cv_hal_split8u, src,dst, len, cn)
 173
 174 #if CV_SIMD
 175     if( len >= v_uint8::nlanes && 2 <= cn && cn <= 4 )
 176         vecsplit_<uchar, v_uint8>(src, dst, len, cn);
 177     else
 178 #endif
 179         split_(src, dst, len, cn);
 180 }
 181
 182 void split16u(const ushort* src, ushort** dst, int len, int cn )
 183 {
 184     CALL_HAL(split16u, cv_hal_split16u, src,dst, len, cn)
 185 #if CV_SIMD
 186     if( len >= v_uint16::nlanes && 2 <= cn && cn <= 4 )
 187         vecsplit_<ushort, v_uint16>(src, dst, len, cn);
 188     else
 189 #endif
 190         split_(src, dst, len, cn);
 191 }
 192
 193 void split32s(const int* src, int** dst, int len, int cn )
 194 {
 195     CALL_HAL(split32s, cv_hal_split32s, src,dst, len, cn)
 196 #if CV_SIMD
 197     if( len >= v_uint32::nlanes && 2 <= cn && cn <= 4 )
 198         vecsplit_<int, v_int32>(src, dst, len, cn);
 199     else
 200 #endif
 201         split_(src, dst, len, cn);
 202 }
 203
 204 void split64s(const int64* src, int64** dst, int len, int cn )
 205 {
 206     CALL_HAL(split64s, cv_hal_split64s, src,dst, len, cn)
 207 #if CV_SIMD
 208     if( len >= v_int64::nlanes && 2 <= cn && cn <= 4 )
 209         vecsplit_<int64, v_int64>(src, dst, len, cn);
 210     else
 211 #endif
 212         split_(src, dst, len, cn);
 213 }
 214
 215 }} // cv::hal::
 216
 217 /****************************************************************************************\
 218 *                                       split & merge                                    *
 219 \****************************************************************************************/
 220
 221 typedef void (*SplitFunc)(const uchar* src, uchar** dst, int len, int cn);
 222
 223 static SplitFunc getSplitFunc(int depth)
 224 {
 225     static SplitFunc splitTab[] =
 226     {
 227         (SplitFunc)GET_OPTIMIZED(cv::hal::split8u), (SplitFunc)GET_OPTIMIZED(cv::hal::split8u), (SplitFunc)GET_OPTIMIZED(cv::hal::split16u), (SplitFunc)GET_OPTIMIZED(cv::hal::split16u),
 228         (SplitFunc)GET_OPTIMIZED(cv::hal::split32s), (SplitFunc)GET_OPTIMIZED(cv::hal::split32s), (SplitFunc)GET_OPTIMIZED(cv::hal::split64s), 0
 229     };
 230
 231     return splitTab[depth];
 232 }
 233
 234 #ifdef HAVE_IPP
 235
 236 namespace cv {
 237 static bool ipp_split(const Mat& src, Mat* mv, int channels)
 238 {
 239 #ifdef HAVE_IPP_IW
 240     CV_INSTRUMENT_REGION_IPP()
 241
 242     if(channels != 3 && channels != 4)
 243         return false;
 244
 245     if(src.dims <= 2)
 246     {
 247         IppiSize size       = ippiSize(src.size());
 248         void    *dstPtrs[4] = {NULL};
 249         size_t   dstStep    = mv[0].step;
 250         for(int i = 0; i < channels; i++)
 251         {
 252             dstPtrs[i] = mv[i].ptr();
 253             if(dstStep != mv[i].step)
 254                 return false;
 255         }
 256
 257         return CV_INSTRUMENT_FUN_IPP(llwiCopySplit, src.ptr(), (int)src.step, dstPtrs, (int)dstStep, size, (int)src.elemSize1(), channels, 0) >= 0;
 258     }
 259     else
 260     {
 261         const Mat *arrays[5] = {NULL};
 262         uchar     *ptrs[5]   = {NULL};
 263         arrays[0] = &src;
 264
 265         for(int i = 1; i < channels; i++)
 266         {
 267             arrays[i] = &mv[i-1];
 268         }
 269
 270         NAryMatIterator it(arrays, ptrs);
 271         IppiSize size = { (int)it.size, 1 };
 272
 273         for( size_t i = 0; i < it.nplanes; i++, ++it )
 274         {
 275             if(CV_INSTRUMENT_FUN_IPP(llwiCopySplit, ptrs[0], 0, (void**)&ptrs[1], 0, size, (int)src.elemSize1(), channels, 0) < 0)
 276                 return false;
 277         }
 278         return true;
 279     }
 280 #else
 281     CV_UNUSED(src); CV_UNUSED(mv); CV_UNUSED(channels);
 282     return false;
 283 #endif
 284 }
 285 }
 286 #endif
 287
 288 void cv::split(const Mat& src, Mat* mv)
 289 {
 290     CV_INSTRUMENT_REGION()
 291
 292     int k, depth = src.depth(), cn = src.channels();
 293     if( cn == 1 )
 294     {
 295         src.copyTo(mv[0]);
 296         return;
 297     }
 298
 299     for( k = 0; k < cn; k++ )
 300     {
 301         mv[k].create(src.dims, src.size, depth);
 302     }
 303
 304     CV_IPP_RUN_FAST(ipp_split(src, mv, cn));
 305
 306     SplitFunc func = getSplitFunc(depth);
 307     CV_Assert( func != 0 );
 308
 309     size_t esz = src.elemSize(), esz1 = src.elemSize1();
 310     size_t blocksize0 = (BLOCK_SIZE + esz-1)/esz;
 311     AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
 312     const Mat** arrays = (const Mat**)_buf.data();
 313     uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
 314
 315     arrays[0] = &src;
 316     for( k = 0; k < cn; k++ )
 317     {
 318         arrays[k+1] = &mv[k];
 319     }
 320
 321     NAryMatIterator it(arrays, ptrs, cn+1);
 322     size_t total = it.size;
 323     size_t blocksize = std::min((size_t)CV_SPLIT_MERGE_MAX_BLOCK_SIZE(cn), cn <= 4 ? total : std::min(total, blocksize0));
 324
 325     for( size_t i = 0; i < it.nplanes; i++, ++it )
 326     {
 327         for( size_t j = 0; j < total; j += blocksize )
 328         {
 329             size_t bsz = std::min(total - j, blocksize);
 330             func( ptrs[0], &ptrs[1], (int)bsz, cn );
 331
 332             if( j + blocksize < total )
 333             {
 334                 ptrs[0] += bsz*esz;
 335                 for( k = 0; k < cn; k++ )
 336                     ptrs[k+1] += bsz*esz1;
 337             }
 338         }
 339     }
 340 }
 341
 342 #ifdef HAVE_OPENCL
 343
 344 namespace cv {
 345
 346 static bool ocl_split( InputArray _m, OutputArrayOfArrays _mv )
 347 {
 348     int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type),
 349             rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
 350
 351     String dstargs, processelem, indexdecl;
 352     for (int i = 0; i < cn; ++i)
 353     {
 354         dstargs += format("DECLARE_DST_PARAM(%d)", i);
 355         indexdecl += format("DECLARE_INDEX(%d)", i);
 356         processelem += format("PROCESS_ELEM(%d)", i);
 357     }
 358
 359     ocl::Kernel k("split", ocl::core::split_merge_oclsrc,
 360                   format("-D T=%s -D OP_SPLIT -D cn=%d -D DECLARE_DST_PARAMS=%s"
 361                          " -D PROCESS_ELEMS_N=%s -D DECLARE_INDEX_N=%s",
 362                          ocl::memopTypeToStr(depth), cn, dstargs.c_str(),
 363                          processelem.c_str(), indexdecl.c_str()));
 364     if (k.empty())
 365         return false;
 366
 367     Size size = _m.size();
 368     _mv.create(cn, 1, depth);
 369     for (int i = 0; i < cn; ++i)
 370         _mv.create(size, depth, i);
 371
 372     std::vector<UMat> dst;
 373     _mv.getUMatVector(dst);
 374
 375     int argidx = k.set(0, ocl::KernelArg::ReadOnly(_m.getUMat()));
 376     for (int i = 0; i < cn; ++i)
 377         argidx = k.set(argidx, ocl::KernelArg::WriteOnlyNoSize(dst[i]));
 378     k.set(argidx, rowsPerWI);
 379
 380     size_t globalsize[2] = { (size_t)size.width, ((size_t)size.height + rowsPerWI - 1) / rowsPerWI };
 381     return k.run(2, globalsize, NULL, false);
 382 }
 383
 384 }
 385
 386 #endif
 387
 388 void cv::split(InputArray _m, OutputArrayOfArrays _mv)
 389 {
 390     CV_INSTRUMENT_REGION()
 391
 392     CV_OCL_RUN(_m.dims() <= 2 && _mv.isUMatVector(),
 393                ocl_split(_m, _mv))
 394
 395     Mat m = _m.getMat();
 396     if( m.empty() )
 397     {
 398         _mv.release();
 399         return;
 400     }
 401
 402     CV_Assert( !_mv.fixedType() || _mv.empty() || _mv.type() == m.depth() );
 403
 404     int depth = m.depth(), cn = m.channels();
 405     _mv.create(cn, 1, depth);
 406     for (int i = 0; i < cn; ++i)
 407         _mv.create(m.dims, m.size.p, depth, i);
 408
 409     std::vector<Mat> dst;
 410     _mv.getMatVector(dst);
 411
 412     split(m, &dst[0]);
 413 }