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.

Hey, thanks for the tip.  I'll be sure to check that out!

Does this work to any cameras? I've got one but I love to get the pixels move up.






________________
Quadracentifiable

I've got a Samsung Galaxy S running 2.1, so if your phone is similar to that you shouldn't have any problem.

that's funny... I tested out this code when you first posted it, and was getting really slow performance, but now it runs at about 47-48fps... same OS version (N1, 2.2)... 

Has anyone tested this on 0194 ???

Yes I have tested the ak_eric code on my 0194. it's runing. Without color for me, and with some screen distortion, but running :)

Hi,

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.

The .apk is working on my Spica !
So for now, I'm Trying to adapt the java/android code to processing, but for the moment I fail :-/
Has Someone ever managed to do this ?

Hi,

I'm trying to adapt the Java/droid code to processig, but I'm really not a Java's expert, so I don't know if is it possible in this way.
For now i Have this :

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. }

plus classes in java file.
One for the Camera :

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. }

And the other for the GL texture:

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. }

For now, the sketch is running, but I have a white screen on my phone.
I'have put some println into method's classes to know what's happens, and I can see the surfaceCreated() method for example, is never launch... Someone know why ?

Many thanks in advance !

Any progress on the OPENGL?

Any updates so far ?

Hi: I'm working on a xoom tablet. Ketai's camera class works ok. 

is this applicable to all phones with camera?

that's correct.