使用表面纹理的相机预览

Posted 2023-04-17

【中文标题】使用表面纹理的相机预览

【英文标题】：Camera Preview Using Surface Texture

【发布时间】：2015-02-21 22:16:58

【问题描述】：

我正在尝试使用 SurfaceTexture 从我设备的后置摄像头显示摄像头预览，但我不断收到错误消息

bindTextureImage : 绑定外部纹理图像 0x2:0x502 时出错

看着上面写着的那一行

SurfaceTexture.UpdateTexImage()

查看 android 文档，似乎这可能是由在 SurfaceTexture.OnFrameAvailableListener 的 OnFrameAvailable 方法上调用 UpdateTexImage 引起的。根据文档“可以在任意线程上调用回调 (SurfaceTexture.OnFrameAvailableListener)，所以在没有首先将 OpenGL ES 上下文绑定到调用回调的线程之前调用 updateTexImage() 是不安全的。

如何将 OpenGL ES 上下文“绑定”到调用回调的线程？

我一直在努力密切关注Grafika 项目中的“来自相机的纹理”活动，以尝试获取有关如何完成此任务的线索。感谢任何帮助。

我的完整代码粘贴在下面：

public class CameraPreviewFromTextureActivity extends Activity 

private static String TAG = "CameraPreviewFromTexture";

private static SurfaceHolder mySurfaceHolder = null;    
private SurfaceTexture mCameraTexture = null;   
private Camera mCamera = null;  
private EglCore mEglCore;
private WindowSurface mWindowSurface;
private int mWindowSurfaceWidth;
private int mWindowSurfaceHeight;
private int mCameraPreviewWidth, mCameraPreviewHeight;
private float mCameraPreviewFps;
private Texture2dProgram mTexProgram;

@Override
protected void onCreate(Bundle savedInstanceState) 

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_camera_preview_from_texture);

    mySurfaceHolder = ((SurfaceView)this.findViewById(R.id.surfaceView)).getHolder();
    mySurfaceHolder.addCallback(mySurfaceHolderCallback);

    //Run Thread Methods
    mEglCore = new EglCore(null, 0);
    openCamera(328, 288, 30);


private SurfaceHolder.Callback mySurfaceHolderCallback = new SurfaceHolder.Callback() 


    @Override
    public void surfaceDestroyed(SurfaceHolder holder) 
    
        releaseGl();
    

    @Override
    public void surfaceCreated(SurfaceHolder holder) 
    
        surfaceAvailable(holder, true);         
    

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) 
    
         Log.d(TAG, "SurfaceChanged " + width + "x" + height);

         mWindowSurfaceWidth = width;
         mWindowSurfaceHeight = height;
         finishSurfaceSetup();
    
;


 private void surfaceAvailable(SurfaceHolder holder, boolean newSurface) 
 
     Surface surface = holder.getSurface();
     mWindowSurface = new WindowSurface(mEglCore, surface, false);
     mWindowSurface.makeCurrent();

     // Create and configure the SurfaceTexture, which will receive frames from the
     // camera.  We set the textured rect's program to render from it.
     mTexProgram = new Texture2dProgram(Texture2dProgram.ProgramType.TEXTURE_EXT);
     int textureId = mTexProgram.createTextureObject();
     mCameraTexture = new SurfaceTexture(textureId);
     //mRect.setTexture(textureId);

     if (!newSurface) 
         // This Surface was established on a previous run, so no surfaceChanged()
         // message is forthcoming.  Finish the surface setup now.
         //
         // We could also just call this unconditionally, and perhaps do an unnecessary
         // bit of reallocating if a surface-changed message arrives.
         mWindowSurfaceWidth = mWindowSurface.getWidth();
         mWindowSurfaceHeight = mWindowSurface.getHeight();
         finishSurfaceSetup();
     

     mCameraTexture.setOnFrameAvailableListener(myOnFrameListner);
 

 private SurfaceTexture.OnFrameAvailableListener myOnFrameListner = new SurfaceTexture.OnFrameAvailableListener() 
   
    @Override
    public void onFrameAvailable(SurfaceTexture surfaceTexture) 
               
        surfaceTexture.updateTexImage();  //Problem Occurs Here
        draw();
    
;

