Merge pull request #29523 from asmorkalov:as/relax_gapi_gstreamer_test

Relaxed G-API tests for GStreamer to support Ubuntu 26.04.

3rdparty/ippicv/ippicv.cmake

@@ -2,7 +2,7 @@ function(download_ippicv root_var)
   set(${root_var} "" PARENT_SCOPE)
 
   # Commit SHA in the opencv_3rdparty repo
-  set(IPPICV_COMMIT "406d398c436d0465c8e53dd432d9ecd9301d5f4a")
+  set(IPPICV_COMMIT "8338862a733cb3980d8b51d8e14917fe0e695f71")
   # Define actual ICV versions
   if(APPLE)
     set(IPPICV_COMMIT "0cc4aa06bf2bef4b05d237c69a5a96b9cd0cb85a")
@@ -14,8 +14,8 @@ function(download_ippicv root_var)
     set(OPENCV_ICV_PLATFORM "linux")
     set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_lnx")
     if(X86_64)
-      set(OPENCV_ICV_NAME "ippicv_2026.0.0_lnx_intel64_20260327_general.tgz")
-      set(OPENCV_ICV_HASH "9a3ee0c5c3c02102faa422d60bfd1f4a")
+      set(OPENCV_ICV_NAME "ippicv_2026.0.0_lnx_intel64_20260630_general.tgz")
+      set(OPENCV_ICV_HASH "a77e60db544e07a126ae98f5ffe83be1")
     else()
       if(ANDROID)
         set(IPPICV_COMMIT "c7c6d527dde5fee7cb914ee9e4e20f7436aab3a1")
@@ -31,8 +31,8 @@ function(download_ippicv root_var)
     set(OPENCV_ICV_PLATFORM "windows")
     set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_win")
     if(X86_64)
-      set(OPENCV_ICV_NAME "ippicv_2026.0.0_win_intel64_20260327_general.zip")
-      set(OPENCV_ICV_HASH "73bc67cd5e4c8da706fa88fe84630231")
+      set(OPENCV_ICV_NAME "ippicv_2026.0.0_win_intel64_20260630_general.zip")
+      set(OPENCV_ICV_HASH "d81c8b7d40da2867df82f0077a40afa1")
     else()
       set(IPPICV_COMMIT "7f55c0c26be418d494615afca15218566775c725")
       set(OPENCV_ICV_NAME "ippicv_2021.12.0_win_ia32_20240425_general.zip")

hal/ipp/CMakeLists.txt

@@ -26,6 +26,7 @@ add_library(ipphal STATIC
     "${CMAKE_CURRENT_SOURCE_DIR}/src/canny_ipp.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/threshold_ipp.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/distancetransform_ipp.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/histogram_ipp.cpp"
 )
 
 #TODO: HAVE_IPP_ICV and HAVE_IPP_IW added as private macro till OpenCV itself is

hal/ipp/include/ipp_hal_imgproc.hpp

