1 /* 2 * Copyright (C) 2014 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 17 package android.hardware.camera2.legacy; 18 19 import android.graphics.SurfaceTexture; 20 import android.hardware.camera2.impl.CameraDeviceImpl; 21 import android.os.ConditionVariable; 22 import android.os.Handler; 23 import android.os.Message; 24 import android.util.Log; 25 import android.util.Pair; 26 import android.util.Size; 27 import android.view.Surface; 28 29 import java.util.Collection; 30 31 import static com.android.internal.util.Preconditions.*; 32 33 /** 34 * GLThreadManager handles the thread used for rendering into the configured output surfaces. 35 */ 36 public class GLThreadManager { 37 private final String TAG; 38 private static final boolean DEBUG = false; 39 40 private static final int MSG_NEW_CONFIGURATION = 1; 41 private static final int MSG_NEW_FRAME = 2; 42 private static final int MSG_CLEANUP = 3; 43 private static final int MSG_DROP_FRAMES = 4; 44 private static final int MSG_ALLOW_FRAMES = 5; 45 46 private CaptureCollector mCaptureCollector; 47 48 private final CameraDeviceState mDeviceState; 49 50 private final SurfaceTextureRenderer mTextureRenderer; 51 52 private final RequestHandlerThread mGLHandlerThread; 53 54 private final RequestThreadManager.FpsCounter mPrevCounter = 55 new RequestThreadManager.FpsCounter("GL Preview Producer"); 56 57 /** 58 * Container object for Configure messages. 59 */ 60 private static class ConfigureHolder { 61 public final ConditionVariable condition; 62 public final Collection<Pair<Surface, Size>> surfaces; 63 public final CaptureCollector collector; 64 65 public ConfigureHolder(ConditionVariable condition, Collection<Pair<Surface, 66 Size>> surfaces, CaptureCollector collector) { 67 this.condition = condition; 68 this.surfaces = surfaces; 69 this.collector = collector; 70 } 71 } 72 73 private final Handler.Callback mGLHandlerCb = new Handler.Callback() { 74 private boolean mCleanup = false; 75 private boolean mConfigured = false; 76 private boolean mDroppingFrames = false; 77 78 @SuppressWarnings("unchecked") 79 @Override 80 public boolean handleMessage(Message msg) { 81 if (mCleanup) { 82 return true; 83 } 84 try { 85 switch (msg.what) { 86 case MSG_NEW_CONFIGURATION: 87 ConfigureHolder configure = (ConfigureHolder) msg.obj; 88 mTextureRenderer.cleanupEGLContext(); 89 mTextureRenderer.configureSurfaces(configure.surfaces); 90 mCaptureCollector = checkNotNull(configure.collector); 91 configure.condition.open(); 92 mConfigured = true; 93 break; 94 case MSG_NEW_FRAME: 95 if (mDroppingFrames) { 96 Log.w(TAG, "Ignoring frame."); 97 break; 98 } 99 if (DEBUG) { 100 mPrevCounter.countAndLog(); 101 } 102 if (!mConfigured) { 103 Log.e(TAG, "Dropping frame, EGL context not configured!"); 104 } 105 mTextureRenderer.drawIntoSurfaces(mCaptureCollector); 106 break; 107 case MSG_CLEANUP: 108 mTextureRenderer.cleanupEGLContext(); 109 mCleanup = true; 110 mConfigured = false; 111 break; 112 case MSG_DROP_FRAMES: 113 mDroppingFrames = true; 114 break; 115 case MSG_ALLOW_FRAMES: 116 mDroppingFrames = false; 117 break; 118 case RequestHandlerThread.MSG_POKE_IDLE_HANDLER: 119 // OK: Ignore message. 120 break; 121 default: 122 Log.e(TAG, "Unhandled message " + msg.what + " on GLThread."); 123 break; 124 } 125 } catch (Exception e) { 126 Log.e(TAG, "Received exception on GL render thread: ", e); 127 mDeviceState.setError(CameraDeviceImpl.CameraDeviceCallbacks.ERROR_CAMERA_DEVICE); 128 } 129 return true; 130 } 131 }; 132 133 /** 134 * Create a new GL thread and renderer. 135 * 136 * @param cameraId the camera id for this thread. 137 * @param facing direction the camera is facing. 138 * @param state {@link CameraDeviceState} to use for error handling. 139 */ 140 public GLThreadManager(int cameraId, int facing, CameraDeviceState state) { 141 mTextureRenderer = new SurfaceTextureRenderer(facing); 142 TAG = String.format("CameraDeviceGLThread-%d", cameraId); 143 mGLHandlerThread = new RequestHandlerThread(TAG, mGLHandlerCb); 144 mDeviceState = state; 145 } 146 147 /** 148 * Start the thread. 149 * 150 * <p> 151 * This must be called before queueing new frames. 152 * </p> 153 */ 154 public void start() { 155 mGLHandlerThread.start(); 156 } 157 158 /** 159 * Wait until the thread has started. 160 */ 161 public void waitUntilStarted() { 162 mGLHandlerThread.waitUntilStarted(); 163 } 164 165 /** 166 * Quit the thread. 167 * 168 * <p> 169 * No further methods can be called after this. 170 * </p> 171 */ 172 public void quit() { 173 Handler handler = mGLHandlerThread.getHandler(); 174 handler.sendMessageAtFrontOfQueue(handler.obtainMessage(MSG_CLEANUP)); 175 mGLHandlerThread.quitSafely(); 176 try { 177 mGLHandlerThread.join(); 178 } catch (InterruptedException e) { 179 Log.e(TAG, String.format("Thread %s (%d) interrupted while quitting.", 180 mGLHandlerThread.getName(), mGLHandlerThread.getId())); 181 } 182 } 183 184 /** 185 * Queue a new call to draw into the surfaces specified in the next available preview 186 * request from the {@link CaptureCollector} passed to 187 * {@link #setConfigurationAndWait(java.util.Collection, CaptureCollector)}; 188 */ 189 public void queueNewFrame() { 190 Handler handler = mGLHandlerThread.getHandler(); 191 192 /** 193 * Avoid queuing more than one new frame. If we are not consuming faster than frames 194 * are produced, drop frames rather than allowing the queue to back up. 195 */ 196 if (!handler.hasMessages(MSG_NEW_FRAME)) { 197 handler.sendMessage(handler.obtainMessage(MSG_NEW_FRAME)); 198 } else { 199 Log.e(TAG, "GLThread dropping frame. Not consuming frames quickly enough!"); 200 } 201 } 202 203 /** 204 * Configure the GL renderer for the given set of output surfaces, and block until 205 * this configuration has been applied. 206 * 207 * @param surfaces a collection of pairs of {@link android.view.Surface}s and their 208 * corresponding sizes to configure. 209 * @param collector a {@link CaptureCollector} to retrieve requests from. 210 */ 211 public void setConfigurationAndWait(Collection<Pair<Surface, Size>> surfaces, 212 CaptureCollector collector) { 213 checkNotNull(collector, "collector must not be null"); 214 Handler handler = mGLHandlerThread.getHandler(); 215 216 final ConditionVariable condition = new ConditionVariable(/*closed*/false); 217 ConfigureHolder configure = new ConfigureHolder(condition, surfaces, collector); 218 219 Message m = handler.obtainMessage(MSG_NEW_CONFIGURATION, /*arg1*/0, /*arg2*/0, configure); 220 handler.sendMessage(m); 221 222 // Block until configuration applied. 223 condition.block(); 224 } 225 226 /** 227 * Get the underlying surface to produce frames from. 228 * 229 * <p> 230 * This returns the surface that is drawn into the set of surfaces passed in for each frame. 231 * This method should only be called after a call to 232 * {@link #setConfigurationAndWait(java.util.Collection)}. Calling this before the first call 233 * to {@link #setConfigurationAndWait(java.util.Collection)}, after {@link #quit()}, or 234 * concurrently to one of these calls may result in an invalid 235 * {@link android.graphics.SurfaceTexture} being returned. 236 * </p> 237 * 238 * @return an {@link android.graphics.SurfaceTexture} to draw to. 239 */ 240 public SurfaceTexture getCurrentSurfaceTexture() { 241 return mTextureRenderer.getSurfaceTexture(); 242 } 243 244 /** 245 * Ignore any subsequent calls to {@link #queueNewFrame(java.util.Collection)}. 246 */ 247 public void ignoreNewFrames() { 248 mGLHandlerThread.getHandler().sendEmptyMessage(MSG_DROP_FRAMES); 249 } 250 251 /** 252 * Wait until no messages are queued. 253 */ 254 public void waitUntilIdle() { 255 mGLHandlerThread.waitUntilIdle(); 256 } 257 258 /** 259 * Re-enable drawing new frames after a call to {@link #ignoreNewFrames()}. 260 */ 261 public void allowNewFrames() { 262 mGLHandlerThread.getHandler().sendEmptyMessage(MSG_ALLOW_FRAMES); 263 } 264 } 265
