content: /*
   * 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);
              }
          }
      }
  }
  