@@ -154,6 +154,11 @@ int ipp_hal_distanceTransform(const uchar* src_data, size_t src_step, uchar* dst
 #undef cv_hal_distanceTransform
 #define cv_hal_distanceTransform ipp_hal_distanceTransform
 
+int ipp_hal_calcHist(const uchar* src_data, size_t src_step, int src_type, int src_width, int src_height,
+                     float* hist_data, int hist_size, const float** ranges, bool uniform, bool accumulate);
+#undef cv_hal_calcHist
+#define cv_hal_calcHist ipp_hal_calcHist
+
 #endif // IPP_VERSION_X100 >= 700
 
 #define IPP_DISABLE_PERF_CANNY_MT 1 // cv::Canny OpenCV MT performance is better

hal/ipp/src/histogram_ipp.cpp

@@ -0,0 +1,223 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (C) 2026, BigVision LLC, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+#include "ipp_hal_imgproc.hpp"
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/utils/tls.hpp>
+#include "precomp_ipp.hpp"
+
+#if IPP_VERSION_X100 >= 700
+
+#define IPP_HISTOGRAM_PARALLEL 1
+
+namespace cv { namespace ipp { unsigned long long getIppTopFeatures(); } }
+
+using namespace cv;
+
+namespace {
+
+typedef IppStatus(CV_STDCALL * IppiHistogram_C1)(const void* pSrc, int srcStep,
+    IppiSize roiSize, Ipp32u* pHist, const IppiHistogramSpec* pSpec, Ipp8u* pBuffer);
+
+static IppiHistogram_C1 getIppiHistogramFunction_C1(int type)
+{
+    IppiHistogram_C1 ippFunction =
+        (type == CV_8UC1) ? (IppiHistogram_C1)ippiHistogram_8u_C1R :
+        (type == CV_16UC1) ? (IppiHistogram_C1)ippiHistogram_16u_C1R :
+        (type == CV_32FC1) ? (IppiHistogram_C1)ippiHistogram_32f_C1R :
+        NULL;
+
+    return ippFunction;
+}
+
+class ipp_calcHistParallelTLS
+{
+public:
+    ipp_calcHistParallelTLS() {}
+
+    IppAutoBuffer<IppiHistogramSpec> spec;
+    IppAutoBuffer<Ipp8u>  buffer;
+    IppAutoBuffer<Ipp32u> thist;
+};
+
+class ipp_calcHistParallel: public ParallelLoopBody
+{
+public:
+    ipp_calcHistParallel(const Mat &src, Mat &hist, Ipp32s histSize, const float *ranges, bool uniform, bool &ok):
+        ParallelLoopBody(), m_src(src), m_hist(hist), m_ok(ok)
+    {
+        ok = true;
+
+        m_uniform        = uniform;
+        m_ranges         = ranges;
+        m_histSize       = histSize;
+        m_type           = ippiGetDataType(src.type());
+        m_levelsNum      = histSize+1;
+        ippiHistogram_C1 = getIppiHistogramFunction_C1(src.type());
+        m_fullRoi    = ippiSize(src.size());
+        m_bufferSize = 0;
+        m_specSize   = 0;
+        if(!ippiHistogram_C1)
+        {
+            ok = false;
+            return;
+        }
+
+        if(ippiHistogramGetBufferSize(m_type, m_fullRoi, &m_levelsNum, 1, 1, &m_specSize, &m_bufferSize) < 0)
+        {
+            ok = false;
+            return;
+        }
+
+        hist.setTo(0);
+    }
+
+    virtual void operator() (const Range & range) const CV_OVERRIDE
+    {
+        if(!m_ok)
+            return;
+
+        ipp_calcHistParallelTLS *pTls = m_tls.get();
+
+        IppiSize roi = {m_src.cols, range.end - range.start };
+        bool     mtLoop = false;
+        if(m_fullRoi.height != roi.height)
+            mtLoop = true;
+
+        if(!pTls->spec)
+        {
+            pTls->spec.allocate(m_specSize);
+            if(!pTls->spec.get())
+            {
+                m_ok = false;
+                return;
+            }
+
+            pTls->buffer.allocate(m_bufferSize);
+            if(!pTls->buffer.get() && m_bufferSize)
+            {
+                m_ok = false;
+                return;
+            }
+
+            if(m_uniform)
+            {
+                if(ippiHistogramUniformInit(m_type, (Ipp32f*)&m_ranges[0], (Ipp32f*)&m_ranges[1], (Ipp32s*)&m_levelsNum, 1, pTls->spec) < 0)
+                {
+                    m_ok = false;
+                    return;
+                }
+            }
+            else
+            {
+                if(ippiHistogramInit(m_type, (const Ipp32f**)&m_ranges, (Ipp32s*)&m_levelsNum, 1, pTls->spec) < 0)
+                {
+                    m_ok = false;
+                    return;
+                }
+            }
+
+            pTls->thist.allocate(m_histSize*sizeof(Ipp32u));
+        }
+
+        if(CV_INSTRUMENT_FUN_IPP(ippiHistogram_C1, m_src.ptr(range.start), (int)m_src.step, roi, pTls->thist, pTls->spec, pTls->buffer) < 0)
+        {
+            m_ok = false;
+            return;
+        }
+
+        if(mtLoop)
+        {
+            for(int i = 0; i < m_histSize; i++)
+                CV_XADD((int*)(m_hist.ptr(i)), *(int*)((Ipp32u*)pTls->thist + i));
+        }
+        else
+            ippiCopy_32s_C1R((Ipp32s*)pTls->thist.get(), sizeof(Ipp32u), (Ipp32s*)m_hist.ptr(), (int)m_hist.step, ippiSize(1, m_histSize));
+    }
+
+private:
+    const Mat      &m_src;
+    Mat            &m_hist;
+    Ipp32s          m_histSize;
+    const float    *m_ranges;
+    bool            m_uniform;
+
+    IppiHistogram_C1    ippiHistogram_C1;
+    IppiSize            m_fullRoi;
+    IppDataType         m_type;
+    Ipp32s              m_levelsNum;
+    int                 m_bufferSize;
+    int                 m_specSize;
+
+    mutable Mutex                    m_syncMutex;
+    TLSData<ipp_calcHistParallelTLS> m_tls;
+
+    volatile bool &m_ok;
+    const ipp_calcHistParallel & operator = (const ipp_calcHistParallel & );
+};
+
+static bool ipp_calchist(const Mat &image, Mat &hist, int histSize, const float** ranges, bool uniform, bool accumulate)
+{
+#if IPP_VERSION_X100 < 201801
+    // No SSE42 optimization for uniform 32f
+    if(uniform && image.depth() == CV_32F && cv::ipp::getIppTopFeatures() == ippCPUID_SSE42)
+        return false;
+#endif
+
+    // IPP_DISABLE_HISTOGRAM - https://github.com/opencv/opencv/issues/11544
+    // and https://github.com/opencv/opencv/issues/21595
+    if ((uniform && (ranges[0][1] - ranges[0][0]) != histSize) || abs(ranges[0][0]) != cvFloor(ranges[0][0]))
+        return false;
+
+    Mat ihist = hist;
+    if(accumulate)
+        ihist.create(1, &histSize, CV_32S);
+
+    bool  ok      = true;
+    int   threads = ippiSuggestThreadsNum(image.cols, image.rows, image.elemSize(), (1+((double)ihist.total()/image.total()))*2);
+    Range range(0, image.rows);
+    ipp_calcHistParallel invoker(image, ihist, histSize, ranges[0], uniform, ok);
+    if(!ok)
+        return false;
+
+    if(IPP_HISTOGRAM_PARALLEL && threads > 1)
+        parallel_for_(range, invoker, threads*2);
+    else
+        invoker(range);
+
+    if(ok)
+    {
+        if(accumulate)
+        {
+            IppiSize histRoi = ippiSize(1, histSize);
+            IppAutoBuffer<Ipp32f> fhist(histSize*sizeof(Ipp32f));
+            CV_INSTRUMENT_FUN_IPP(ippiConvert_32s32f_C1R, (Ipp32s*)ihist.ptr(), (int)ihist.step, (Ipp32f*)fhist, sizeof(Ipp32f), histRoi);
+            CV_INSTRUMENT_FUN_IPP(ippiAdd_32f_C1IR, (Ipp32f*)fhist, sizeof(Ipp32f), (Ipp32f*)hist.ptr(), (int)hist.step, histRoi);
+        }
+        else
+            CV_INSTRUMENT_FUN_IPP(ippiConvert_32s32f_C1R, (Ipp32s*)ihist.ptr(), (int)ihist.step, (Ipp32f*)hist.ptr(), (int)hist.step, ippiSize(1, histSize));
+    }
+    return ok;
+}
+
+} // namespace
+
+int ipp_hal_calcHist(const uchar* src_data, size_t src_step, int src_type, int src_width, int src_height,
+                     float* hist_data, int hist_size, const float** ranges, bool uniform, bool accumulate)
+{
+    CV_HAL_CHECK_USE_IPP();
+
+    Mat image(src_height, src_width, src_type, (void*)src_data, src_step);
+    Mat hist(1, &hist_size, CV_32F, (void*)hist_data);
+
+    if(ipp_calchist(image, hist, hist_size, ranges, uniform, accumulate))
+        return CV_HAL_ERROR_OK;
+
+    return CV_HAL_ERROR_NOT_IMPLEMENTED;
+}
+
+#endif

hal/ipp/src/precomp_ipp.hpp

@@ -120,4 +120,30 @@ static inline int ippiSuggestRowThreadsNum(const ::ipp::IwiImage &image, size_t
 }
 #endif
 
+#if IPP_VERSION_X100 >= 201700
+#define CV_IPP_MALLOC(SIZE) ippMalloc_L(SIZE)
+#else
+#define CV_IPP_MALLOC(SIZE) ippMalloc((int)SIZE)
+#endif
+
+template<typename T>
+class IppAutoBuffer
+{
+public:
+    IppAutoBuffer() { m_size = 0; m_pBuffer = NULL; }
+    explicit IppAutoBuffer(size_t size) { m_size = 0; m_pBuffer = NULL; allocate(size); }
+    ~IppAutoBuffer() { deallocate(); }
+    T* allocate(size_t size)   { if(m_size < size) { deallocate(); m_pBuffer = (T*)CV_IPP_MALLOC(size); m_size = size; } return m_pBuffer; }
+    void deallocate() { if(m_pBuffer) { ippFree(m_pBuffer); m_pBuffer = NULL; } m_size = 0; }
+    inline T* get() { return (T*)m_pBuffer;}
+    inline operator T* () { return (T*)m_pBuffer;}
+    inline operator const T* () const { return (const T*)m_pBuffer;}
+private:
+    IppAutoBuffer(IppAutoBuffer &) {}
+    IppAutoBuffer& operator =(const IppAutoBuffer &) {return *this;}
+
+    size_t m_size;
+    T*     m_pBuffer;
+};
+
 #endif //__PRECOMP_IPP_HPP__

modules/gapi/test/streaming/gapi_gstreamersource_tests.cpp

@@ -77,7 +77,7 @@ TEST_P(GStreamerSourceTest, AccuracyTest)
 
     EXPECT_FALSE(ccomp.running());
 
-    EXPECT_EQ(streamLength, framesCount);
+    EXPECT_NEAR(streamLength, framesCount, 1);
 }
 
 TEST_P(GStreamerSourceTest, TimestampsTest)
