Have you seen this demo app? It copies the pixels from the camera into an opengl texture. The performance is quite good, and the source code is available for download in the page.

1. import android.content.pm.ActivityInfo;
2. import android.os.Bundle;
3. import android.os.Looper;
4. import android.os.Handler;
5. import android.view.Window;
6. import android.view.WindowManager;
7. import android.content.Context;
8. CamLayer mPreview;
9. GLLayer glView;
10. PImage gBuffer;
11. void setup() {
12.   orientation(LANDSCAPE);
13.   Looper.prepare();
14.   glView=new GLLayer(this.getApplicationContext());
15.   mPreview = new CamLayer(this.getApplicationContext(), glView);
16. }
17. void draw() {
18. }
19. super.onPause();
20. System.exit(0);
21. }

1. import java.io.IOException;
2. import android.content.Context;
3. import android.hardware.Camera;
4. import android.hardware.Camera.PreviewCallback;
5. import android.util.Log;
6. import android.view.SurfaceHolder;
7. import android.view.SurfaceView;
8. public class CamLayer extends SurfaceView implements SurfaceHolder.Callback, PreviewCallback {
9.   Camera mCamera;
10.   boolean isPreviewRunning = false;
11.   Camera.PreviewCallback callback;
12.   Camera.Size prevSize;
13.   CamLayer(Context context, Camera.PreviewCallback callback) {
14.     super(context);
15.     this.callback=callback;
16.     // Install a SurfaceHolder.Callback so we get notified when the
17.     // underlying surface is created and destroyed.
18.     SurfaceHolder mHolder = getHolder();
19.     mHolder.addCallback(this);
20.     mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
21.     System.out.println("objet cam cree");
22.     //surfaceCreated(mHolder);
23.   }
24.   public void surfaceCreated(SurfaceHolder holder) {
25.     synchronized(this) {
26.       mCamera = Camera.open();
27.       Camera.Parameters p = mCamera.getParameters(); 
28.       p.setPreviewSize(240, 160);
29.       mCamera.setParameters(p);
30.       prevSize = p.getPreviewSize();
31.       //gBuffer = createImage(prevSize.width, prevSize.height, RGB);
32.       try {
33.         if (mCamera != null) {
34.           mCamera.setPreviewDisplay(holder);
35.           System.out.println("surface cree");
36.         }
37.       }
38.       catch (IOException e) {
39.         Log.e("Camera", "mCamera.setPreviewDisplay(holder);");
40.       }
41.       mCamera.startPreview();
42.       mCamera.setPreviewCallback(this);
43.     }
44.   }
45.   public void surfaceDestroyed(SurfaceHolder holder) {
46.     // Surface will be destroyed when we return, so stop the preview.
47.     // Because the CameraDevice object is not a shared resource, it's very
48.     // important to release it when the activity is paused.
49.     synchronized(this) {
50.       try {
51.         if (mCamera!=null) {
52.           mCamera.stopPreview(); 
53.           isPreviewRunning=false;
54.           mCamera.release();
55.         }
56.       }
57.       catch (Exception e) {
58.         Log.e("Camera", e.getMessage());
59.       }
60.     }
61.   }
62.  public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
63.   }
64.   public void onPreviewFrame(byte[] arg0, Camera arg1) {
65.     if (callback!=null)
66.       callback.onPreviewFrame(arg0, arg1);
67.   }
68. }