private void draw() 

    GlUtil.checkGlError("draw start");

    GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
    //mRect.draw(mTexProgram, mDisplayProjectionMatrix);
    mWindowSurface.swapBuffers();

    GlUtil.checkGlError("draw done");

 private void finishSurfaceSetup() 
 
     int width = mWindowSurfaceWidth;
     int height = mWindowSurfaceHeight;

     // Use full window.
     GLES20.glViewport(0, 0, width, height);

     // Ready to go, start the camera.
     Log.d(TAG, "starting camera preview");
     try 
         mCamera.setPreviewTexture(mCameraTexture);
      catch (IOException ioe) 
         throw new RuntimeException(ioe);
     
     mCamera.startPreview();
 

 private void openCamera(int desiredWidth, int desiredHeight, int desiredFps) 
 
     if (mCamera != null) 
     
         throw new RuntimeException("camera already initialized");
     

     Camera.CameraInfo info = new Camera.CameraInfo();

    try
    
        mCamera = Camera.open();
    
    catch(Exception ex)
    
        ex.printStackTrace();
    

     Camera.Parameters parms = mCamera.getParameters();

     // Try to set the frame rate to a constant value.
     int thousandFps = chooseFixedPreviewFps(parms, desiredFps * 1000);

     // Give the camera a hint that we're recording video.  This can have a big
     // impact on frame rate.
     parms.setRecordingHint(true);

     mCamera.setParameters(parms);

     int[] fpsRange = new int[2];
     Camera.Size mCameraPreviewSize = parms.getPreviewSize();
     parms.getPreviewFpsRange(fpsRange);
     String previewFacts = mCameraPreviewSize.width + "x" + mCameraPreviewSize.height;
     if (fpsRange[0] == fpsRange[1]) 
         previewFacts += " @" + (fpsRange[0] / 1000.0) + "fps";
      else 
         previewFacts += " @[" + (fpsRange[0] / 1000.0) +
                 " - " + (fpsRange[1] / 1000.0) + "] fps";
     
     Log.i(TAG, "Camera config: " + previewFacts);

     mCameraPreviewWidth = mCameraPreviewSize.width;
     mCameraPreviewHeight = mCameraPreviewSize.height;
     mCameraPreviewFps = desiredFps;
 


 public static int chooseFixedPreviewFps(Camera.Parameters parms, int desiredThousandFps) 
 
        List<int[]> supported = parms.getSupportedPreviewFpsRange();

        for (int[] entry : supported) 
            //Log.d(TAG, "entry: " + entry[0] + " - " + entry[1]);
            if ((entry[0] == entry[1]) && (entry[0] == desiredThousandFps)) 
                parms.setPreviewFpsRange(entry[0], entry[1]);
                return entry[0];
            
        

        int[] tmp = new int[2];
        parms.getPreviewFpsRange(tmp);
        int guess;
        if (tmp[0] == tmp[1]) 
            guess = tmp[0];
         else 
            guess = tmp[1] / 2;     // shrug
        

        Log.d(TAG, "Couldn't find match for " + desiredThousandFps + ", using " + guess);
        return guess;
    


@Override
public boolean onCreateOptionsMenu(Menu menu) 
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.camera_preview_from_texture, menu);
    return true;


@Override
public boolean onOptionsItemSelected(MenuItem item) 
    // Handle action bar item clicks here. The action bar will
    // automatically handle clicks on the Home/Up button, so long
    // as you specify a parent activity in AndroidManifest.xml.
    int id = item.getItemId();
    if (id == R.id.action_settings) 
        return true;
    
    return super.onOptionsItemSelected(item);


 private void releaseGl() 
     GlUtil.checkGlError("releaseGl start");

     if (mWindowSurface != null) 
         mWindowSurface.release();
         mWindowSurface = null;
     
     if (mTexProgram != null) 
         mTexProgram.release();
         mTexProgram = null;
     
     GlUtil.checkGlError("releaseGl done");

     mEglCore.makeNothingCurrent();
 

 private void releaseCamera() 
     if (mCamera != null) 
         mCamera.stopPreview();
         mCamera.release();
         mCamera = null;
         Log.d(TAG, "releaseCamera -- done");
     
 

@Override
public void onDestroy()

    releaseCamera();
    releaseGl();
    mEglCore.release();

【参考方案1】：

每个线程都有一个“当前”EGL 上下文，由 GLES 驱动程序通过线程本地存储引用。您发出的任何 GLES 命令（包括纹理绑定）都在此上下文中运行。

快速浏览您的代码表明您正在尝试在 UI 线程上执行所有操作。如果您创建自己的上下文并使其成为当前上下文，它将与 UI 代码发生冲突，该代码将拥有自己的 EGL 上下文，用于硬件加速的视图渲染。如果你创建一个单独的线程，让你的 EGL 上下文在其中成为当前的，然后就不用管它，生活会简单一些。

您可以看到“来自相机的纹理”活动的可用帧处理程序只是：

    public void onFrameAvailable(SurfaceTexture surfaceTexture) 
        mHandler.sendFrameAvailable();
    

因为可用帧消息可以到达任意线程，所以您不知道那里的当前 EGL 上下文（或者线程是否有一个）。你可以调用eglMakeCurrent()（通过EglCore#makeCurrent()）来使你的成为最新的，但是你不能从多个线程中使用相同的EGL上下文，所以如果它同时在其他地方你可能会遇到问题.因此，将帧可用消息转发到您知道 EGL 上下文是当前的线程会更容易。

FWIW，0x0502 是GL_INVALID_OPERATION​。

【参考方案2】：

同样的错误，我已经通过在函数draw()的开头添加mWindowSurface.makeCurrent()来修复它。