@@ -124,12 +124,12 @@ TEST_P(GStreamerSourceTest, TimestampsTest)
     EXPECT_FALSE(ccomp.running());
 
     EXPECT_EQ(0L, allSeqIds.front());
-    EXPECT_EQ(int64_t(streamLength) - 1, allSeqIds.back());
-    EXPECT_EQ(streamLength, allSeqIds.size());
+    EXPECT_NEAR(int64_t(streamLength) - 1, allSeqIds.back(), 1);
+    EXPECT_NEAR(streamLength, allSeqIds.size(), 1);
     EXPECT_TRUE(std::is_sorted(allSeqIds.begin(), allSeqIds.end()));
     EXPECT_EQ(allSeqIds.size(), std::set<int64_t>(allSeqIds.begin(), allSeqIds.end()).size());
 
-    EXPECT_EQ(streamLength, allTimestamps.size());
+    EXPECT_NEAR(streamLength, allTimestamps.size(), 1);
     EXPECT_TRUE(std::is_sorted(allTimestamps.begin(), allTimestamps.end()));
 }
 
@@ -270,7 +270,7 @@ TEST_P(GStreamerSourceTest, GFrameTest)
 
     EXPECT_FALSE(ccomp.running());
 
-    EXPECT_EQ(streamLength, framesCount);
+    EXPECT_NEAR(streamLength, framesCount, 1);
 }
 
 

