android/filterpacks/videosrc/SurfaceTextureTarget.java - platform/prebuilts/fullsdk/sources/android-30 - 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.GLEnvironment;
 import android.filterfw.core.GLFrame;
 import android.filterfw.core.MutableFrameFormat;
 import android.filterfw.core.ShaderProgram;
 import android.filterfw.format.ImageFormat;

 import android.filterfw.geometry.Quad;
 import android.filterfw.geometry.Point;

 import android.graphics.SurfaceTexture;

 import android.util.Log;

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

     private final int RENDERMODE_STRETCH   = 0;
     private final int RENDERMODE_FIT       = 1;
     private final int RENDERMODE_FILL_CROP = 2;
     private final int RENDERMODE_CUSTOMIZE = 3;

     /** Required. Sets the destination surfaceTexture.
      */
     @GenerateFinalPort(name = "surfaceTexture")
     private SurfaceTexture mSurfaceTexture;

     /** Required. Sets the width of the output surfaceTexture images */
     @GenerateFinalPort(name = "width")
     private int mScreenWidth;

     /** Required. Sets the height of the output surfaceTexture images */
     @GenerateFinalPort(name = "height")
     private int mScreenHeight;


     /** Optional. Control how the incoming frames are rendered onto the
      * output. Default is FIT.
      * RENDERMODE_STRETCH: Just fill the output surfaceView.
      * RENDERMODE_FIT: Keep aspect ratio and fit without cropping. May
      * have black bars.
      * RENDERMODE_FILL_CROP: Keep aspect ratio and fit without black
      * bars. May crop.
      */
     @GenerateFieldPort(name = "renderMode", hasDefault = true)
     private String mRenderModeString;

     @GenerateFieldPort(name = "sourceQuad", hasDefault = true)
     private Quad mSourceQuad = new Quad(new Point(0.0f, 1.0f),
                                         new Point(1.0f, 1.0f),
                                         new Point(0.0f, 0.0f),
                                         new Point(1.0f, 0.0f));

     @GenerateFieldPort(name = "targetQuad", hasDefault = true)
     private Quad mTargetQuad = new Quad(new Point(0.0f, 0.0f),
                                         new Point(1.0f, 0.0f),
                                         new Point(0.0f, 1.0f),
                                         new Point(1.0f, 1.0f));

     private int mSurfaceId;

     private ShaderProgram mProgram;
     private GLFrame mScreen;
     private int mRenderMode = RENDERMODE_FIT;
     private float mAspectRatio = 1.f;

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

     public SurfaceTextureTarget(String name) {
         super(name);

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

     @Override
     public synchronized void setupPorts() {
         // Make sure we have a SurfaceView
         if (mSurfaceTexture == null) {
             throw new RuntimeException("Null SurfaceTexture passed to SurfaceTextureTarget");
         }

         // Add input port - will accept anything that's 4-channel.
         addMaskedInputPort("frame", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
     }

     public void updateRenderMode() {
         if (mLogVerbose) Log.v(TAG, "updateRenderMode. Thread: " + Thread.currentThread());
         if (mRenderModeString != null) {
             if (mRenderModeString.equals("stretch")) {
                 mRenderMode = RENDERMODE_STRETCH;
             } else if (mRenderModeString.equals("fit")) {
                 mRenderMode = RENDERMODE_FIT;
             } else if (mRenderModeString.equals("fill_crop")) {
                 mRenderMode = RENDERMODE_FILL_CROP;
             } else if (mRenderModeString.equals("customize")) {
                 mRenderMode = RENDERMODE_CUSTOMIZE;
             } else {
                 throw new RuntimeException("Unknown render mode '" + mRenderModeString + "'!");
             }
         }
         updateTargetRect();
     }

     @Override
     public void prepare(FilterContext context) {
         if (mLogVerbose) Log.v(TAG, "Prepare. Thread: " + Thread.currentThread());
         // Create identity shader to render, and make sure to render upside-down, as textures
         // are stored internally bottom-to-top.
         mProgram = ShaderProgram.createIdentity(context);
         mProgram.setSourceRect(0, 1, 1, -1);
         mProgram.setClearColor(0.0f, 0.0f, 0.0f);

         updateRenderMode();

         // Create a frame representing the screen
         MutableFrameFormat screenFormat = new MutableFrameFormat(FrameFormat.TYPE_BYTE,
                                                                  FrameFormat.TARGET_GPU);
         screenFormat.setBytesPerSample(4);
         screenFormat.setDimensions(mScreenWidth, mScreenHeight);
         mScreen = (GLFrame)context.getFrameManager().newBoundFrame(screenFormat,
                                                                    GLFrame.EXISTING_FBO_BINDING,
                                                                    0);
     }

     @Override
     public synchronized void open(FilterContext context) {
         // Set up SurfaceTexture internals
         if (mSurfaceTexture == null) {
             Log.e(TAG, "SurfaceTexture is null!!");
             throw new RuntimeException("Could not register SurfaceTexture: " + mSurfaceTexture);
         }
         mSurfaceId = context.getGLEnvironment().registerSurfaceTexture(
             mSurfaceTexture, mScreenWidth, mScreenHeight);
         if (mSurfaceId <= 0) {
             throw new RuntimeException("Could not register SurfaceTexture: " + mSurfaceTexture);
         }
     }


     // Once the surface is unregistered, we still need the surfacetexture reference.
     // That is because when the the filter graph stops and starts again, the app
     // may not set the mSurfaceTexture again on the filter. In some cases, the app
     // may not even know that the graph has re-started. So it is difficult to enforce
     // that condition on an app using this filter. The only case where we need
     // to let go of the mSurfaceTexure reference is when the app wants to shut
     // down the graph on purpose, such as in the disconnect call.
     @Override
     public synchronized void close(FilterContext context) {
         if (mSurfaceId > 0) {
             context.getGLEnvironment().unregisterSurfaceId(mSurfaceId);
             mSurfaceId = -1;
         }
     }

     // This should be called from the client side when the surfacetexture is no longer
     // valid. e.g. from onPause() in the application using the filter graph.
     // In this case, we need to let go of our surfacetexture reference.
     public synchronized void disconnect(FilterContext context) {
         if (mLogVerbose) Log.v(TAG, "disconnect");
         if (mSurfaceTexture == null) {
             Log.d(TAG, "SurfaceTexture is already null. Nothing to disconnect.");
             return;
         }
         mSurfaceTexture = null;
         // Make sure we unregister the surface as well if a surface was registered.
         // There can be a situation where the surface was not registered but the
         // surfacetexture was valid. For example, the disconnect can be called before
         // the filter was opened. Hence, the surfaceId may not be a valid one here,
         // and need to check for its validity.
         if (mSurfaceId > 0) {
             context.getGLEnvironment().unregisterSurfaceId(mSurfaceId);
             mSurfaceId = -1;
         }
     }

     @Override
     public synchronized void process(FilterContext context) {
         // Surface is not registered. Nothing to render into.
         if (mSurfaceId <= 0) {
             return;
         }
         GLEnvironment glEnv = context.getGLEnvironment();

         // Get input frame
         Frame input = pullInput("frame");
         boolean createdFrame = false;

         float currentAspectRatio =
           (float)input.getFormat().getWidth() / input.getFormat().getHeight();
         if (currentAspectRatio != mAspectRatio) {
             if (mLogVerbose) {
                 Log.v(TAG, "Process. New aspect ratio: " + currentAspectRatio +
                     ", previously: " + mAspectRatio + ". Thread: " + Thread.currentThread());
             }
             mAspectRatio = currentAspectRatio;
             updateTargetRect();
         }

         // See if we need to copy to GPU
         Frame gpuFrame = null;
         int target = input.getFormat().getTarget();
         if (target != FrameFormat.TARGET_GPU) {
             gpuFrame = context.getFrameManager().duplicateFrameToTarget(input,
                                                                         FrameFormat.TARGET_GPU);
             createdFrame = true;
         } else {
             gpuFrame = input;
         }

         // Activate our surface
         glEnv.activateSurfaceWithId(mSurfaceId);

         // Process
         mProgram.process(gpuFrame, mScreen);

         glEnv.setSurfaceTimestamp(input.getTimestamp());

         // And swap buffers
         glEnv.swapBuffers();

         if (createdFrame) {
             gpuFrame.release();
         }
     }

     @Override
     public void fieldPortValueUpdated(String name, FilterContext context) {
         if (mLogVerbose) Log.v(TAG, "FPVU. Thread: " + Thread.currentThread());
         updateRenderMode();
     }

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

     private void updateTargetRect() {
         if (mLogVerbose) Log.v(TAG, "updateTargetRect. Thread: " + Thread.currentThread());
         if (mScreenWidth > 0 && mScreenHeight > 0 && mProgram != null) {
             float screenAspectRatio = (float)mScreenWidth / mScreenHeight;
             float relativeAspectRatio = screenAspectRatio / mAspectRatio;
             if (mLogVerbose) {
                 Log.v(TAG, "UTR. screen w = " + (float)mScreenWidth + " x screen h = " +
                     (float)mScreenHeight + " Screen AR: " + screenAspectRatio +
                     ", frame AR: "  + mAspectRatio + ", relative AR: " + relativeAspectRatio);
             }

             if (relativeAspectRatio == 1.0f && mRenderMode != RENDERMODE_CUSTOMIZE) {
                 mProgram.setTargetRect(0, 0, 1, 1);
                 mProgram.setClearsOutput(false);
             } else {
                 switch (mRenderMode) {
                     case RENDERMODE_STRETCH:
                         mTargetQuad.p0.set(0f, 0.0f);
                         mTargetQuad.p1.set(1f, 0.0f);
                         mTargetQuad.p2.set(0f, 1.0f);
                         mTargetQuad.p3.set(1f, 1.0f);
                         mProgram.setClearsOutput(false);
                         break;
                     case RENDERMODE_FIT:
                         if (relativeAspectRatio > 1.0f) {
                             // Screen is wider than the camera, scale down X
                             mTargetQuad.p0.set(0.5f - 0.5f / relativeAspectRatio, 0.0f);
                             mTargetQuad.p1.set(0.5f + 0.5f / relativeAspectRatio, 0.0f);
                             mTargetQuad.p2.set(0.5f - 0.5f / relativeAspectRatio, 1.0f);
                             mTargetQuad.p3.set(0.5f + 0.5f / relativeAspectRatio, 1.0f);

                         } else {
                             // Screen is taller than the camera, scale down Y
                             mTargetQuad.p0.set(0.0f, 0.5f - 0.5f * relativeAspectRatio);
                             mTargetQuad.p1.set(1.0f, 0.5f - 0.5f * relativeAspectRatio);
                             mTargetQuad.p2.set(0.0f, 0.5f + 0.5f * relativeAspectRatio);
                             mTargetQuad.p3.set(1.0f, 0.5f + 0.5f * relativeAspectRatio);
                         }
                         mProgram.setClearsOutput(true);
                         break;
                     case RENDERMODE_FILL_CROP:
                         if (relativeAspectRatio > 1) {
                             // Screen is wider than the camera, crop in Y
                             mTargetQuad.p0.set(0.0f, 0.5f - 0.5f * relativeAspectRatio);
                             mTargetQuad.p1.set(1.0f, 0.5f - 0.5f * relativeAspectRatio);
                             mTargetQuad.p2.set(0.0f, 0.5f + 0.5f * relativeAspectRatio);
                             mTargetQuad.p3.set(1.0f, 0.5f + 0.5f * relativeAspectRatio);
                         } else {
                             // Screen is taller than the camera, crop in X
                             mTargetQuad.p0.set(0.5f - 0.5f / relativeAspectRatio, 0.0f);
                             mTargetQuad.p1.set(0.5f + 0.5f / relativeAspectRatio, 0.0f);
                             mTargetQuad.p2.set(0.5f - 0.5f / relativeAspectRatio, 1.0f);
                             mTargetQuad.p3.set(0.5f + 0.5f / relativeAspectRatio, 1.0f);
                         }
                         mProgram.setClearsOutput(true);
                         break;
                     case RENDERMODE_CUSTOMIZE:
                         ((ShaderProgram) mProgram).setSourceRegion(mSourceQuad);
                         break;
                 }
                 if (mLogVerbose) Log.v(TAG,  "UTR. quad: " + mTargetQuad);
                 ((ShaderProgram) mProgram).setTargetRegion(mTargetQuad);
             }
         }
     }
 }
	/*
	* 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.GLEnvironment;
	import android.filterfw.core.GLFrame;
	import android.filterfw.core.MutableFrameFormat;
	import android.filterfw.core.ShaderProgram;
	import android.filterfw.format.ImageFormat;

	import android.filterfw.geometry.Quad;
	import android.filterfw.geometry.Point;

	import android.graphics.SurfaceTexture;

	import android.util.Log;

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

	private final int RENDERMODE_STRETCH = 0;
	private final int RENDERMODE_FIT = 1;
	private final int RENDERMODE_FILL_CROP = 2;
	private final int RENDERMODE_CUSTOMIZE = 3;

	/** Required. Sets the destination surfaceTexture.
	*/
	@GenerateFinalPort(name = "surfaceTexture")
	private SurfaceTexture mSurfaceTexture;

	/** Required. Sets the width of the output surfaceTexture images */
	@GenerateFinalPort(name = "width")
	private int mScreenWidth;

	/** Required. Sets the height of the output surfaceTexture images */
	@GenerateFinalPort(name = "height")
	private int mScreenHeight;


	/** Optional. Control how the incoming frames are rendered onto the
	* output. Default is FIT.
	* RENDERMODE_STRETCH: Just fill the output surfaceView.
	* RENDERMODE_FIT: Keep aspect ratio and fit without cropping. May
	* have black bars.
	* RENDERMODE_FILL_CROP: Keep aspect ratio and fit without black
	* bars. May crop.
	*/
	@GenerateFieldPort(name = "renderMode", hasDefault = true)
	private String mRenderModeString;

	@GenerateFieldPort(name = "sourceQuad", hasDefault = true)
	private Quad mSourceQuad = new Quad(new Point(0.0f, 1.0f),
	new Point(1.0f, 1.0f),
	new Point(0.0f, 0.0f),
	new Point(1.0f, 0.0f));

	@GenerateFieldPort(name = "targetQuad", hasDefault = true)
	private Quad mTargetQuad = new Quad(new Point(0.0f, 0.0f),
	new Point(1.0f, 0.0f),
	new Point(0.0f, 1.0f),
	new Point(1.0f, 1.0f));

	private int mSurfaceId;

	private ShaderProgram mProgram;
	private GLFrame mScreen;
	private int mRenderMode = RENDERMODE_FIT;
	private float mAspectRatio = 1.f;

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

	public SurfaceTextureTarget(String name) {
	super(name);

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

	@Override
	public synchronized void setupPorts() {
	// Make sure we have a SurfaceView
	if (mSurfaceTexture == null) {
	throw new RuntimeException("Null SurfaceTexture passed to SurfaceTextureTarget");
	}

	// Add input port - will accept anything that's 4-channel.
	addMaskedInputPort("frame", ImageFormat.create(ImageFormat.COLORSPACE_RGBA));
	}

	public void updateRenderMode() {
	if (mLogVerbose) Log.v(TAG, "updateRenderMode. Thread: " + Thread.currentThread());
	if (mRenderModeString != null) {
	if (mRenderModeString.equals("stretch")) {
	mRenderMode = RENDERMODE_STRETCH;
	} else if (mRenderModeString.equals("fit")) {
	mRenderMode = RENDERMODE_FIT;
	} else if (mRenderModeString.equals("fill_crop")) {
	mRenderMode = RENDERMODE_FILL_CROP;
	} else if (mRenderModeString.equals("customize")) {
	mRenderMode = RENDERMODE_CUSTOMIZE;
	} else {
	throw new RuntimeException("Unknown render mode '" + mRenderModeString + "'!");
	}
	}
	updateTargetRect();
	}

	@Override
	public void prepare(FilterContext context) {
	if (mLogVerbose) Log.v(TAG, "Prepare. Thread: " + Thread.currentThread());
	// Create identity shader to render, and make sure to render upside-down, as textures
	// are stored internally bottom-to-top.
	mProgram = ShaderProgram.createIdentity(context);
	mProgram.setSourceRect(0, 1, 1, -1);
	mProgram.setClearColor(0.0f, 0.0f, 0.0f);

	updateRenderMode();

	// Create a frame representing the screen
	MutableFrameFormat screenFormat = new MutableFrameFormat(FrameFormat.TYPE_BYTE,
	FrameFormat.TARGET_GPU);
	screenFormat.setBytesPerSample(4);
	screenFormat.setDimensions(mScreenWidth, mScreenHeight);
	mScreen = (GLFrame)context.getFrameManager().newBoundFrame(screenFormat,
	GLFrame.EXISTING_FBO_BINDING,
	0);
	}

	@Override
	public synchronized void open(FilterContext context) {
	// Set up SurfaceTexture internals
	if (mSurfaceTexture == null) {
	Log.e(TAG, "SurfaceTexture is null!!");
	throw new RuntimeException("Could not register SurfaceTexture: " + mSurfaceTexture);
	}
	mSurfaceId = context.getGLEnvironment().registerSurfaceTexture(
	mSurfaceTexture, mScreenWidth, mScreenHeight);
	if (mSurfaceId <= 0) {
	throw new RuntimeException("Could not register SurfaceTexture: " + mSurfaceTexture);
	}
	}


	// Once the surface is unregistered, we still need the surfacetexture reference.
	// That is because when the the filter graph stops and starts again, the app
	// may not set the mSurfaceTexture again on the filter. In some cases, the app
	// may not even know that the graph has re-started. So it is difficult to enforce
	// that condition on an app using this filter. The only case where we need
	// to let go of the mSurfaceTexure reference is when the app wants to shut
	// down the graph on purpose, such as in the disconnect call.
	@Override
	public synchronized void close(FilterContext context) {
	if (mSurfaceId > 0) {
	context.getGLEnvironment().unregisterSurfaceId(mSurfaceId);
	mSurfaceId = -1;
	}
	}

	// This should be called from the client side when the surfacetexture is no longer
	// valid. e.g. from onPause() in the application using the filter graph.
	// In this case, we need to let go of our surfacetexture reference.
	public synchronized void disconnect(FilterContext context) {
	if (mLogVerbose) Log.v(TAG, "disconnect");
	if (mSurfaceTexture == null) {
	Log.d(TAG, "SurfaceTexture is already null. Nothing to disconnect.");
	return;
	}
	mSurfaceTexture = null;
	// Make sure we unregister the surface as well if a surface was registered.
	// There can be a situation where the surface was not registered but the
	// surfacetexture was valid. For example, the disconnect can be called before
	// the filter was opened. Hence, the surfaceId may not be a valid one here,
	// and need to check for its validity.
	if (mSurfaceId > 0) {
	context.getGLEnvironment().unregisterSurfaceId(mSurfaceId);
	mSurfaceId = -1;
	}
	}

	@Override
	public synchronized void process(FilterContext context) {
	// Surface is not registered. Nothing to render into.
	if (mSurfaceId <= 0) {
	return;
	}
	GLEnvironment glEnv = context.getGLEnvironment();

	// Get input frame
	Frame input = pullInput("frame");
	boolean createdFrame = false;

	float currentAspectRatio =
	(float)input.getFormat().getWidth() / input.getFormat().getHeight();
	if (currentAspectRatio != mAspectRatio) {
	if (mLogVerbose) {
	Log.v(TAG, "Process. New aspect ratio: " + currentAspectRatio +
	", previously: " + mAspectRatio + ". Thread: " + Thread.currentThread());
	}
	mAspectRatio = currentAspectRatio;
	updateTargetRect();
	}

	// See if we need to copy to GPU
	Frame gpuFrame = null;
	int target = input.getFormat().getTarget();
	if (target != FrameFormat.TARGET_GPU) {
	gpuFrame = context.getFrameManager().duplicateFrameToTarget(input,
	FrameFormat.TARGET_GPU);
	createdFrame = true;
	} else {
	gpuFrame = input;
	}

	// Activate our surface
	glEnv.activateSurfaceWithId(mSurfaceId);

	// Process
	mProgram.process(gpuFrame, mScreen);

	glEnv.setSurfaceTimestamp(input.getTimestamp());

	// And swap buffers
	glEnv.swapBuffers();

	if (createdFrame) {
	gpuFrame.release();
	}
	}

	@Override
	public void fieldPortValueUpdated(String name, FilterContext context) {
	if (mLogVerbose) Log.v(TAG, "FPVU. Thread: " + Thread.currentThread());
	updateRenderMode();
	}

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

	private void updateTargetRect() {
	if (mLogVerbose) Log.v(TAG, "updateTargetRect. Thread: " + Thread.currentThread());
	if (mScreenWidth > 0 && mScreenHeight > 0 && mProgram != null) {
	float screenAspectRatio = (float)mScreenWidth / mScreenHeight;
	float relativeAspectRatio = screenAspectRatio / mAspectRatio;
	if (mLogVerbose) {
	Log.v(TAG, "UTR. screen w = " + (float)mScreenWidth + " x screen h = " +
	(float)mScreenHeight + " Screen AR: " + screenAspectRatio +
	", frame AR: " + mAspectRatio + ", relative AR: " + relativeAspectRatio);
	}

	if (relativeAspectRatio == 1.0f && mRenderMode != RENDERMODE_CUSTOMIZE) {
	mProgram.setTargetRect(0, 0, 1, 1);
	mProgram.setClearsOutput(false);
	} else {
	switch (mRenderMode) {
	case RENDERMODE_STRETCH:
	mTargetQuad.p0.set(0f, 0.0f);
	mTargetQuad.p1.set(1f, 0.0f);
	mTargetQuad.p2.set(0f, 1.0f);
	mTargetQuad.p3.set(1f, 1.0f);
	mProgram.setClearsOutput(false);
	break;
	case RENDERMODE_FIT:
	if (relativeAspectRatio > 1.0f) {
	// Screen is wider than the camera, scale down X
	mTargetQuad.p0.set(0.5f - 0.5f / relativeAspectRatio, 0.0f);
	mTargetQuad.p1.set(0.5f + 0.5f / relativeAspectRatio, 0.0f);
	mTargetQuad.p2.set(0.5f - 0.5f / relativeAspectRatio, 1.0f);
	mTargetQuad.p3.set(0.5f + 0.5f / relativeAspectRatio, 1.0f);

	} else {
	// Screen is taller than the camera, scale down Y
	mTargetQuad.p0.set(0.0f, 0.5f - 0.5f * relativeAspectRatio);
	mTargetQuad.p1.set(1.0f, 0.5f - 0.5f * relativeAspectRatio);
	mTargetQuad.p2.set(0.0f, 0.5f + 0.5f * relativeAspectRatio);
	mTargetQuad.p3.set(1.0f, 0.5f + 0.5f * relativeAspectRatio);
	}
	mProgram.setClearsOutput(true);
	break;
	case RENDERMODE_FILL_CROP:
	if (relativeAspectRatio > 1) {
	// Screen is wider than the camera, crop in Y
	mTargetQuad.p0.set(0.0f, 0.5f - 0.5f * relativeAspectRatio);
	mTargetQuad.p1.set(1.0f, 0.5f - 0.5f * relativeAspectRatio);
	mTargetQuad.p2.set(0.0f, 0.5f + 0.5f * relativeAspectRatio);
	mTargetQuad.p3.set(1.0f, 0.5f + 0.5f * relativeAspectRatio);
	} else {
	// Screen is taller than the camera, crop in X
	mTargetQuad.p0.set(0.5f - 0.5f / relativeAspectRatio, 0.0f);
	mTargetQuad.p1.set(0.5f + 0.5f / relativeAspectRatio, 0.0f);
	mTargetQuad.p2.set(0.5f - 0.5f / relativeAspectRatio, 1.0f);
	mTargetQuad.p3.set(0.5f + 0.5f / relativeAspectRatio, 1.0f);
	}
	mProgram.setClearsOutput(true);
	break;
	case RENDERMODE_CUSTOMIZE:
	((ShaderProgram) mProgram).setSourceRegion(mSourceQuad);
	break;
	}
	if (mLogVerbose) Log.v(TAG, "UTR. quad: " + mTargetQuad);
	((ShaderProgram) mProgram).setTargetRegion(mTargetQuad);
	}
	}
	}
	}