Merge branch '2.4'

android/service/engine/src/org/opencv/engine/BinderConnector.java

@@ -4,23 +4,43 @@ import android.os.IBinder;
 
 public class BinderConnector
 {
-    public BinderConnector(MarketConnector Market)
-    {
-        Init(Market);
+    public BinderConnector(MarketConnector Market) {
+        mMarket = Market;
+    }
+
+    public boolean Init() {
+        boolean result = false;
+        if (mIsReady)
+            result = Init(mMarket);
+
+        return result;
     }
+
     public native IBinder Connect();
+
     public boolean Disconnect()
     {
-        Final();
-        return true;
-    }
+        if (mIsReady)
+            Final();
 
-    static
-    {
-        System.loadLibrary("OpenCVEngine");
-        System.loadLibrary("OpenCVEngine_jni");
+        return mIsReady;
     }
 
     private native boolean Init(MarketConnector Market);
-    public native void Final();
+    private native void Final();
+    private static boolean mIsReady = false;
+    private MarketConnector mMarket;
+
+    static {
+        try {
+            System.loadLibrary("OpenCVEngine");
+            System.loadLibrary("OpenCVEngine_jni");
+            mIsReady = true;
+        }
+        catch(UnsatisfiedLinkError e) {
+            mIsReady = false;
+            e.printStackTrace();
+        }
+    }
+
 }

android/service/engine/src/org/opencv/engine/HardwareDetector.java

@@ -47,9 +47,17 @@ public class HardwareDetector
 
     public static native int DetectKnownPlatforms();
 
-    static
-    {
-        System.loadLibrary("OpenCVEngine");
-        System.loadLibrary("OpenCVEngine_jni");
+    public static boolean mIsReady = false;
+
+    static {
+        try {
+            System.loadLibrary("OpenCVEngine");
+            System.loadLibrary("OpenCVEngine_jni");
+            mIsReady = true;
+        }
+        catch(UnsatisfiedLinkError e) {
+            mIsReady = false;
+            e.printStackTrace();
+        }
     }
 }

android/service/engine/src/org/opencv/engine/OpenCVEngineService.java

@@ -3,31 +3,62 @@ package org.opencv.engine;
 import android.app.Service;
 import android.content.Intent;
 import android.os.IBinder;
+import android.os.RemoteException;
 import android.util.Log;
 
-
 public class OpenCVEngineService extends Service
 {
     private static final String TAG = "OpenCVEngine/Service";
-    private IBinder mEngineInterface;
+    private IBinder mEngineInterface = null;
     private MarketConnector mMarket;
     private BinderConnector mNativeBinder;
-    public void onCreate()
-    {
+
+    public void onCreate() {
         Log.i(TAG, "Service starting");
         super.onCreate();
         Log.i(TAG, "Engine binder component creating");
         mMarket = new MarketConnector(getBaseContext());
         mNativeBinder = new BinderConnector(mMarket);
-        mEngineInterface = mNativeBinder.Connect();
-        Log.i(TAG, "Service started successfully");
+        if (mNativeBinder.Init()) {
+            mEngineInterface = mNativeBinder.Connect();
+            Log.i(TAG, "Service started successfully");
+        } else {
+            Log.e(TAG, "Cannot initialize native part of OpenCV Manager!");
+            Log.e(TAG, "Using stub instead");
+
+            mEngineInterface = new OpenCVEngineInterface.Stub() {
+
+                @Override
+                public boolean installVersion(String version) throws RemoteException {
+                    // TODO Auto-generated method stub
+                    return false;
+                }
+
+                @Override
+                public String getLibraryList(String version) throws RemoteException {
+                    // TODO Auto-generated method stub
+                    return null;
+                }
+
+                @Override
+                public String getLibPathByVersion(String version) throws RemoteException {
+                    // TODO Auto-generated method stub
+                    return null;
+                }
+
+                @Override
+                public int getEngineVersion() throws RemoteException {
+                    return -1;
+                }
+            };
+        }
     }
 
-    public IBinder onBind(Intent intent)
-    {
+    public IBinder onBind(Intent intent) {
         Log.i(TAG, "Service onBind called for intent " + intent.toString());
         return mEngineInterface;
     }
+
     public boolean onUnbind(Intent intent)
     {
         Log.i(TAG, "Service onUnbind called for intent " + intent.toString());

android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java

@@ -42,6 +42,26 @@ public class ManagerActivity extends Activity
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+
+        if (!HardwareDetector.mIsReady) {
+            Log.e(TAG, "Cannot initialize native part of OpenCV Manager!");
+
+            AlertDialog dialog = new AlertDialog.Builder(this).create();
+
+            dialog.setTitle("OpenCV Manager Error");
+            dialog.setMessage("OpenCV Manager is incompatible with this device. Please replace it with an appropriate package.");
+            dialog.setCancelable(false);
+            dialog.setButton("OK", new DialogInterface.OnClickListener() {
+
+                public void onClick(DialogInterface dialog, int which) {
+                    finish();
+                }
+            });
+
+            dialog.show();
+            return;
+        }
+
         setContentView(R.layout.main);
 
         TextView OsVersionView = (TextView)findViewById(R.id.OsVersionValue);
@@ -186,6 +206,20 @@ public class ManagerActivity extends Activity
             }
         });
 
+        mPackageChangeReciever = new BroadcastReceiver() {
+
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                Log.d("OpenCVManager/Reciever", "Bradcast message " + intent.getAction() + " reciever");
+                Log.d("OpenCVManager/Reciever", "Filling package list on broadcast message");
+                if (!bindService(new Intent("org.opencv.engine.BIND"), new OpenCVEngineServiceConnection(), Context.BIND_AUTO_CREATE))
+                {
+                    TextView EngineVersionView = (TextView)findViewById(R.id.EngineVersionValue);
+                    EngineVersionView.setText("not avaliable");
+                }
+            }
+        };
+
         IntentFilter filter = new IntentFilter();
         filter.addAction(Intent.ACTION_PACKAGE_ADDED);
         filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
@@ -199,17 +233,23 @@ public class ManagerActivity extends Activity
     @Override
     protected void onDestroy() {
         super.onDestroy();
-        unregisterReceiver(mPackageChangeReciever);
+        if (mPackageChangeReciever != null)
+            unregisterReceiver(mPackageChangeReciever);
     }
 
     @Override
     protected void onResume() {
         super.onResume();
-        Log.d(TAG, "Filling package list on resume");
-        if (!bindService(new Intent("org.opencv.engine.BIND"), new OpenCVEngineServiceConnection(), Context.BIND_AUTO_CREATE))
-        {
-            TextView EngineVersionView = (TextView)findViewById(R.id.EngineVersionValue);
-            EngineVersionView.setText("not avaliable");
+        if (HardwareDetector.mIsReady) {
+            Log.d(TAG, "Filling package list on resume");
+            OpenCVEngineServiceConnection connection = new OpenCVEngineServiceConnection();
+            if (!bindService(new Intent("org.opencv.engine.BIND"), connection, Context.BIND_AUTO_CREATE)) {
+                Log.e(TAG, "Cannot bind to OpenCV Manager service!");
+                TextView EngineVersionView = (TextView)findViewById(R.id.EngineVersionValue);
+                if (EngineVersionView != null)
+                    EngineVersionView.setText("not avaliable");
+                unbindService(connection);
+            }
         }
     }
 
@@ -225,19 +265,7 @@ public class ManagerActivity extends Activity
     protected int ManagerApiLevel = 0;
     protected String ManagerVersion;
 
-    protected BroadcastReceiver mPackageChangeReciever = new BroadcastReceiver() {
-
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            Log.d("OpenCVManager/Reciever", "Bradcast message " + intent.getAction() + " reciever");
-            Log.d("OpenCVManager/Reciever", "Filling package list on broadcast message");
-            if (!bindService(new Intent("org.opencv.engine.BIND"), new OpenCVEngineServiceConnection(), Context.BIND_AUTO_CREATE))
-            {
-                TextView EngineVersionView = (TextView)findViewById(R.id.EngineVersionValue);
-                EngineVersionView.setText("not avaliable");
-            }
-        }
-    };
+    protected BroadcastReceiver mPackageChangeReciever = null;
 
     protected class OpenCVEngineServiceConnection implements ServiceConnection
     {
@@ -246,6 +274,12 @@ public class ManagerActivity extends Activity
 
         public void onServiceConnected(ComponentName name, IBinder service) {
             OpenCVEngineInterface EngineService = OpenCVEngineInterface.Stub.asInterface(service);
+            if (EngineService == null) {
+                Log.e(TAG, "Cannot connect to OpenCV Manager Service!");
+                unbindService(this);
+                return;
+            }
+
             try {
                 ManagerApiLevel = EngineService.getEngineVersion();
             } catch (RemoteException e) {

cmake/OpenCVDetectCXXCompiler.cmake

@@ -27,23 +27,23 @@ endif()
 #  the -fPIC flag should be used.
 # ----------------------------------------------------------------------------
 if(UNIX)
-    if  (__ICL)
-        set(CV_ICC   __ICL)
-    elseif(__ICC)
-        set(CV_ICC   __ICC)
-    elseif(__ECL)
-        set(CV_ICC   __ECL)
-    elseif(__ECC)
-        set(CV_ICC   __ECC)
-    elseif(__INTEL_COMPILER)
-        set(CV_ICC   __INTEL_COMPILER)
-    elseif(CMAKE_C_COMPILER MATCHES "icc")
-        set(CV_ICC   icc_matches_c_compiler)
-    endif()
+  if  (__ICL)
+    set(CV_ICC   __ICL)
+  elseif(__ICC)
+    set(CV_ICC   __ICC)
+  elseif(__ECL)
+    set(CV_ICC   __ECL)
+  elseif(__ECC)
+    set(CV_ICC   __ECC)
+  elseif(__INTEL_COMPILER)
+    set(CV_ICC   __INTEL_COMPILER)
+  elseif(CMAKE_C_COMPILER MATCHES "icc")
+    set(CV_ICC   icc_matches_c_compiler)
+  endif()
 endif()
 
 if(MSVC AND CMAKE_C_COMPILER MATCHES "icc")
-    set(CV_ICC   __INTEL_COMPILER_FOR_WINDOWS)
+  set(CV_ICC   __INTEL_COMPILER_FOR_WINDOWS)
 endif()
 
 # ----------------------------------------------------------------------------
@@ -64,45 +64,49 @@ if(CMAKE_COMPILER_IS_CLANGCXX)
   string(REGEX MATCH "[0-9]+\\.[0-9]+" CMAKE_CLANG_REGEX_VERSION "${CMAKE_OPENCV_CLANG_VERSION_FULL}")
 
 elseif(CMAKE_COMPILER_IS_GNUCXX)
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
-                  OUTPUT_VARIABLE CMAKE_OPENCV_GCC_VERSION_FULL
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
+                OUTPUT_VARIABLE CMAKE_OPENCV_GCC_VERSION_FULL
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
 
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} -v
-                  ERROR_VARIABLE CMAKE_OPENCV_GCC_INFO_FULL
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} -v
+                ERROR_VARIABLE CMAKE_OPENCV_GCC_INFO_FULL
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
 
-    # Typical output in CMAKE_OPENCV_GCC_VERSION_FULL: "c+//0 (whatever) 4.2.3 (...)"
-    # Look for the version number
-    string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" CMAKE_GCC_REGEX_VERSION "${CMAKE_OPENCV_GCC_VERSION_FULL}")
-    if(NOT CMAKE_GCC_REGEX_VERSION)
-      string(REGEX MATCH "[0-9]+\\.[0-9]+" CMAKE_GCC_REGEX_VERSION "${CMAKE_OPENCV_GCC_VERSION_FULL}")
-    endif()
+  # Typical output in CMAKE_OPENCV_GCC_VERSION_FULL: "c+//0 (whatever) 4.2.3 (...)"
+  # Look for the version number
+  string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" CMAKE_GCC_REGEX_VERSION "${CMAKE_OPENCV_GCC_VERSION_FULL}")
+  if(NOT CMAKE_GCC_REGEX_VERSION)
+    string(REGEX MATCH "[0-9]+\\.[0-9]+" CMAKE_GCC_REGEX_VERSION "${CMAKE_OPENCV_GCC_VERSION_FULL}")
+  endif()
 
-    # Split the three parts:
-    string(REGEX MATCHALL "[0-9]+" CMAKE_OPENCV_GCC_VERSIONS "${CMAKE_GCC_REGEX_VERSION}")
+  # Split the three parts:
+  string(REGEX MATCHALL "[0-9]+" CMAKE_OPENCV_GCC_VERSIONS "${CMAKE_GCC_REGEX_VERSION}")
 
-    list(GET CMAKE_OPENCV_GCC_VERSIONS 0 CMAKE_OPENCV_GCC_VERSION_MAJOR)
-    list(GET CMAKE_OPENCV_GCC_VERSIONS 1 CMAKE_OPENCV_GCC_VERSION_MINOR)
+  list(GET CMAKE_OPENCV_GCC_VERSIONS 0 CMAKE_OPENCV_GCC_VERSION_MAJOR)
+  list(GET CMAKE_OPENCV_GCC_VERSIONS 1 CMAKE_OPENCV_GCC_VERSION_MINOR)
 
-    set(CMAKE_OPENCV_GCC_VERSION ${CMAKE_OPENCV_GCC_VERSION_MAJOR}${CMAKE_OPENCV_GCC_VERSION_MINOR})
-    math(EXPR CMAKE_OPENCV_GCC_VERSION_NUM "${CMAKE_OPENCV_GCC_VERSION_MAJOR}*100 + ${CMAKE_OPENCV_GCC_VERSION_MINOR}")
-    message(STATUS "Detected version of GNU GCC: ${CMAKE_OPENCV_GCC_VERSION} (${CMAKE_OPENCV_GCC_VERSION_NUM})")
+  set(CMAKE_OPENCV_GCC_VERSION ${CMAKE_OPENCV_GCC_VERSION_MAJOR}${CMAKE_OPENCV_GCC_VERSION_MINOR})
+  math(EXPR CMAKE_OPENCV_GCC_VERSION_NUM "${CMAKE_OPENCV_GCC_VERSION_MAJOR}*100 + ${CMAKE_OPENCV_GCC_VERSION_MINOR}")
+  message(STATUS "Detected version of GNU GCC: ${CMAKE_OPENCV_GCC_VERSION} (${CMAKE_OPENCV_GCC_VERSION_NUM})")
 
-    if(WIN32)
-        execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpmachine
-                  OUTPUT_VARIABLE CMAKE_OPENCV_GCC_TARGET_MACHINE
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
-        if(CMAKE_OPENCV_GCC_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64")
-            set(MINGW64 1)
-        endif()
+  if(WIN32)
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpmachine
+              OUTPUT_VARIABLE CMAKE_OPENCV_GCC_TARGET_MACHINE
+              OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(CMAKE_OPENCV_GCC_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64")
+      set(MINGW64 1)
     endif()
+  endif()
 endif()
 
-if(MINGW64 OR CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*" OR CMAKE_GENERATOR MATCHES "Visual Studio.*Win64")
-    set(X86_64 1)
+if(MSVC64 OR MINGW64)
+  set(X86_64 1)
+elseif(MSVC AND NOT CMAKE_CROSSCOMPILING)
+  set(X86 1)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
+  set(X86_64 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*|amd64.*|AMD64.*")
-    set(X86 1)
+  set(X86 1)
 elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "arm.*|ARM.*")
-    set(ARM 1)
+  set(ARM 1)
 endif()

cmake/OpenCVDetectOpenCL.cmake

@@ -4,7 +4,7 @@ if(APPLE)
   set(OPENCL_INCLUDE_DIR "" CACHE STRING "OpenCL include directory")
   mark_as_advanced(OPENCL_INCLUDE_DIR OPENCL_LIBRARY)
 else(APPLE)
-  find_package(OpenCL QUIET)
+  #find_package(OpenCL QUIET)
 
   if (NOT OPENCL_FOUND)
     find_path(OPENCL_ROOT_DIR

doc/check_docs.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import sys, glob
 

doc/check_docs2.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import os, sys, fnmatch, re
 

doc/conf.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 # -*- coding: utf-8 -*-
 #

doc/ocv.py

-#/usr/bin/env python
+#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """
     ocv domain, a modified copy of sphinx.domains.cpp + shpinx.domains.python.

doc/patch_refman_latex.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import sys
 

doc/pattern_tools/gen_pattern.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 """gen_pattern.py
 To run:

doc/pattern_tools/svgfig.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 # svgfig.py copyright (C) 2008 Jim Pivarski <jpivarski@gmail.com>
 #

doc/reformat.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import os, sys, re
 

modules/contrib/doc/facerec/src/create_csv.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import sys
 import os.path

modules/core/test/test_io.cpp

@@ -455,7 +455,7 @@ protected:
 TEST(Core_InputOutput, huge) { CV_BigMatrixIOTest test; test.safe_run(); }
 */
 
-TEST(Core_globbing, accurasy)
+TEST(Core_globbing, accuracy)
 {
     std::string patternLena    = cvtest::TS::ptr()->get_data_path() + "lena*.*";
     std::string patternLenaPng = cvtest::TS::ptr()->get_data_path() + "lena.png";

modules/gpu/misc/mark_nvidia.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import sys, re
 

modules/highgui/src/cap_v4l.cpp

@@ -154,6 +154,11 @@ the symptoms were damaged image and 'Corrupt JPEG data: premature end of data se
 - USE_TEMP_BUFFER fixes the main problem (improper buffer management) and
   prevents bad images in the first place
 
+11th patch: April 2, 2013, Forrest Reiling forrest.reiling@gmail.com
+Added v4l2 support for getting capture property CV_CAP_PROP_POS_MSEC.
+Returns the millisecond timestamp of the last frame grabbed or 0 if no frames have been grabbed
+Used to successfully synchonize 2 Logitech C310 USB webcams to within 16 ms of one another
+
 
 make & enjoy!
 
@@ -320,6 +325,8 @@ typedef struct CvCaptureCAM_V4L
    struct v4l2_queryctrl queryctrl;
    struct v4l2_querymenu querymenu;
 
+   struct timeval timestamp;
+
    /* V4L2 control variables */
    int v4l2_brightness, v4l2_brightness_min, v4l2_brightness_max;
    int v4l2_contrast, v4l2_contrast_min, v4l2_contrast_max;
@@ -836,6 +843,9 @@ static int _capture_V4L2 (CvCaptureCAM_V4L *capture, char *deviceName)
    capture->v4l2_gain_max = 0;
    capture->v4l2_exposure_max = 0;
 
+   capture->timestamp.tv_sec = 0;
+   capture->timestamp.tv_usec = 0;
+
    /* Scan V4L2 controls */
    v4l2_scan_controls(capture);
 
@@ -1221,6 +1231,9 @@ static int read_frame_v4l2(CvCaptureCAM_V4L* capture) {
    if (-1 == ioctl (capture->deviceHandle, VIDIOC_QBUF, &buf))
        perror ("VIDIOC_QBUF");
 
+   //set timestamp in capture struct to be timestamp of most recent frame
+   capture->timestamp = buf.timestamp;
+
    return 1;
 }
 
@@ -2308,6 +2321,13 @@ static double icvGetPropertyCAM_V4L (CvCaptureCAM_V4L* capture,
       /* initialize the control structure */
 
       switch (property_id) {
+      case CV_CAP_PROP_POS_MSEC:
+          if (capture->FirstCapture) {
+            return 0;
+          } else {
+            return 1000 * capture->timestamp.tv_sec + ((double) capture->timestamp.tv_usec) / 1000;
+          }
+          break;
       case CV_CAP_PROP_BRIGHTNESS:
           capture->control.id = V4L2_CID_BRIGHTNESS;
           break;

modules/java/check-tests.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import sys, os, re
 

modules/java/generator/gen_java.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import sys, re, os.path
 from string import Template

modules/java/generator/gen_javadoc.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import os, sys, re, string, glob
 from optparse import OptionParser

modules/java/generator/rst_parser.py

-#/usr/bin/env python
+#!/usr/bin/env python
 
 import os, sys, re, string, fnmatch
 allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "java", "python", "stitching", "ts", "photo", "nonfree", "videostab", "ocl", "softcascade", "superres"]

modules/nonfree/src/surf.ocl.cpp

@@ -76,7 +76,7 @@ namespace cv
 
                 size_t wave_size = 0;
                 queryDeviceInfo(WAVEFRONT_SIZE, &wave_size);
-                std::sprintf(pSURF_OPTIONS, " -D WAVE_SIZE=%d", static_cast<int>(wave_size));
+                std::sprintf(pSURF_OPTIONS, "-D WAVE_SIZE=%d", static_cast<int>(wave_size));
                 OPTION_INIT = true;
             }
             openCLExecuteKernel(clCxt, source, kernelName, globalThreads, localThreads, args, channels, depth, SURF_OPTIONS);

modules/ocl/include/opencv2/ocl/private/util.hpp

@@ -127,8 +127,9 @@ namespace cv
         // currently only support wavefront size queries
         enum DEVICE_INFO
         {
-             WAVEFRONT_SIZE,            //in AMD speak
-             WARP_SIZE = WAVEFRONT_SIZE //in nvidia speak
+            WAVEFRONT_SIZE,             //in AMD speak
+            WARP_SIZE = WAVEFRONT_SIZE, //in nvidia speak
+            IS_CPU_DEVICE               //check if the device is CPU
         };
         //info should have been pre-allocated
         void CV_EXPORTS queryDeviceInfo(DEVICE_INFO info_type, void* info);

modules/ocl/src/arithm.cpp

@@ -91,9 +91,6 @@ namespace cv
         extern const char *arithm_bitwise_xor_scalar_mask;
         extern const char *arithm_compare_eq;
         extern const char *arithm_compare_ne;
-        extern const char *arithm_sub;
-        extern const char *arithm_sub_scalar;
-        extern const char *arithm_sub_scalar_mask;
         extern const char *arithm_mul;
         extern const char *arithm_div;
         extern const char *arithm_absdiff;
@@ -260,11 +257,11 @@ void cv::ocl::add(const oclMat &src1, const oclMat &src2, oclMat &dst, const ocl
 
 void cv::ocl::subtract(const oclMat &src1, const oclMat &src2, oclMat &dst)
 {
-    arithmetic_run(src1, src2, dst, "arithm_sub", &arithm_sub);
+    arithmetic_run(src1, src2, dst, "arithm_add", &arithm_add);
 }
 void cv::ocl::subtract(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask)
 {
-    arithmetic_run(src1, src2, dst, mask, "arithm_sub_with_mask", &arithm_sub);
+    arithmetic_run(src1, src2, dst, mask, "arithm_add_with_mask", &arithm_add);
 }
 typedef void (*MulDivFunc)(const oclMat &src1, const oclMat &src2, oclMat &dst, String kernelName,
                            const char **kernelString, void *scalar);
@@ -451,14 +448,16 @@ void cv::ocl::add(const oclMat &src1, const Scalar &src2, oclMat &dst, const ocl
 
 void cv::ocl::subtract(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask)
 {
-    String kernelName = mask.data ? "arithm_s_sub_with_mask" : "arithm_s_sub";
-    const char **kernelString = mask.data ? &arithm_sub_scalar_mask : &arithm_sub_scalar;
+    String kernelName = mask.data ? "arithm_s_add_with_mask" : "arithm_s_add";
+    const char **kernelString = mask.data ? &arithm_add_scalar_mask : &arithm_add_scalar;
+
     arithmetic_scalar( src1, src2, dst, mask, kernelName, kernelString, 1);
 }
 void cv::ocl::subtract(const Scalar &src2, const oclMat &src1, oclMat &dst, const oclMat &mask)
 {
-    String kernelName = mask.data ? "arithm_s_sub_with_mask" : "arithm_s_sub";
-    const char **kernelString = mask.data ? &arithm_sub_scalar_mask : &arithm_sub_scalar;
+    String kernelName = mask.data ? "arithm_s_add_with_mask" : "arithm_s_add";
+    const char **kernelString = mask.data ? &arithm_add_scalar_mask : &arithm_add_scalar;
+
     arithmetic_scalar( src1, src2, dst, mask, kernelName, kernelString, -1);
 }
 void cv::ocl::divide(double scalar, const oclMat &src,  oclMat &dst)

modules/ocl/src/initialization.cpp

@@ -394,6 +394,15 @@ namespace cv
 
                 }
                 break;
+            case IS_CPU_DEVICE:
+                {
+                    cl_device_type devicetype;
+                    openCLSafeCall(clGetDeviceInfo(impl->devices[impl->devnum],
+                                    CL_DEVICE_TYPE, sizeof(cl_device_type),
+                                    &devicetype, NULL));
+                    *(bool*)info = (devicetype == CVCL_DEVICE_TYPE_CPU);
+                }
+                break;
             default:
                 CV_Error(-1, "Invalid device info type");
                 break;

modules/ocl/src/matrix_operations.cpp

@@ -393,7 +393,7 @@ void cv::ocl::oclMat::convertTo( oclMat &dst, int rtype, double alpha, double be
     if( rtype < 0 )
         rtype = type();
     else
-        rtype = CV_MAKETYPE(CV_MAT_DEPTH(rtype), channels());
+        rtype = CV_MAKETYPE(CV_MAT_DEPTH(rtype), oclchannels());
 
     //int scn = channels();
     int sdepth = depth(), ddepth = CV_MAT_DEPTH(rtype);

modules/ocl/src/opencl/arithm_flip.cl

@@ -330,16 +330,14 @@ __kernel void arithm_flip_cols_C1_D0 (__global uchar *src, int src_step, int src
     if (x < thread_cols && y < rows)
     {
         int src_index_0 = mad24(y, src_step, (x)           + src_offset);
-        int src_index_1 = mad24(y, src_step, (cols - x -1) + src_offset);
-
-        int dst_index_0 = mad24(y, dst_step, (x)           + dst_offset);
         int dst_index_1 = mad24(y, dst_step, (cols - x -1) + dst_offset);
-
         uchar data0 = *(src + src_index_0);
-        uchar data1 = *(src + src_index_1);
+        *(dst + dst_index_1) = data0;
 
+        int src_index_1 = mad24(y, src_step, (cols - x -1) + src_offset);
+        int dst_index_0 = mad24(y, dst_step, (x)           + dst_offset);
+        uchar data1 = *(src + src_index_1);
         *(dst + dst_index_0) = data1;
-        *(dst + dst_index_1) = data0;
     }
 }
 __kernel void arithm_flip_cols_C1_D1 (__global char *src, int src_step, int src_offset,

modules/ocl/src/opencl/imgproc_integral.cl

@@ -44,7 +44,11 @@
 //M*/
 
 #if defined (DOUBLE_SUPPORT)
+#ifdef cl_khr_fp64
 #pragma OPENCL EXTENSION cl_khr_fp64:enable
+#elif defined (cl_amd_fp64)
+#pragma OPENCL EXTENSION cl_amd_fp64:enable
+#endif
 #endif
 #define LSIZE 256
 #define LSIZE_1 255
@@ -71,13 +75,13 @@ kernel void integral_cols(__global uchar4 *src,__global int *sum ,__global float
     gid = gid << 1;
     for(int i = 0; i < rows; i =i + LSIZE_1)
     {
-        src_t[0] = (i + lid < rows ? convert_int4(src[src_offset + (lid+i) * src_step + gid]) : 0);
-        src_t[1] = (i + lid < rows ? convert_int4(src[src_offset + (lid+i) * src_step + gid + 1]) : 0);
+        src_t[0] = (i + lid < rows ? convert_int4(src[src_offset + (lid+i) * src_step + min(gid, (uint)cols - 1)]) : 0);
+        src_t[1] = (i + lid < rows ? convert_int4(src[src_offset + (lid+i) * src_step + min(gid + 1, (uint)cols - 1)]) : 0);
 
         sum_t[0] = (i == 0 ? 0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]);
-        sqsum_t[0] = (i == 0 ? 0 : lm_sqsum[0][LSIZE_2 + LOG_LSIZE]);
+        sqsum_t[0] = (i == 0 ? (float4)0 : lm_sqsum[0][LSIZE_2 + LOG_LSIZE]);
         sum_t[1] =  (i == 0 ? 0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]);
-        sqsum_t[1] =  (i == 0 ? 0 : lm_sqsum[1][LSIZE_2 + LOG_LSIZE]);
+        sqsum_t[1] =  (i == 0 ? (float4)0 : lm_sqsum[1][LSIZE_2 + LOG_LSIZE]);
         barrier(CLK_LOCAL_MEM_FENCE);
 
         int bf_loc = lid + GET_CONFLICT_OFFSET(lid);
@@ -127,7 +131,8 @@ kernel void integral_cols(__global uchar4 *src,__global int *sum ,__global float
         }
         barrier(CLK_LOCAL_MEM_FENCE);
         int loc_s0 = gid * dst_step + i + lid - 1 - pre_invalid * dst_step / 4, loc_s1 = loc_s0 + dst_step ;
-        if(lid > 0 && (i+lid) <= rows){
+        if(lid > 0 && (i+lid) <= rows)
+        {
             lm_sum[0][bf_loc] += sum_t[0];
             lm_sum[1][bf_loc] += sum_t[1];
             lm_sqsum[0][bf_loc] += sqsum_t[0];
@@ -169,15 +174,15 @@ kernel void integral_rows(__global int4 *srcsum,__global float4 * srcsqsum,__glo
     src_step = src_step >> 4;
     for(int i = 0; i < rows; i =i + LSIZE_1)
     {
-        src_t[0] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2] : 0;
-        sqsrc_t[0] = i + lid < rows ? srcsqsum[(lid+i) * src_step + gid * 2] : 0;
-        src_t[1] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2 + 1] : 0;
-        sqsrc_t[1] = i + lid < rows ? srcsqsum[(lid+i) * src_step + gid * 2 + 1] : 0;
+        src_t[0] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2] : (int4)0;
+        sqsrc_t[0] = i + lid < rows ? srcsqsum[(lid+i) * src_step + gid * 2] : (float4)0;
+        src_t[1] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2 + 1] : (int4)0;
+        sqsrc_t[1] = i + lid < rows ? srcsqsum[(lid+i) * src_step + gid * 2 + 1] : (float4)0;
 
         sum_t[0] =  (i == 0 ? 0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]);
-        sqsum_t[0] =  (i == 0 ? 0 : lm_sqsum[0][LSIZE_2 + LOG_LSIZE]);
+        sqsum_t[0] =  (i == 0 ? (float4)0 : lm_sqsum[0][LSIZE_2 + LOG_LSIZE]);
         sum_t[1] =  (i == 0 ? 0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]);
-        sqsum_t[1] =  (i == 0 ? 0 : lm_sqsum[1][LSIZE_2 + LOG_LSIZE]);
+        sqsum_t[1] =  (i == 0 ? (float4)0 : lm_sqsum[1][LSIZE_2 + LOG_LSIZE]);
         barrier(CLK_LOCAL_MEM_FENCE);
 
         int bf_loc = lid + GET_CONFLICT_OFFSET(lid);
@@ -228,14 +233,14 @@ kernel void integral_rows(__global int4 *srcsum,__global float4 * srcsqsum,__glo
         barrier(CLK_LOCAL_MEM_FENCE);
         if(gid == 0 && (i + lid) <= rows)
         {
-           sum[sum_offset + i + lid] = 0;
-           sqsum[sqsum_offset + i + lid] = 0;
+            sum[sum_offset + i + lid] = 0;
+            sqsum[sqsum_offset + i + lid] = 0;
         }
         if(i + lid == 0)
         {
             int loc0 = gid * 2 * sum_step;
             int loc1 = gid * 2 * sqsum_step;
-            for(int k = 1;k <= 8;k++)
+            for(int k = 1; k <= 8; k++)
             {
                 if(gid * 8 + k > cols) break;
                 sum[sum_offset + loc0 + k * sum_step / 4] = 0;
@@ -244,7 +249,8 @@ kernel void integral_rows(__global int4 *srcsum,__global float4 * srcsqsum,__glo
         }
         int loc_s0 = sum_offset + gid * 2 * sum_step + sum_step / 4 + i + lid, loc_s1 = loc_s0 + sum_step ;
         int loc_sq0 = sqsum_offset + gid * 2 * sqsum_step + sqsum_step / 4 + i + lid, loc_sq1 = loc_sq0 + sqsum_step ;
-        if(lid > 0 && (i+lid) <= rows){
+        if(lid > 0 && (i+lid) <= rows)
+        {
             lm_sum[0][bf_loc] += sum_t[0];
             lm_sum[1][bf_loc] += sum_t[1];
             lm_sqsum[0][bf_loc] += sqsum_t[0];

modules/ocl/src/opencl/match_template.cl

@@ -447,10 +447,10 @@ void matchTemplate_Naive_CCORR_C1_D0
             __global const uchar * tpl_ptr = tpl + mad24(i, tpl_step, tpl_offset);
             for(j = 0; j < tpl_cols; j ++)
             {
-                sum = mad24(img_ptr[j], tpl_ptr[j], sum);
+                sum = mad24(convert_int(img_ptr[j]), convert_int(tpl_ptr[j]), sum);
             }
         }
-        res[res_idx] = sum;
+        res[res_idx] = (float)sum;
     }
 }
 
@@ -548,7 +548,7 @@ void matchTemplate_Naive_CCORR_C4_D0
                 sum   = mad24(convert_int4(img_ptr[j]), convert_int4(tpl_ptr[j]), sum);
             }
         }
-        res[res_idx] = sum.x + sum.y + sum.z + sum.w;
+        res[res_idx] = (float)(sum.x + sum.y + sum.z + sum.w);
     }
 }
 
@@ -633,9 +633,8 @@ void matchTemplate_Prepared_CCOFF_C1_D0
 
     if(gidx < res_cols && gidy < res_rows)
     {
-        float sum = (float)(
-                        (img_sums[SUMS_PTR(tpl_cols, tpl_rows)] - img_sums[SUMS_PTR(tpl_cols, 0)])
-                        - (img_sums[SUMS_PTR(0, tpl_rows)] - img_sums[SUMS_PTR(0, 0)]));
+        float sum = (float)((img_sums[SUMS_PTR(tpl_cols, tpl_rows)] - img_sums[SUMS_PTR(tpl_cols, 0)])
+                            -(img_sums[SUMS_PTR(0, tpl_rows)] - img_sums[SUMS_PTR(0, 0)]));
         res[res_idx] -= sum * tpl_sum;
     }
 }