在基于 Android 相机预览的 CV 应用程序中使用 OpenCL

?
公共类 Tutorial4Activity 扩展 Activity {
私人MyGLSurfaceView mView;
@Override
public void onCreate（Bundle savedInstanceState） {
super.onCreate（savedInstanceState）;
requestWindowFeature（Window.FEATURE_NO_TITLE）;
getWindow（）.setFlags（WindowManager.LayoutParams.FLAG_FULLSCREEN，
WindowManager.LayoutParams.FLAG_FULLSCREEN）;
getWindow（）.setFlags（WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON，
WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON）;
setRequestedOrientation（ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE）;
mView = 新的 MyGLSurfaceView（这个);
setContentView（mView）;
}
@Override
受保护的无效 onPause（） {
mView.onPause（）;
super.onPause（）;
}
@Override
受保护的无效 onResume（） {
super.onResume（）;
mView.onResume（）;
}
}
和最小类：View

public class MyGLSurfaceView 扩展了 CameraGLSurfaceView 实现 CameraGLSurfaceView.CameraTextureListener {
static final String LOGTAG = “MyGLSurfaceView”;
受保护的 int procMode = NativePart.PROCESSING_MODE_NO_PROCESSING;
static final String[] procModeName = new String[] {“无处理”， “CPU”， “OpenCL Direct”， “OpenCL via OpenCV” };
受保护的 int frameCounter;
保护时间长NanoTime;
TextView mFpsText = 空;
公共MyGLSurfaceView（上下文，属性集属性）{
super（上下文，属性）;
}
@Override
公共布尔值 onTouchEvent（MotionEvent e） {
if（e.getAction（） == MotionEvent.ACTION_DOWN）
（（活动）getContext（））.openOptionsMenu（）;
返回 true;
}
@Override
公共空隙 surfaceCreated（SurfaceHolder holder） {
super.surfaceCreated（持有人）;
NativePart.initCL（）;
}
@Override
public void surfaceDestroyed（SurfaceHolder holder） {
NativePart.closeCL（）;
super.surfaceDestroyed（持有人）;
}
公共无效 setProcessingMode（int newMode） {
if（newMode>=0 && newMode<procModeName.length）
procMode = 新模式;
还
Log.e（LOGTAG， “忽略无效的处理模式： ” + newMode）;
（（活动） getContext（））.runOnUiThread（new Runnable（） {
公共无效运行（） {
Toast.makeText（getContext（）， “选择模式： ” + procModeName[procMode]， Toast.LENGTH_LONG）.show（）;
}
});
}
@Override
public void onCameraViewStarted（int width， int height） {
（（活动） getContext（））.runOnUiThread（new Runnable（） {
公共无效运行（） {
Toast.makeText（getContext（）， “onCameraViewStarted”， Toast.LENGTH_SHORT）.show（）;
}
});
如果 （NativePart.builtWithOpenCL（））
NativePart.initCL（）;
frameCounter = 0;
lastNanoTime = System.nanoTime（）;
}
@Override
公共无效 onCameraViewStopped（） {
（（活动） getContext（））.runOnUiThread（new Runnable（） {
公共无效运行（） {
Toast.makeText（getContext（）， “onCameraViewStopped”， Toast.LENGTH_SHORT）.show（）;
}
});
}
@Override
公共布尔值 onCameraTexture（int texIn， int texOut， int width， int height） {
转数快
frameCounter++;
if（frameCounter >= 30）
{
final int fps = （int） （frameCounter * 1e9 / （System.nanoTime（） - lastNanoTime））;
Log.i（LOGTAG， “drawFrame（） FPS： ”+fps）;
if（mFpsText ！= null） {
Runnable fpsUpdater = new Runnable（） {
公共无效运行（） {
mFpsText.setText（“FPS： ” + fps）;
}
};
新增功能处理程序（Looper.getMainLooper（））.post（fpsUpdater）;
} 还 {
Log.d（LOGTAG， “mFpsText == null”);
mFpsText = （TextView）（（活动） getContext（））.findViewById（R.id.fps_text_view）;
}
frameCounter = 0;
lastNanoTime = System.nanoTime（）;
}
if（procMode == NativePart.PROCESSING_MODE_NO_PROCESSING）
返回 false;
NativePart.processFrame（texIn， texOut， width， height， procMode）;
返回 true;
}
}
?

受保护的抽象 void openCamera（）;

受保护的抽象 void closeCamera（）;

受保护的抽象 void setCameraPreviewSize（int width， int height）;

