android/filterpacks/videosrc/CameraSource.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */


 package android.filterpacks.videosrc;

 import android.filterfw.core.Filter;
 import android.filterfw.core.FilterContext;
 import android.filterfw.core.Frame;
 import android.filterfw.core.FrameFormat;
 import android.filterfw.core.GenerateFieldPort;
 import android.filterfw.core.GenerateFinalPort;
 import android.filterfw.core.GLFrame;
 import android.filterfw.core.MutableFrameFormat;
 import android.filterfw.core.ShaderProgram;
 import android.filterfw.format.ImageFormat;
 import android.graphics.SurfaceTexture;
 import android.hardware.Camera;
 import android.opengl.Matrix;

 import java.io.IOException;
 import java.util.List;

 import android.util.Log;

 /**
  * @hide
  */
 public class CameraSource extends Filter {

     /** User-visible parameters */

     /** Camera ID to use for input. Defaults to 0. */
     @GenerateFieldPort(name = "id", hasDefault = true)
     private int mCameraId = 0;

     /** Frame width to request from camera. Actual size may not match requested. */
     @GenerateFieldPort(name = "width", hasDefault = true)
     private int mWidth = 320;

     /** Frame height to request from camera. Actual size may not match requested. */
     @GenerateFieldPort(name = "height", hasDefault = true)
     private int mHeight = 240;

     /** Stream framerate to request from camera. Actual frame rate may not match requested. */
     @GenerateFieldPort(name = "framerate", hasDefault = true)
     private int mFps = 30;

     /** Whether the filter should always wait for a new frame from the camera
      * before providing output.  If set to false, the filter will keep
      * outputting the last frame it received from the camera if multiple process
      * calls are received before the next update from the Camera. Defaults to true.
      */
     @GenerateFinalPort(name = "waitForNewFrame", hasDefault = true)
     private boolean mWaitForNewFrame = true;

     private Camera mCamera;
     private GLFrame mCameraFrame;
     private SurfaceTexture mSurfaceTexture;
     private ShaderProgram mFrameExtractor;
     private MutableFrameFormat mOutputFormat;

     private float[] mCameraTransform;
     private float[] mMappedCoords;
     // These default source coordinates perform the necessary flip
     // for converting from OpenGL origin to MFF/Bitmap origin.
     private static final float[] mSourceCoords = { 0, 1, 0, 1,
                                                    1, 1, 0, 1,
                                                    0, 0, 0, 1,
                                                    1, 0, 0, 1 };

     private static final int NEWFRAME_TIMEOUT = 100; //ms
     private static final int NEWFRAME_TIMEOUT_REPEAT = 10;

     private boolean mNewFrameAvailable;

     private Camera.Parameters mCameraParameters;

     private static final String mFrameShader =
             "#extension GL_OES_EGL_image_external : require\n" +
             "precision mediump float;\n" +
             "uniform samplerExternalOES tex_sampler_0;\n" +
             "varying vec2 v_texcoord;\n" +
             "void main() {\n" +
             "  gl_FragColor = texture2D(tex_sampler_0, v_texcoord);\n" +
             "}\n";

     private final boolean mLogVerbose;
     private static final String TAG = "CameraSource";

     public CameraSource(String name) {
         super(name);
         mCameraTransform = new float[16];
         mMappedCoords = new float[16];

         mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
     }

     @Override
     public void setupPorts() {
         // Add input port
         addOutputPort("video", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
                                                   FrameFormat.TARGET_GPU));
     }

     private void createFormats() {
         mOutputFormat = ImageFormat.create(mWidth, mHeight,
                                            ImageFormat.COLORSPACE_RGBA,
                                            FrameFormat.TARGET_GPU);
     }

     @Override
     public void prepare(FilterContext context) {
         if (mLogVerbose) Log.v(TAG, "Preparing");
         // Compile shader TODO: Move to onGLEnvSomething?
         mFrameExtractor = new ShaderProgram(context, mFrameShader);
     }

     @Override
     public void open(FilterContext context) {
         if (mLogVerbose) Log.v(TAG, "Opening");
         // Open camera
         mCamera = Camera.open(mCameraId);

         // Set parameters
         getCameraParameters();
         mCamera.setParameters(mCameraParameters);

         // Create frame formats
         createFormats();

         // Bind it to our camera frame
         mCameraFrame = (GLFrame)context.getFrameManager().newBoundFrame(mOutputFormat,
                                                                         GLFrame.EXTERNAL_TEXTURE,
                                                                         0);
         mSurfaceTexture = new SurfaceTexture(mCameraFrame.getTextureId());
         try {
             mCamera.setPreviewTexture(mSurfaceTexture);
         } catch (IOException e) {
             throw new RuntimeException("Could not bind camera surface texture: " +
                                        e.getMessage() + "!");
         }

         // Connect SurfaceTexture to callback
         mSurfaceTexture.setOnFrameAvailableListener(onCameraFrameAvailableListener);
         // Start the preview
         mNewFrameAvailable = false;
         mCamera.startPreview();
     }

     @Override
     public void process(FilterContext context) {
         if (mLogVerbose) Log.v(TAG, "Processing new frame");

         if (mWaitForNewFrame) {
             int waitCount = 0;
             while (!mNewFrameAvailable) {
                 if (waitCount == NEWFRAME_TIMEOUT_REPEAT) {
                     throw new RuntimeException("Timeout waiting for new frame");
                 }
                 try {
                     this.wait(NEWFRAME_TIMEOUT);
                 } catch (InterruptedException e) {
                     if (mLogVerbose) Log.v(TAG, "Interrupted while waiting for new frame");
                 }
             }
             mNewFrameAvailable = false;
             if (mLogVerbose) Log.v(TAG, "Got new frame");
         }

         mSurfaceTexture.updateTexImage();

         if (mLogVerbose) Log.v(TAG, "Using frame extractor in thread: " + Thread.currentThread());
         mSurfaceTexture.getTransformMatrix(mCameraTransform);
         Matrix.multiplyMM(mMappedCoords, 0,
                           mCameraTransform, 0,
                           mSourceCoords, 0);
         mFrameExtractor.setSourceRegion(mMappedCoords[0], mMappedCoords[1],
                                         mMappedCoords[4], mMappedCoords[5],
                                         mMappedCoords[8], mMappedCoords[9],
                                         mMappedCoords[12], mMappedCoords[13]);

         Frame output = context.getFrameManager().newFrame(mOutputFormat);
         mFrameExtractor.process(mCameraFrame, output);

         long timestamp = mSurfaceTexture.getTimestamp();
         if (mLogVerbose) Log.v(TAG, "Timestamp: " + (timestamp / 1000000000.0) + " s");
         output.setTimestamp(timestamp);

         pushOutput("video", output);

         // Release pushed frame
         output.release();

         if (mLogVerbose) Log.v(TAG, "Done processing new frame");
     }

     @Override
     public void close(FilterContext context) {
         if (mLogVerbose) Log.v(TAG, "Closing");

         mCamera.release();
         mCamera = null;
         mSurfaceTexture.release();
         mSurfaceTexture = null;
     }

     @Override
     public void tearDown(FilterContext context) {
         if (mCameraFrame != null) {
             mCameraFrame.release();
         }
     }

     @Override
     public void fieldPortValueUpdated(String name, FilterContext context) {
         if (name.equals("framerate")) {
             getCameraParameters();
             int closestRange[] = findClosestFpsRange(mFps, mCameraParameters);
             mCameraParameters.setPreviewFpsRange(closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
                                                  closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
             mCamera.setParameters(mCameraParameters);
         }
     }

     synchronized public Camera.Parameters getCameraParameters() {
         boolean closeCamera = false;
         if (mCameraParameters == null) {
             if (mCamera == null) {
                 mCamera = Camera.open(mCameraId);
                 closeCamera = true;
             }
             mCameraParameters = mCamera.getParameters();

             if (closeCamera) {
                 mCamera.release();
                 mCamera = null;
             }
         }

         int closestSize[] = findClosestSize(mWidth, mHeight, mCameraParameters);
         mWidth = closestSize[0];
         mHeight = closestSize[1];
         mCameraParameters.setPreviewSize(mWidth, mHeight);

         int closestRange[] = findClosestFpsRange(mFps, mCameraParameters);

         mCameraParameters.setPreviewFpsRange(closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
                                              closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);

         return mCameraParameters;
     }

     /** Update camera parameters. Image resolution cannot be changed. */
     synchronized public void setCameraParameters(Camera.Parameters params) {
         params.setPreviewSize(mWidth, mHeight);
         mCameraParameters = params;
         if (isOpen()) {
             mCamera.setParameters(mCameraParameters);
         }
     }

     private int[] findClosestSize(int width, int height, Camera.Parameters parameters) {
         List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();
         int closestWidth = -1;
         int closestHeight = -1;
         int smallestWidth = previewSizes.get(0).width;
         int smallestHeight =  previewSizes.get(0).height;
         for (Camera.Size size : previewSizes) {
             // Best match defined as not being larger in either dimension than
             // the requested size, but as close as possible. The below isn't a
             // stable selection (reording the size list can give different
             // results), but since this is a fallback nicety, that's acceptable.
             if ( size.width <= width &&
                  size.height <= height &&
                  size.width >= closestWidth &&
                  size.height >= closestHeight) {
                 closestWidth = size.width;
                 closestHeight = size.height;
             }
             if ( size.width < smallestWidth &&
                  size.height < smallestHeight) {
                 smallestWidth = size.width;
                 smallestHeight = size.height;
             }
         }
         if (closestWidth == -1) {
             // Requested size is smaller than any listed size; match with smallest possible
             closestWidth = smallestWidth;
             closestHeight = smallestHeight;
         }

         if (mLogVerbose) {
             Log.v(TAG,
                   "Requested resolution: (" + width + ", " + height
                   + "). Closest match: (" + closestWidth + ", "
                   + closestHeight + ").");
         }
         int[] closestSize = {closestWidth, closestHeight};
         return closestSize;
     }

     private int[] findClosestFpsRange(int fps, Camera.Parameters params) {
         List<int[]> supportedFpsRanges = params.getSupportedPreviewFpsRange();
         int[] closestRange = supportedFpsRanges.get(0);
         for (int[] range : supportedFpsRanges) {
             if (range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] < fps*1000 &&
                 range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] > fps*1000 &&
                 range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] >
                 closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] &&
                 range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] <
                 closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]) {
                 closestRange = range;
             }
         }
         if (mLogVerbose) Log.v(TAG, "Requested fps: " + fps
                                + ".Closest frame rate range: ["
                                + closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] / 1000.
                                + ","
                                + closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] / 1000.
                                + "]");

         return closestRange;
     }

     private SurfaceTexture.OnFrameAvailableListener onCameraFrameAvailableListener =
             new SurfaceTexture.OnFrameAvailableListener() {
         @Override
         public void onFrameAvailable(SurfaceTexture surfaceTexture) {
             if (mLogVerbose) Log.v(TAG, "New frame from camera");
             synchronized(CameraSource.this) {
                 mNewFrameAvailable = true;
                 CameraSource.this.notify();
             }
         }
     };

 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/


	package android.filterpacks.videosrc;

	import android.filterfw.core.Filter;
	import android.filterfw.core.FilterContext;
	import android.filterfw.core.Frame;
	import android.filterfw.core.FrameFormat;
	import android.filterfw.core.GenerateFieldPort;
	import android.filterfw.core.GenerateFinalPort;
	import android.filterfw.core.GLFrame;
	import android.filterfw.core.MutableFrameFormat;
	import android.filterfw.core.ShaderProgram;
	import android.filterfw.format.ImageFormat;
	import android.graphics.SurfaceTexture;
	import android.hardware.Camera;
	import android.opengl.Matrix;

	import java.io.IOException;
	import java.util.List;

	import android.util.Log;

	/**
	* @hide
	*/
	public class CameraSource extends Filter {

	/** User-visible parameters */

	/** Camera ID to use for input. Defaults to 0. */
	@GenerateFieldPort(name = "id", hasDefault = true)
	private int mCameraId = 0;

	/** Frame width to request from camera. Actual size may not match requested. */
	@GenerateFieldPort(name = "width", hasDefault = true)
	private int mWidth = 320;

	/** Frame height to request from camera. Actual size may not match requested. */
	@GenerateFieldPort(name = "height", hasDefault = true)
	private int mHeight = 240;

	/** Stream framerate to request from camera. Actual frame rate may not match requested. */
	@GenerateFieldPort(name = "framerate", hasDefault = true)
	private int mFps = 30;

	/** Whether the filter should always wait for a new frame from the camera
	* before providing output. If set to false, the filter will keep
	* outputting the last frame it received from the camera if multiple process
	* calls are received before the next update from the Camera. Defaults to true.
	*/
	@GenerateFinalPort(name = "waitForNewFrame", hasDefault = true)
	private boolean mWaitForNewFrame = true;

	private Camera mCamera;
	private GLFrame mCameraFrame;
	private SurfaceTexture mSurfaceTexture;
	private ShaderProgram mFrameExtractor;
	private MutableFrameFormat mOutputFormat;

	private float[] mCameraTransform;
	private float[] mMappedCoords;
	// These default source coordinates perform the necessary flip
	// for converting from OpenGL origin to MFF/Bitmap origin.
	private static final float[] mSourceCoords = { 0, 1, 0, 1,
	1, 1, 0, 1,
	0, 0, 0, 1,
	1, 0, 0, 1 };

	private static final int NEWFRAME_TIMEOUT = 100; //ms
	private static final int NEWFRAME_TIMEOUT_REPEAT = 10;

	private boolean mNewFrameAvailable;

	private Camera.Parameters mCameraParameters;

	private static final String mFrameShader =
	"#extension GL_OES_EGL_image_external : require\n" +
	"precision mediump float;\n" +
	"uniform samplerExternalOES tex_sampler_0;\n" +
	"varying vec2 v_texcoord;\n" +
	"void main() {\n" +
	" gl_FragColor = texture2D(tex_sampler_0, v_texcoord);\n" +
	"}\n";

	private final boolean mLogVerbose;
	private static final String TAG = "CameraSource";

	public CameraSource(String name) {
	super(name);
	mCameraTransform = new float[16];
	mMappedCoords = new float[16];

	mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);
	}

	@Override
	public void setupPorts() {
	// Add input port
	addOutputPort("video", ImageFormat.create(ImageFormat.COLORSPACE_RGBA,
	FrameFormat.TARGET_GPU));
	}

	private void createFormats() {
	mOutputFormat = ImageFormat.create(mWidth, mHeight,
	ImageFormat.COLORSPACE_RGBA,
	FrameFormat.TARGET_GPU);
	}

	@Override
	public void prepare(FilterContext context) {
	if (mLogVerbose) Log.v(TAG, "Preparing");
	// Compile shader TODO: Move to onGLEnvSomething?
	mFrameExtractor = new ShaderProgram(context, mFrameShader);
	}

	@Override
	public void open(FilterContext context) {
	if (mLogVerbose) Log.v(TAG, "Opening");
	// Open camera
	mCamera = Camera.open(mCameraId);

	// Set parameters
	getCameraParameters();
	mCamera.setParameters(mCameraParameters);

	// Create frame formats
	createFormats();

	// Bind it to our camera frame
	mCameraFrame = (GLFrame)context.getFrameManager().newBoundFrame(mOutputFormat,
	GLFrame.EXTERNAL_TEXTURE,
	0);
	mSurfaceTexture = new SurfaceTexture(mCameraFrame.getTextureId());
	try {
	mCamera.setPreviewTexture(mSurfaceTexture);
	} catch (IOException e) {
	throw new RuntimeException("Could not bind camera surface texture: " +
	e.getMessage() + "!");
	}

	// Connect SurfaceTexture to callback
	mSurfaceTexture.setOnFrameAvailableListener(onCameraFrameAvailableListener);
	// Start the preview
	mNewFrameAvailable = false;
	mCamera.startPreview();
	}

	@Override
	public void process(FilterContext context) {
	if (mLogVerbose) Log.v(TAG, "Processing new frame");

	if (mWaitForNewFrame) {
	int waitCount = 0;
	while (!mNewFrameAvailable) {
	if (waitCount == NEWFRAME_TIMEOUT_REPEAT) {
	throw new RuntimeException("Timeout waiting for new frame");
	}
	try {
	this.wait(NEWFRAME_TIMEOUT);
	} catch (InterruptedException e) {
	if (mLogVerbose) Log.v(TAG, "Interrupted while waiting for new frame");
	}
	}
	mNewFrameAvailable = false;
	if (mLogVerbose) Log.v(TAG, "Got new frame");
	}

	mSurfaceTexture.updateTexImage();

	if (mLogVerbose) Log.v(TAG, "Using frame extractor in thread: " + Thread.currentThread());
	mSurfaceTexture.getTransformMatrix(mCameraTransform);
	Matrix.multiplyMM(mMappedCoords, 0,
	mCameraTransform, 0,
	mSourceCoords, 0);
	mFrameExtractor.setSourceRegion(mMappedCoords[0], mMappedCoords[1],
	mMappedCoords[4], mMappedCoords[5],
	mMappedCoords[8], mMappedCoords[9],
	mMappedCoords[12], mMappedCoords[13]);

	Frame output = context.getFrameManager().newFrame(mOutputFormat);
	mFrameExtractor.process(mCameraFrame, output);

	long timestamp = mSurfaceTexture.getTimestamp();
	if (mLogVerbose) Log.v(TAG, "Timestamp: " + (timestamp / 1000000000.0) + " s");
	output.setTimestamp(timestamp);

	pushOutput("video", output);

	// Release pushed frame
	output.release();

	if (mLogVerbose) Log.v(TAG, "Done processing new frame");
	}

	@Override
	public void close(FilterContext context) {
	if (mLogVerbose) Log.v(TAG, "Closing");

	mCamera.release();
	mCamera = null;
	mSurfaceTexture.release();
	mSurfaceTexture = null;
	}

	@Override
	public void tearDown(FilterContext context) {
	if (mCameraFrame != null) {
	mCameraFrame.release();
	}
	}

	@Override
	public void fieldPortValueUpdated(String name, FilterContext context) {
	if (name.equals("framerate")) {
	getCameraParameters();
	int closestRange[] = findClosestFpsRange(mFps, mCameraParameters);
	mCameraParameters.setPreviewFpsRange(closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
	closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
	mCamera.setParameters(mCameraParameters);
	}
	}

	synchronized public Camera.Parameters getCameraParameters() {
	boolean closeCamera = false;
	if (mCameraParameters == null) {
	if (mCamera == null) {
	mCamera = Camera.open(mCameraId);
	closeCamera = true;
	}
	mCameraParameters = mCamera.getParameters();

	if (closeCamera) {
	mCamera.release();
	mCamera = null;
	}
	}

	int closestSize[] = findClosestSize(mWidth, mHeight, mCameraParameters);
	mWidth = closestSize[0];
	mHeight = closestSize[1];
	mCameraParameters.setPreviewSize(mWidth, mHeight);

	int closestRange[] = findClosestFpsRange(mFps, mCameraParameters);

	mCameraParameters.setPreviewFpsRange(closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
	closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);

	return mCameraParameters;
	}

	/** Update camera parameters. Image resolution cannot be changed. */
	synchronized public void setCameraParameters(Camera.Parameters params) {
	params.setPreviewSize(mWidth, mHeight);
	mCameraParameters = params;
	if (isOpen()) {
	mCamera.setParameters(mCameraParameters);
	}
	}

	private int[] findClosestSize(int width, int height, Camera.Parameters parameters) {
	List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();
	int closestWidth = -1;
	int closestHeight = -1;
	int smallestWidth = previewSizes.get(0).width;
	int smallestHeight = previewSizes.get(0).height;
	for (Camera.Size size : previewSizes) {
	// Best match defined as not being larger in either dimension than
	// the requested size, but as close as possible. The below isn't a
	// stable selection (reording the size list can give different
	// results), but since this is a fallback nicety, that's acceptable.
	if ( size.width <= width &&
	size.height <= height &&
	size.width >= closestWidth &&
	size.height >= closestHeight) {
	closestWidth = size.width;
	closestHeight = size.height;
	}
	if ( size.width < smallestWidth &&
	size.height < smallestHeight) {
	smallestWidth = size.width;
	smallestHeight = size.height;
	}
	}
	if (closestWidth == -1) {
	// Requested size is smaller than any listed size; match with smallest possible
	closestWidth = smallestWidth;
	closestHeight = smallestHeight;
	}

	if (mLogVerbose) {
	Log.v(TAG,
	"Requested resolution: (" + width + ", " + height
	+ "). Closest match: (" + closestWidth + ", "
	+ closestHeight + ").");
	}
	int[] closestSize = {closestWidth, closestHeight};
	return closestSize;
	}

	private int[] findClosestFpsRange(int fps, Camera.Parameters params) {
	List<int[]> supportedFpsRanges = params.getSupportedPreviewFpsRange();
	int[] closestRange = supportedFpsRanges.get(0);
	for (int[] range : supportedFpsRanges) {
	if (range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] < fps*1000 &&
	range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] > fps*1000 &&
	range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] >
	closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] &&
	range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] <
	closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]) {
	closestRange = range;
	}
	}
	if (mLogVerbose) Log.v(TAG, "Requested fps: " + fps
	+ ".Closest frame rate range: ["
	+ closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] / 1000.
	+ ","
	+ closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] / 1000.
	+ "]");

	return closestRange;
	}

	private SurfaceTexture.OnFrameAvailableListener onCameraFrameAvailableListener =
	new SurfaceTexture.OnFrameAvailableListener() {
	@Override
	public void onFrameAvailable(SurfaceTexture surfaceTexture) {
	if (mLogVerbose) Log.v(TAG, "New frame from camera");
	synchronized(CameraSource.this) {
	mNewFrameAvailable = true;
	CameraSource.this.notify();
	}
	}
	};

	}