modules/imgproc/src/histogram.cpp

@@ -688,152 +688,6 @@ calcHist_8u( std::vector<uchar*>& _ptrs, const std::vector<int>& _deltas,
     }
 }
 
-#ifdef HAVE_IPP
-
-typedef IppStatus(CV_STDCALL * IppiHistogram_C1)(const void* pSrc, int srcStep,
-    IppiSize roiSize, Ipp32u* pHist, const IppiHistogramSpec* pSpec, Ipp8u* pBuffer);
-
-static IppiHistogram_C1 getIppiHistogramFunction_C1(int type)
-{
-    IppiHistogram_C1 ippFunction =
-        (type == CV_8UC1) ? (IppiHistogram_C1)ippiHistogram_8u_C1R :
-        (type == CV_16UC1) ? (IppiHistogram_C1)ippiHistogram_16u_C1R :
-        (type == CV_32FC1) ? (IppiHistogram_C1)ippiHistogram_32f_C1R :
-        NULL;
-
-    return ippFunction;
-}
-
-class ipp_calcHistParallelTLS
-{
-public:
-    ipp_calcHistParallelTLS() {}
-
-    IppAutoBuffer<IppiHistogramSpec> spec;
-    IppAutoBuffer<Ipp8u>  buffer;
-    IppAutoBuffer<Ipp32u> thist;
-};
-
-class ipp_calcHistParallel: public ParallelLoopBody
-{
-public:
-    ipp_calcHistParallel(const Mat &src, Mat &hist, Ipp32s histSize, const float *ranges, bool uniform, bool &ok):
-        ParallelLoopBody(), m_src(src), m_hist(hist), m_ok(ok)
-    {
-        ok = true;
-
-        m_uniform        = uniform;
-        m_ranges         = ranges;
-        m_histSize       = histSize;
-        m_type           = ippiGetDataType(src.type());
-        m_levelsNum      = histSize+1;
-        ippiHistogram_C1 = getIppiHistogramFunction_C1(src.type());
-        m_fullRoi    = ippiSize(src.size());
-        m_bufferSize = 0;
-        m_specSize   = 0;
-        if(!ippiHistogram_C1)
-        {
-            ok = false;
-            return;
-        }
-
-        if(ippiHistogramGetBufferSize(m_type, m_fullRoi, &m_levelsNum, 1, 1, &m_specSize, &m_bufferSize) < 0)
-        {
-            ok = false;
-            return;
-        }
-
-        hist.setTo(0);
-    }
-
-    virtual void operator() (const Range & range) const CV_OVERRIDE
-    {
-        CV_INSTRUMENT_REGION_IPP();
-
-        if(!m_ok)
-            return;
-
-        ipp_calcHistParallelTLS *pTls = m_tls.get();
-
-        IppiSize roi = {m_src.cols, range.end - range.start };
-        bool     mtLoop = false;
-        if(m_fullRoi.height != roi.height)
-            mtLoop = true;
-
-        if(!pTls->spec)
-        {
-            pTls->spec.allocate(m_specSize);
-            if(!pTls->spec.get())
-            {
-                m_ok = false;
-                return;
-            }
-
-            pTls->buffer.allocate(m_bufferSize);
-            if(!pTls->buffer.get() && m_bufferSize)
-            {
-                m_ok = false;
-                return;
-            }
-
-            if(m_uniform)
-            {
-                if(ippiHistogramUniformInit(m_type, (Ipp32f*)&m_ranges[0], (Ipp32f*)&m_ranges[1], (Ipp32s*)&m_levelsNum, 1, pTls->spec) < 0)
-                {
-                    m_ok = false;
-                    return;
-                }
-            }
-            else
-            {
-                if(ippiHistogramInit(m_type, (const Ipp32f**)&m_ranges, (Ipp32s*)&m_levelsNum, 1, pTls->spec) < 0)
-                {
-                    m_ok = false;
-                    return;
-                }
-            }
-
-            pTls->thist.allocate(m_histSize*sizeof(Ipp32u));
-        }
-
-        if(CV_INSTRUMENT_FUN_IPP(ippiHistogram_C1, m_src.ptr(range.start), (int)m_src.step, roi, pTls->thist, pTls->spec, pTls->buffer) < 0)
-        {
-            m_ok = false;
-            return;
-        }
-
-        if(mtLoop)
-        {
-            for(int i = 0; i < m_histSize; i++)
-                CV_XADD((int*)(m_hist.ptr(i)), *(int*)((Ipp32u*)pTls->thist + i));
-        }
-        else
-            ippiCopy_32s_C1R((Ipp32s*)pTls->thist.get(), sizeof(Ipp32u), (Ipp32s*)m_hist.ptr(), (int)m_hist.step, ippiSize(1, m_histSize));
-    }
-
-private:
-    const Mat      &m_src;
-    Mat            &m_hist;
-    Ipp32s          m_histSize;
-    const float    *m_ranges;
-    bool            m_uniform;
-
-    IppiHistogram_C1    ippiHistogram_C1;
-    IppiSize            m_fullRoi;
-    IppDataType         m_type;
-    Ipp32s              m_levelsNum;
-    int                 m_bufferSize;
-    int                 m_specSize;
-
-    mutable Mutex                    m_syncMutex;
-    TLSData<ipp_calcHistParallelTLS> m_tls;
-
-    volatile bool &m_ok;
-    const ipp_calcHistParallel & operator = (const ipp_calcHistParallel & );
-};
-
-#endif
-
 }
 
 #ifdef HAVE_OPENVX