?
int initCL（）
{
dumpCLinfo（）;
LOGE（“initCL：启动initCL”);
EGLDisplay mEglDisplay = eglGetCurrentDisplay（）;
如果 （mEglDisplay == EGL_NO_DISPLAY）
LOGE（“initCL： eglGetCurrentDisplay（） returned 'EGL_NO_DISPLAY'， error = %x”， eglGetError（））;
EGLContext mEglContext = eglGetCurrentContext（）;
如果 （mEglContext == EGL_NO_CONTEXT）
LOGE（“initCL： eglGetCurrentContext（） returned 'EGL_NO_CONTEXT'， error = %x”， eglGetError（））;
cl_context_properties props[] =
{ CL_GL_CONTEXT_KHR， （cl_context_properties） mEglContext，
CL_EGL_DISPLAY_KHR、（cl_context_properties） mEglDisplay、
CL_CONTEXT_PLATFORM、0、
0 };
尝试
{
haveOpenCL = 假;
cl：:P latform p = cl：:P latform：：getDefault（）;
std：：string ext = p.getInfo<CL_PLATFORM_EXTENSIONS>（）;
if（ext.find（“cl_khr_gl_sharing”） == std：：string：：npos）
LOGE（“警告：PLATFORM不支持CL-GL共享”);
道具[5] = （cl_context_properties） p（）;
theContext = cl：：Context（CL_DEVICE_TYPE_GPU， props）;
std：：vector<cl：:D evice> devs = theContext.getInfo<CL_CONTEXT_DEVICES>（）;
LOGD（“上下文返回了 %d 个设备，取第一个设备”， devs.size（））;
ext = devs[0].getInfo<CL_DEVICE_EXTENSIONS>（）;
if（ext.find（“cl_khr_gl_sharing”） == std：：string：：npos）
LOGE（“警告：DEVICE不支持CL-GL共享”);
theQueue = cl：：CommandQueue（theContext， devs[0]）;
cl：:P rogram：：Sources src（1， std：：make_pair（oclProgI2I， sizeof（oclProgI2I）））;
theProgI2I = cl：:P rogram（theContext， src）;
progI2I.build（devs）;
cv：：ocl：：attachContext（p.getInfo<CL_PLATFORM_NAME>（）， p（）， theContext（）， devs[0]（））;
if（ cv：：ocl：：useOpenCL() )
LOGD（“OpenCV+OpenCL 工作正常！”);
还
LOGE（“无法使用 OpenCL TAPI 初始化 OpenCV”);
haveOpenCL = 真;
}
catch（const cl：：Error&e）
{
LOGE（“cl：：错误：%s （%d）”， e.what（）， e.err（））;
返回 1;
}
catch（const std：：exception&e）
{
LOGE（“std：：exception： %s”， e.what（））;
返回 2;
}
捕获（...）
{
LOGE（ “OpenCL 信息：初始化 OpenCL 内容时出现未知错误” );
返回 3;
}
LOGD（“initCL 已完成”);
如果（haveOpenCL)
返回 0;
还
返回 4;
}
然后，纹理可以被对象包装，并通过 OpenCL 调用进行处理：cl::ImageGL

cl：：ImageGL imgIn （theContext， CL_MEM_READ_ONLY， GL_TEXTURE_2D， 0， texIn）;
cl：：ImageGL imgOut（theContext， CL_MEM_WRITE_ONLY， GL_TEXTURE_2D， 0， texOut）;
std：：vector < cl：：Memory >图像;
images.push_back（imgIn）;
images.push_back（imgOut）;
int64_t t = getTimeMs（）;
theQueue.enqueueAcquireGLObjects（&images）;
theQueue.finish（）;
LOGD（“enqueueAcquireGLObjects（） 成本 %d ms”， getTimeInterval（t））;
t = getTimeMs（）;
cl：：Kernel Laplacian（theProgI2I， “拉普拉斯”）;TODO：可以做一次
拉普拉斯.setArg（0， imgIn）;
Laplacian.setArg（1， imgOut）;
theQueue.finish（）;
LOGD（“Kernel（） 成本 %d ms”， getTimeInterval（t））;
t = getTimeMs（）;
theQueue.enqueueNDRangeKernel（拉普拉斯， cl：：NullRange， cl：：NDRange（w， h）， cl：：NullRange）;
theQueue.finish（）;
LOGD（“enqueueNDRangeKernel（） 成本 %d 毫秒”， getTimeInterval（t））;
t = getTimeMs（）;
theQueue.enqueueReleaseGLObjects（&images）;
theQueue.finish（）;
LOGD（“enqueueReleaseGLObjects（） 成本 %d ms”， getTimeInterval（t））;
?

LOGD（“将结果上传到纹理成本 %d ms”， getTimeInterval（t））;