SurfaceTexture.java revision 554366d158a0ec330a339f4343fb0a3164257f1e
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.graphics; 18 19import java.lang.ref.WeakReference; 20import android.os.Handler; 21import android.os.Looper; 22import android.os.Message; 23 24/** 25 * Captures frames from an image stream as an OpenGL ES texture. 26 * 27 * <p>The image stream may come from either camera preview or video decode. A SurfaceTexture 28 * may be used in place of a SurfaceHolder when specifying the output destination of a 29 * {@link android.hardware.Camera} or {@link android.media.MediaPlayer} 30 * object. Doing so will cause all the frames from the image stream to be sent to the 31 * SurfaceTexture object rather than to the device's display. When {@link #updateTexImage} is 32 * called, the contents of the texture object specified when the SurfaceTexture was created are 33 * updated to contain the most recent image from the image stream. This may cause some frames of 34 * the stream to be skipped. 35 * 36 * <p>When sampling from the texture one should first transform the texture coordinates using the 37 * matrix queried via {@link #getTransformMatrix(float[])}. The transform matrix may change each 38 * time {@link #updateTexImage} is called, so it should be re-queried each time the texture image 39 * is updated. 40 * This matrix transforms traditional 2D OpenGL ES texture coordinate column vectors of the form (s, 41 * t, 0, 1) where s and t are on the inclusive interval [0, 1] to the proper sampling location in 42 * the streamed texture. This transform compensates for any properties of the image stream source 43 * that cause it to appear different from a traditional OpenGL ES texture. For example, sampling 44 * from the bottom left corner of the image can be accomplished by transforming the column vector 45 * (0, 0, 0, 1) using the queried matrix, while sampling from the top right corner of the image can 46 * be done by transforming (1, 1, 0, 1). 47 * 48 * <p>The texture object uses the GL_TEXTURE_EXTERNAL_OES texture target, which is defined by the 49 * <a href="http://www.khronos.org/registry/gles/extensions/OES/OES_EGL_image_external.txt"> 50 * GL_OES_EGL_image_external</a> OpenGL ES extension. This limits how the texture may be used. 51 * Each time the texture is bound it must be bound to the GL_TEXTURE_EXTERNAL_OES target rather than 52 * the GL_TEXTURE_2D target. Additionally, any OpenGL ES 2.0 shader that samples from the texture 53 * must declare its use of this extension using, for example, an "#extension 54 * GL_OES_EGL_image_external : require" directive. Such shaders must also access the texture using 55 * the samplerExternalOES GLSL sampler type. 56 * 57 * <p>SurfaceTexture objects may be created on any thread. {@link #updateTexImage} may only be 58 * called on the thread with the OpenGL ES context that contains the texture object. The 59 * frame-available callback is called on an arbitrary thread, so unless special care is taken {@link 60 * #updateTexImage} should not be called directly from the callback. 61 */ 62public class SurfaceTexture { 63 64 private EventHandler mEventHandler; 65 private OnFrameAvailableListener mOnFrameAvailableListener; 66 67 /** 68 * This field is used by native code, do not access or modify. 69 */ 70 private int mSurfaceTexture; 71 72 /** 73 * Callback interface for being notified that a new stream frame is available. 74 */ 75 public interface OnFrameAvailableListener { 76 void onFrameAvailable(SurfaceTexture surfaceTexture); 77 } 78 79 /** 80 * Exception thrown when a surface couldn't be created or resized 81 */ 82 public static class OutOfResourcesException extends Exception { 83 public OutOfResourcesException() { 84 } 85 public OutOfResourcesException(String name) { 86 super(name); 87 } 88 } 89 90 /** 91 * Construct a new SurfaceTexture to stream images to a given OpenGL texture. 92 * 93 * @param texName the OpenGL texture object name (e.g. generated via glGenTextures) 94 */ 95 public SurfaceTexture(int texName) { 96 this(texName, false); 97 } 98 99 /** 100 * Construct a new SurfaceTexture to stream images to a given OpenGL texture. 101 * 102 * @param texName the OpenGL texture object name (e.g. generated via glGenTextures) 103 * @param allowSynchronousMode whether the SurfaceTexture can run in the synchronous mode. 104 * When the image stream comes from OpenGL, SurfaceTexture may run in the synchronous 105 * mode where the producer side may be blocked to avoid skipping frames. To avoid the 106 * thread block, set allowSynchronousMode to false. 107 * 108 * @hide 109 */ 110 public SurfaceTexture(int texName, boolean allowSynchronousMode) { 111 Looper looper; 112 if ((looper = Looper.myLooper()) != null) { 113 mEventHandler = new EventHandler(looper); 114 } else if ((looper = Looper.getMainLooper()) != null) { 115 mEventHandler = new EventHandler(looper); 116 } else { 117 mEventHandler = null; 118 } 119 nativeInit(texName, new WeakReference<SurfaceTexture>(this), allowSynchronousMode); 120 } 121 122 /** 123 * Register a callback to be invoked when a new image frame becomes available to the 124 * SurfaceTexture. Note that this callback may be called on an arbitrary thread, so it is not 125 * safe to call {@link #updateTexImage} without first binding the OpenGL ES context to the 126 * thread invoking the callback. 127 */ 128 public void setOnFrameAvailableListener(OnFrameAvailableListener l) { 129 mOnFrameAvailableListener = l; 130 } 131 132 /** 133 * Set the size of buffers returned by requestBuffers when a width and height 134 * of zero is requested. 135 * 136 * @hide Pending approval by API council. 137 */ 138 public void setDefaultBufferSize(int width, int height) { 139 nativeSetDefaultBufferSize(width, height); 140 } 141 142 /** 143 * Update the texture image to the most recent frame from the image stream. This may only be 144 * called while the OpenGL ES context that owns the texture is bound to the thread. It will 145 * implicitly bind its texture to the GL_TEXTURE_EXTERNAL_OES texture target. 146 */ 147 public void updateTexImage() { 148 nativeUpdateTexImage(); 149 } 150 151 /** 152 * Retrieve the 4x4 texture coordinate transform matrix associated with the texture image set by 153 * the most recent call to updateTexImage. 154 * 155 * This transform matrix maps 2D homogeneous texture coordinates of the form (s, t, 0, 1) with s 156 * and t in the inclusive range [0, 1] to the texture coordinate that should be used to sample 157 * that location from the texture. Sampling the texture outside of the range of this transform 158 * is undefined. 159 * 160 * The matrix is stored in column-major order so that it may be passed directly to OpenGL ES via 161 * the glLoadMatrixf or glUniformMatrix4fv functions. 162 * 163 * @param mtx the array into which the 4x4 matrix will be stored. The array must have exactly 164 * 16 elements. 165 */ 166 public void getTransformMatrix(float[] mtx) { 167 // Note we intentionally don't check mtx for null, so this will result in a 168 // NullPointerException. But it's safe because it happens before the call to native. 169 if (mtx.length != 16) { 170 throw new IllegalArgumentException(); 171 } 172 nativeGetTransformMatrix(mtx); 173 } 174 175 /** 176 * Retrieve the timestamp associated with the texture image set by the most recent call to 177 * updateTexImage. 178 * 179 * This timestamp is in nanoseconds, and is normally monotonically increasing. The timestamp 180 * should be unaffected by time-of-day adjustments, and for a camera should be strictly 181 * monotonic but for a MediaPlayer may be reset when the position is set. The 182 * specific meaning and zero point of the timestamp depends on the source providing images to 183 * the SurfaceTexture. Unless otherwise specified by the image source, timestamps cannot 184 * generally be compared across SurfaceTexture instances, or across multiple program 185 * invocations. It is mostly useful for determining time offsets between subsequent frames. 186 */ 187 188 public long getTimestamp() { 189 return nativeGetTimestamp(); 190 } 191 192 /** 193 * release() frees all the buffers and puts the SurfaceTexture into the 194 * 'abandoned' state. Once put in this state the SurfaceTexture can never 195 * leave it. When in the 'abandoned' state, all methods of the 196 * ISurfaceTexture interface will fail with the NO_INIT error. 197 * 198 * Note that while calling this method causes all the buffers to be freed 199 * from the perspective of the the SurfaceTexture, if there are additional 200 * references on the buffers (e.g. if a buffer is referenced by a client or 201 * by OpenGL ES as a texture) then those buffer will remain allocated. 202 * 203 * Always call this method when you are done with SurfaceTexture. Failing 204 * to do so may delay resource deallocation for a significant amount of 205 * time. 206 */ 207 public void release() { 208 nativeRelease(); 209 } 210 211 protected void finalize() throws Throwable { 212 try { 213 nativeFinalize(); 214 } finally { 215 super.finalize(); 216 } 217 } 218 219 private class EventHandler extends Handler { 220 public EventHandler(Looper looper) { 221 super(looper); 222 } 223 224 @Override 225 public void handleMessage(Message msg) { 226 if (mOnFrameAvailableListener != null) { 227 mOnFrameAvailableListener.onFrameAvailable(SurfaceTexture.this); 228 } 229 } 230 } 231 232 /** 233 * This method is invoked from native code only. 234 */ 235 @SuppressWarnings({"UnusedDeclaration"}) 236 private static void postEventFromNative(Object selfRef) { 237 WeakReference weakSelf = (WeakReference)selfRef; 238 SurfaceTexture st = (SurfaceTexture)weakSelf.get(); 239 if (st == null) { 240 return; 241 } 242 243 if (st.mEventHandler != null) { 244 Message m = st.mEventHandler.obtainMessage(); 245 st.mEventHandler.sendMessage(m); 246 } 247 } 248 249 private native void nativeInit(int texName, Object weakSelf, boolean allowSynchronousMode); 250 private native void nativeFinalize(); 251 private native void nativeGetTransformMatrix(float[] mtx); 252 private native long nativeGetTimestamp(); 253 private native void nativeSetDefaultBufferSize(int width, int height); 254 private native void nativeUpdateTexImage(); 255 private native int nativeGetQueuedCount(); 256 private native void nativeRelease(); 257 258 /* 259 * We use a class initializer to allow the native code to cache some 260 * field offsets. 261 */ 262 private static native void nativeClassInit(); 263 static { nativeClassInit(); } 264} 265