@@ -894,58 +748,6 @@ namespace cv
 }
 #endif
 
-#ifdef HAVE_IPP
-#define IPP_HISTOGRAM_PARALLEL 1
-namespace cv
-{
-static bool ipp_calchist(const Mat &image, Mat &hist, int histSize, const float** ranges, bool uniform, bool accumulate)
-{
-    CV_INSTRUMENT_REGION_IPP();
-
-#if IPP_VERSION_X100 < 201801
-    // No SSE42 optimization for uniform 32f
-    if(uniform && image.depth() == CV_32F && cv::ipp::getIppTopFeatures() == ippCPUID_SSE42)
-        return false;
-#endif
-
-    // IPP_DISABLE_HISTOGRAM - https://github.com/opencv/opencv/issues/11544
-    // and https://github.com/opencv/opencv/issues/21595
-    if ((uniform && (ranges[0][1] - ranges[0][0]) != histSize) || abs(ranges[0][0]) != cvFloor(ranges[0][0]))
-        return false;
-
-    Mat ihist = hist;
-    if(accumulate)
-        ihist.create(1, &histSize, CV_32S);
-
-    bool  ok      = true;
-    int   threads = ippiSuggestThreadsNum(image, (1+((double)ihist.total()/image.total()))*2);
-    Range range(0, image.rows);
-    ipp_calcHistParallel invoker(image, ihist, histSize, ranges[0], uniform, ok);
-    if(!ok)
-        return false;
-
-    if(IPP_HISTOGRAM_PARALLEL && threads > 1)
-        parallel_for_(range, invoker, threads*2);
-    else
-        invoker(range);
-
-    if(ok)
-    {
-        if(accumulate)
-        {
-            IppiSize histRoi = ippiSize(1, histSize);
-            IppAutoBuffer<Ipp32f> fhist(histSize*sizeof(Ipp32f));
-            CV_INSTRUMENT_FUN_IPP(ippiConvert_32s32f_C1R, (Ipp32s*)ihist.ptr(), (int)ihist.step, (Ipp32f*)fhist, sizeof(Ipp32f), histRoi);
-            CV_INSTRUMENT_FUN_IPP(ippiAdd_32f_C1IR, (Ipp32f*)fhist, sizeof(Ipp32f), (Ipp32f*)hist.ptr(), (int)hist.step, histRoi);
-        }
-        else
-            CV_INSTRUMENT_FUN_IPP(ippiConvert_32s32f_C1R, (Ipp32s*)ihist.ptr(), (int)ihist.step, (Ipp32f*)hist.ptr(), (int)hist.step, ippiSize(1, histSize));
-    }
-    return ok;
-}
-}
-#endif
-
 void cv::calcHist( const Mat* images, int nimages, const int* channels,
                    InputArray _mask, OutputArray _hist, int dims, const int* histSize,
                    const float** ranges, bool uniform, bool accumulate )