1. import java.nio.ByteBuffer;
2. import java.nio.ByteOrder;
3. import java.nio.FloatBuffer;
4. import javax.microedition.khronos.egl.EGLConfig;
5. import javax.microedition.khronos.opengles.GL10;
6. import android.content.Context;
7. import android.graphics.PixelFormat;
8. import android.hardware.Camera;
9. import android.opengl.GLSurfaceView;
10. import android.opengl.GLU;
11. import android.opengl.GLSurfaceView.Renderer;
12. import android.view.SurfaceHolder;
13. public class GLLayer extends GLSurfaceView implements SurfaceHolder.Callback,
14. Camera.PreviewCallback, Renderer {
15.   int onDrawFrameCounter=1;
16.   int[] cameraTexture;
17.   byte[] glCameraFrame=new byte[256*256]; //size of a texture must be a power of 2
18.   FloatBuffer cubeBuff;
19.   FloatBuffer texBuff;
20.   public GLLayer(Context c) {
21.     super(c);
22.     this.setEGLConfigChooser(5, 6, 5, 8, 16, 0);
23.     this.setRenderer(this);
24.     this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
25.     System.out.println("Gllayer cree");
26.   }
27.   public void onDrawFrame(GL10 gl) {
28.     onDrawFrameCounter++;
29.     gl.glEnable(GL10.GL_TEXTURE_2D);
30.     gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
31.     bindCameraTexture(gl);
32.     gl.glLoadIdentity();
33.     GLU.gluLookAt(gl, 0, 0, 4.2f, 0, 0, 0, 0, 1, 0);
34.     gl.glRotatef(onDrawFrameCounter, 1, 0, 0); //Rotate the camera image
35.     gl.glRotatef((float)Math.sin(onDrawFrameCounter/20.0f)*40, 0, 1, 0); //Rotate the camera image
36.     gl.glRotatef((float)Math.cos(onDrawFrameCounter/40.0f)*40, 0, 0, 1); //Rotate the camera image
37.     gl.glNormal3f(0, 0, 1);
38.     gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);           
39.     gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 4, 4);
40.     gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 8, 4);
41.     gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 12, 4);
42.     gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 16, 4);
43.     gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 20, 4);
44.     System.out.println("draw GL frame");
45.   }
46.   public void onSurfaceChanged(GL10 gl, int width, int height) {
47.     gl.glViewport(0, 0, width, height);
48.     float ratio = (float) width / height;
49.     gl.glMatrixMode(GL10.GL_PROJECTION);
50.     gl.glLoadIdentity();
51.     gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
52.     gl.glMatrixMode(GL10.GL_MODELVIEW);
53.     gl.glLoadIdentity();
54.     GLU.gluLookAt(gl, 0, 0, 4.2f, 0, 0, 0, 0, 1, 0);
55.   }
56.   public void onSurfaceCreated(GL10 gl, EGLConfig config) {
57.     gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);
58.     gl.glClearColor(0, 0, 0, 0);
59.     gl.glEnable(GL10.GL_CULL_FACE);
60.     gl.glShadeModel(GL10.GL_SMOOTH);
61.     gl.glEnable(GL10.GL_DEPTH_TEST);
62.     cubeBuff = makeFloatBuffer(camObjCoord);
63.     texBuff = makeFloatBuffer(camTexCoords);       
64.     gl.glVertexPointer(3, GL10.GL_FLOAT, 0, cubeBuff);
65.     gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
66.     gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, texBuff);
67.     gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
68.   }   
69.   /**
70.         * Generates a texture from the black and white array filled by the onPreviewFrame
71.         * method.
72.         */
73.   void bindCameraTexture(GL10 gl) {
74.     synchronized(this) {
75.       if (cameraTexture==null)
76.         cameraTexture=new int[1];
77.       else
78.         gl.glDeleteTextures(1, cameraTexture, 0);
79.       gl.glGenTextures(1, cameraTexture, 0);
80.       int tex = cameraTexture[0];
81.       gl.glBindTexture(GL10.GL_TEXTURE_2D, tex);
82.       gl.glTexImage2D(GL10.GL_TEXTURE_2D, 0, GL10.GL_LUMINANCE, 256, 256, 0, GL10.GL_LUMINANCE, GL10.GL_UNSIGNED_BYTE, ByteBuffer.wrap(glCameraFrame));
83.       gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
84.     }
85.   }
86.   /**
87.         * This method is called if a new image from the camera arrived. The camera
88.         * delivers images in a yuv color format. It is converted to a black and white
89.         * image with a size of 256x256 pixels (only a fraction of the resulting image
90.         * is used). Afterwards Rendering the frame (in the main loop thread) is started by
91.         * setting the newFrameLock to true.
92.         */
93.   public void onPreviewFrame(byte[] yuvs, Camera camera) {       
94.     int bwCounter=0;
95.     int yuvsCounter=0;
96.     //gBuffer.loadPixels();
97.     for (int y=0;y<160;y++) {
98.       System.arraycopy(yuvs, yuvsCounter, glCameraFrame, bwCounter, 240);
99.       yuvsCounter=yuvsCounter+240;
100.       bwCounter=bwCounter+256;
101.     }
102.     //gBuffer.updatePixels();
103.     //image(gBuffer, 0, 0);
104.     System.out.println("image affichee");
105.   }
106.   FloatBuffer makeFloatBuffer(float[] arr) {
107.     ByteBuffer bb = ByteBuffer.allocateDirect(arr.length*4);
108.     bb.order(ByteOrder.nativeOrder());
109.     FloatBuffer fb = bb.asFloatBuffer();
110.     fb.put(arr);
111.     fb.position(0);
112.     return fb;
113.   }
114.   final static float camObjCoord[] = new float[] {
115.     // FRONT
116.     -2.0f, -1.5f, 2.0f,
117.     2.0f, -1.5f, 2.0f,
118.     -2.0f, 1.5f, 2.0f,
119.     2.0f, 1.5f, 2.0f,
120.     // BACK
121.     -2.0f, -1.5f, -2.0f,
122.     -2.0f, 1.5f, -2.0f,
123.     2.0f, -1.5f, -2.0f,
124.     2.0f, 1.5f, -2.0f,
125.     // LEFT
126.     -2.0f, -1.5f, 2.0f,
127.     -2.0f, 1.5f, 2.0f,
128.     -2.0f, -1.5f, -2.0f,
129.     -2.0f, 1.5f, -2.0f,
130.     // RIGHT
131.     2.0f, -1.5f, -2.0f,
132.     2.0f, 1.5f, -2.0f,
133.     2.0f, -1.5f, 2.0f,
134.     2.0f, 1.5f, 2.0f,
135.     // TOP
136.     -2.0f, 1.5f, 2.0f,
137.     2.0f, 1.5f, 2.0f,
138.     -2.0f, 1.5f, -2.0f,
139.     2.0f, 1.5f, -2.0f,
140.     // BOTTOM
141.     -2.0f, -1.5f, 2.0f,
142.     -2.0f, -1.5f, -2.0f,
143.     2.0f, -1.5f, 2.0f,
144.     2.0f, -1.5f, -2.0f,
145.   };
146.   final static float camTexCoords[] = new float[] {
147.     // Camera preview
148.     0.0f, 0.0f,
149.     0.9375f, 0.0f,
150.     0.0f, 0.625f,
151.     0.9375f, 0.625f,
152.     // BACK
153.     0.9375f, 0.0f,
154.     0.9375f, 0.625f,
155.     0.0f, 0.0f,
156.     0.0f, 0.625f,
157.     // LEFT
158.     0.9375f, 0.0f,
159.     0.9375f, 0.625f,
160.     0.0f, 0.0f,
161.     0.0f, 0.625f,
162.     // RIGHT
163.     0.9375f, 0.0f,
164.     0.9375f, 0.625f,
165.     0.0f, 0.0f,
166.     0.0f, 0.625f,
167.     // TOP
168.     0.0f, 0.0f,
169.     0.9375f, 0.0f,
170.     0.0f, 0.625f,
171.     0.9375f, 0.625f,
172.     // BOTTOM
173.     0.9375f, 0.0f,
174.     0.9375f, 0.625f,
175.     0.0f, 0.0f,
176.     0.0f, 0.625f
177.   };
178. }