With JAVA2D or no renderer at all it works...

1. /**
2. CameraPixelData
3. Eric Pavey - 2010-11-15
4. Set Sketch Permissions : CAMERA
5. Add to AndroidManifest.xml:
6.     uses-feature android:name="android.hardware.camera"
7.     uses-feature android:name="android.hardware.camera.autofocus"
8. */
9. import android.content.Context;
10. import android.hardware.Camera;
11. import android.hardware.Camera.PreviewCallback;
12. import android.view.SurfaceHolder;
13. import android.view.SurfaceHolder.Callback;
14. import android.view.SurfaceView;
15. import android.view.Surface;
16. // Setup camera globals:
17. CameraSurfaceView gCamSurfView;
18. // This is the physical image drawn on the screen representing the camera:
19. PImage gBuffer;
20. void setup() {
21.   size(screenWidth, screenHeight, A2D);
22. }
23. void draw() {
24.   // nuttin'... onPreviewFrame below handles all the drawing.
25. }
26. //-----------------------------------------------------------------------------------------
27. //-----------------------------------------------------------------------------------------
28. // Override the parent (super) Activity class:
29. // States onCreate(), onStart(), and onStop() aren't called by the sketch.  Processing is entered
30. // at the 'onResume()' state, and exits at the 'onPause()' state, so just override them:
31. void onResume() {
32.   super.onResume();
33.   println("onResume()!");
34.   // Sete orientation here, before Processing really starts, or it can get angry:
35.   orientation(LANDSCAPE);
36.   // Create our 'CameraSurfaceView' objects, that works the magic:
37.   gCamSurfView = new CameraSurfaceView(this.getApplicationContext());
38. }
39. //-----------------------------------------------------------------------------------------
40. //-----------------------------------------------------------------------------------------
41. class CameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback, Camera.PreviewCallback {
42.   // Object that accesses the camera, and updates our image data
43.   // Using ideas pulled from 'Android Wireless Application Development', page 340
44.   SurfaceHolder mHolder;
45.   Camera cam = null;
46.   Camera.Size prevSize;
47.   // SurfaceView Constructor:  : ---------------------------------------------------
48.   CameraSurfaceView(Context context) {
49.     super(context);
50.     // Processing PApplets come with their own SurfaceView object which can be accessed
51.     // directly via its object name, 'surfaceView', or via the below function:
52.     // mHolder = surfaceView.getHolder();
53.     mHolder = getSurfaceHolder();
54.     // Add this object as a callback:
55.     mHolder.addCallback(this);
56.   }
57.   // SurfaceHolder.Callback stuff: ------------------------------------------------------
58.   void surfaceCreated (SurfaceHolder holder) {
59.     // When the SurfaceHolder is created, create our camera, and register our
60.     // camera's preview callback, which will fire on each frame of preview:
61.     cam = Camera.open();
62.     cam.setPreviewCallback(this);
63.     Camera.Parameters parameters = cam.getParameters();
64.     // Find our preview size, and init our global PImage:
65.     prevSize = parameters.getPreviewSize();
66.     gBuffer = createImage(prevSize.width, prevSize.height, RGB);
67.   } 
68.   void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
69.     // Start our camera previewing:
70.     cam.startPreview();
71.   }
72.   void surfaceDestroyed (SurfaceHolder holder) {
73.     // Give the cam back to the phone:
74.     cam.stopPreview();
75.     cam.release();
76.     cam = null;
77.   }
78.   //  Camera.PreviewCallback stuff: ------------------------------------------------------
79.   void onPreviewFrame(byte[] data, Camera cam) {
80.     // This is called every frame of the preview.  Update our global PImage.
81.     gBuffer.loadPixels();
82.     // Decode our camera byte data into RGB data:
83.     decodeYUV420SP(gBuffer.pixels, data, prevSize.width, prevSize.height);
84.     gBuffer.updatePixels();
85.     // Draw to screen:
86.     image(gBuffer, 0, 0);
87.   }
88.   //  Byte decoder : ---------------------------------------------------------------------
89.   void decodeYUV420SP(int[] rgb, byte[] yuv420sp, int width, int height) {
90.     // Pulled directly from:
91.     // http://ketai.googlecode.com/svn/trunk/ketai/src/edu/uic/ketai/inputService/KetaiCamera.java
92.     final int frameSize = width * height;
93.     for (int j = 0, yp = 0; j < height; j++) {       int uvp = frameSize + (j >> 1) * width, u = 0, v = 0;
94.       for (int i = 0; i < width; i++, yp++) {
95.         int y = (0xff & ((int) yuv420sp[yp])) - 16;
96.         if (y < 0)
97.           y = 0;
98.         if ((i & 1) == 0) {
99.           v = (0xff & yuv420sp[uvp++]) - 128;
100.           u = (0xff & yuv420sp[uvp++]) - 128;
101.         }
102.         int y1192 = 1192 * y;
103.         int r = (y1192 + 1634 * v);
104.         int g = (y1192 - 833 * v - 400 * u);
105.         int b = (y1192 + 2066 * u);
106.         if (r < 0)
107.            r = 0;
108.         else if (r > 262143)
109.            r = 262143;
110.         if (g < 0)
111.            g = 0;
112.         else if (g > 262143)
113.            g = 262143;
114.         if (b < 0)
115.            b = 0;
116.         else if (b > 262143)
117.            b = 262143;
118.         rgb[yp] = 0xff000000 | ((r << 6) & 0xff0000) | ((g >> 2) & 0xff00) | ((b >> 10) & 0xff);
119.       }
120.     }
121.   }
122. }