@@ -973,11 +775,6 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels,
     if(histdata != hist.data)
         accumulate = false;
 
-    CV_IPP_RUN(
-        nimages == 1 && dims == 1 && channels && channels[0] == 0
-            && _mask.empty() && images[0].dims <= 2 && ranges && ranges[0],
-        ipp_calchist(images[0], hist, histSize[0], ranges, uniform, accumulate));
-
     if (nimages == 1 && dims == 1 && channels && channels[0] == 0 && _mask.empty() && images[0].dims <= 2 && ranges && ranges[0]) {
         CALL_HAL(calcHist, cv_hal_calcHist, images[0].data, images[0].step, images[0].type(), images[0].cols, images[0].rows,
                                             hist.ptr<float>(), histSize[0], ranges, uniform, accumulate);

samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp

@@ -30,6 +30,12 @@ int main( int argc, char** argv )
       cout << "Usage: " << argv[0] << " <Input image>" << endl;
       return -1;
     }
+    if (image.channels() != 3)
+    {
+        cout << "The tutorial expects 3 channel image as input!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
     //! [basic-linear-transform-load]
 
     //! [basic-linear-transform-output]
@@ -54,7 +60,7 @@ int main( int argc, char** argv )
     //! [basic-linear-transform-operation]
     for( int y = 0; y < image.rows; y++ ) {
         for( int x = 0; x < image.cols; x++ ) {
-            for( int c = 0; c < image.channels(); c++ ) {
+            for( int c = 0; c < 3; c++ ) {
                 new_image.at<Vec3b>(y,x)[c] =
                   saturate_cast<uchar>( alpha*image.at<Vec3b>(y,x)[c] + beta );
             }