potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-29 23:33:05 +04:00
Code Packages Releases Wiki Activity

Merge pull request #21083 from OrestChura:oc/fix_coverity_vino_issues

Browse Source 
[G-API] Fixed Coverity issues

* Fixed Coverity issues
 - VectorRef&OpaqueRef m_kind = CV_UNKNOWN
 - added same-type overload for saturate()
 - sanitized resize value in ByteMemoryInStream::operator>> (std::string& str)
 - handled throws from ~GStreamingExecutor()

* Catching exception by const ref

* Addressing Sergey's comments

* Applied enable_if semanitcs to saturate(x, round) too

* Removed uncaught_exception, made destructor noexcept back

* Split Fluid ConvertTo to multiple functions to avoid ifs; added CV_ALWAYS_INLINE

* Added FIXME to address throwings from stop()

* Fix standalone

* Addressing comments

* Guarded SIMD optimizations properly

* Removed excess parameter from simd_impl functions
This commit is contained in:
Orest Chura
2021-11-26 19:40:36 +03:00
committed by GitHub
parent b95d71af2b
commit 2deb38d615
7 changed files with 157 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gapi/src/backends/common/serialization.cpp
+1 -1
View File
@@ -928,7 +928,7 @@ IIStream& ByteMemoryInStream::operator>> (std::string& str) {
if (sz == 0u) {
str.clear();
} else {
str.resize(sz);
str.resize(static_cast<std::size_t>(sz));
for (auto &&i : ade::util::iota(sz)) { *this >> str[i]; }
}
return *this;
modules/gapi/src/backends/fluid/gfluidcore.cpp
+102 -73
View File
@@ -1955,93 +1955,122 @@ GAPI_FLUID_KERNEL(GFluidLUT, cv::gapi::core::GLUT, false)
//
//-------------------------
#if CV_SIMD128
template<typename DST, typename SRC>
CV_ALWAYS_INLINE int run_convertto_simd(DST*, const SRC*, int)
{
return 0;
}
CV_ALWAYS_INLINE int run_convertto_simd(uchar *out, const float *in, const int length)
{
int l = 0;
for (; l <= length - 16; l += 16)
{
v_int32x4 i0, i1, i2, i3;
i0 = v_round( v_load( (float*)& in[l ] ) );
i1 = v_round( v_load( (float*)& in[l + 4] ) );
i2 = v_round( v_load( (float*)& in[l + 8] ) );
i3 = v_round( v_load( (float*)& in[l + 12] ) );
v_uint16x8 us0, us1;
us0 = v_pack_u(i0, i1);
us1 = v_pack_u(i2, i3);
v_uint8x16 uc;
uc = v_pack(us0, us1);
v_store((uchar*)& out[l], uc);
}
return l;
}
CV_ALWAYS_INLINE int run_convertto_simd(ushort *out, const float *in, const int length)
{
int l = 0;
for (; l <= length - 8; l += 8)
{
v_int32x4 i0, i1;
i0 = v_round( v_load( (float*)& in[l ] ) );
i1 = v_round( v_load( (float*)& in[l + 4] ) );
v_uint16x8 us;
us = v_pack_u(i0, i1);
v_store((ushort*)& out[l], us);
}
return l;
}
#endif
template<typename DST, typename SRC,
cv::util::enable_if_t<std::is_integral<DST>::value &&
std::is_floating_point<SRC>::value, bool> = true >
CV_ALWAYS_INLINE void run_convertto(DST *out, const SRC *in, const int length)
{
// manual SIMD if need rounding
static_assert(std::is_same<SRC,float>::value, "64-bit floating-point source is not supported");
int l = 0; // cycle index
#if CV_SIMD128
l = run_convertto_simd(out, in, length);
#endif
// tail of SIMD cycle
for (; l < length; l++)
{
out[l] = saturate<DST>(in[l], rintf);
}
}
template<typename DST, typename SRC,
cv::util::enable_if_t<std::is_integral<DST>::value &&
std::is_integral<SRC>::value , bool> = true >
CV_ALWAYS_INLINE void run_convertto(DST *out, const SRC *in, const int length)
{
for (int l = 0; l < length; l++)
{
out[l] = saturate<DST>(in[l]);
}
}
template<typename DST, typename SRC,
cv::util::enable_if_t<std::is_floating_point<DST>::value, bool> = true >
CV_ALWAYS_INLINE void run_convertto(DST *out, const SRC *in, const int length)
{
static_assert(!std::is_same<SRC,double>::value, "64-bit floating-point source is not supported");
for (int l = 0; l < length; l++)
{
out[l] = static_cast<DST>(in[l]);
}
}
template<typename DST, typename SRC>
CV_ALWAYS_INLINE void run_convertto(DST *out, const SRC *in, const float alpha, const float beta,
const int length)
{
static_assert(!std::is_same<SRC,double>::value, "64-bit floating-point source is not supported");
// TODO: optimize if alpha and beta and data are integral
for (int l = 0; l < length; l++)
{
out[l] = saturate<DST>(in[l] * alpha + beta, rintf);
}
}
template<typename DST, typename SRC>
static void run_convertto(Buffer &dst, const View &src, double _alpha, double _beta)
{
const auto *in = src.InLine<SRC>(0);
auto *out = dst.OutLine<DST>();
int width = dst.length();
int chan = dst.meta().chan;
int length = width * chan;
const int width = dst.length();
const int chan = dst.meta().chan;
const int length = width * chan;
// NB: don't do this if SRC or DST is 64-bit
auto alpha = static_cast<float>( _alpha );
auto beta = static_cast<float>( _beta );
const auto alpha = static_cast<float>( _alpha );
const auto beta = static_cast<float>( _beta );
// compute faster if no alpha no beta
if (alpha == 1 && beta == 0)
if (1.f == alpha && 0.f == beta)
{
// manual SIMD if need rounding
if (std::is_integral<DST>::value && std::is_floating_point<SRC>::value)
{
GAPI_Assert(( std::is_same<SRC,float>::value ));
int l = 0; // cycle index
#if CV_SIMD128
if (std::is_same<DST,uchar>::value)
{
for (; l <= length-16; l+=16)
{
v_int32x4 i0, i1, i2, i3;
i0 = v_round( v_load( (float*)& in[l ] ) );
i1 = v_round( v_load( (float*)& in[l + 4] ) );
i2 = v_round( v_load( (float*)& in[l + 8] ) );
i3 = v_round( v_load( (float*)& in[l + 12] ) );
v_uint16x8 us0, us1;
us0 = v_pack_u(i0, i1);
us1 = v_pack_u(i2, i3);
v_uint8x16 uc;
uc = v_pack(us0, us1);
v_store((uchar*)& out[l], uc);
}
}
if (std::is_same<DST,ushort>::value)
{
for (; l <= length-8; l+=8)
{
v_int32x4 i0, i1;
i0 = v_round( v_load( (float*)& in[l ] ) );
i1 = v_round( v_load( (float*)& in[l + 4] ) );
v_uint16x8 us;
us = v_pack_u(i0, i1);
v_store((ushort*)& out[l], us);
}
}
#endif
// tail of SIMD cycle
for (; l < length; l++)
{
out[l] = saturate<DST>(in[l], rintf);
}
}
else if (std::is_integral<DST>::value) // here SRC is integral
{
for (int l=0; l < length; l++)
{
out[l] = saturate<DST>(in[l]);
}
}
else // DST is floating-point, SRC is any
{
for (int l=0; l < length; l++)
{
out[l] = static_cast<DST>(in[l]);
}
}
run_convertto(out, in, length);
}
else // if alpha or beta is non-trivial
{
// TODO: optimize if alpha and beta and data are integral
for (int l=0; l < length; l++)
{
out[l] = saturate<DST>(in[l]*alpha + beta, rintf);
}
run_convertto(out, in, alpha, beta, length);
}
}