Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Returns the maximum number of Other effects.

 *

 * @return The maximum number of Other effects

 */

  public static int getMaxOther()

    {

    return EffectQueue.getMax(EffectTypes.OTHER.ordinal());

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Sets the maximum number of Other effects that can be applied to a single DistortedObject at one time.

 * This can fail if the value of 'max' is outside permitted range.

 *

 * @param max new maximum number of simultaneous Other Effects. Has to be a non-negative number not greater

 *            than Byte.MAX_VALUE

 * @return <code>true</code> if operation was successful, <code>false</code> otherwise.

 */

  public static boolean setMaxOther(int max)

    {

    return EffectQueue.setMax(EffectTypes.OTHER.ordinal(),max);

    }

    protected EffectQueueOther mO;

      mO= new EffectQueueOther(d); // Other effects are never cloned.

      mO.send();

      mO.abortAll();

      mO            = null;

     mO.addListener(el);

     mO.removeListener(el);

      return mM.abortAll() + mV.abortAll() + mF.abortAll() + mO.abortAll();

        case OTHER   : return mO.abortAll();

      if( type==EffectTypes.OTHER.type    ) return mO.removeByID(id>>EffectTypes.LENGTH);

        case OTHER   : return mO.removeByType(name);

      if( type==EffectTypes.OTHER.type    )  return mO.printByID(id>>EffectTypes.LENGTH);

///////////////////////////////////////////////////////////////////////////////////////////////////   

///////////////////////////////////////////////////////////////////////////////////////////////////

// Other-based effects

///////////////////////////////////////////////////////////////////////////////////////////////////

// SAVE_PNG

/**

 * Save the current state of the Object that's backing up our DistortedObject to a PNG file.

 *

 * @param filename Full path to the file.

 * @return         ID of the effect added, or -1 if we failed to add one.

 */

 public long savePNG(String filename, int left, int top, int width, int height)

   {

   return mO.add(EffectNames.SAVE_PNG, filename, left, top, width, height);

   }

  SMOOTH_HUE       ( EffectTypes.FRAGMENT,   new float[] {0.0f}           ),

  SAVE_PNG         ( EffectTypes.OTHER   ,   null                         ),      // OTHER Effects don't have Unities.

  SAVE_MP4         ( EffectTypes.OTHER   ,   null                         );      //

  // add new Other effects here...

    if( ordinal<SAVE_PNG.ordinal()    ) return EffectTypes.FRAGMENT;

    return EffectTypes.OTHER;

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library;

///////////////////////////////////////////////////////////////////////////////////////////////////

import android.graphics.Bitmap;

import android.opengl.GLES20;

import org.distorted.library.message.EffectMessage;

import java.io.BufferedOutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

class EffectQueueOther extends EffectQueue

  {

  private static final int NUM_UNIFORMS = 4;

  private static final int INDEX = EffectTypes.OTHER.ordinal();

  private String[] mFilename;

///////////////////////////////////////////////////////////////////////////////////////////////////

  public EffectQueueOther(DistortedObject obj)

    {

    super(obj,NUM_UNIFORMS, INDEX );

    if( mMax[INDEX]>0 )

      {

      mFilename= new String[mMax[INDEX]];

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  protected void moveEffect(int index)

    {

    mFilename[index] = mFilename[index+1];

    mUniforms[NUM_UNIFORMS*index  ] = mUniforms[NUM_UNIFORMS*(index+1)  ];

    mUniforms[NUM_UNIFORMS*index+1] = mUniforms[NUM_UNIFORMS*(index+1)+1];

    mUniforms[NUM_UNIFORMS*index+2] = mUniforms[NUM_UNIFORMS*(index+1)+2];

    mUniforms[NUM_UNIFORMS*index+3] = mUniforms[NUM_UNIFORMS*(index+1)+3];

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// runs on the graphics thread

  synchronized void send()

    {

    for(int i=0; i<mNumEffects; i++)

      {

      if (mType[i] == EffectNames.SAVE_PNG.ordinal() )

        {

        int left  = (int)mUniforms[NUM_UNIFORMS*i  ];

        int top   = (int)mUniforms[NUM_UNIFORMS*i+1];

        int width = (int)mUniforms[NUM_UNIFORMS*i+2];

        int height= (int)mUniforms[NUM_UNIFORMS*i+3];

        ByteBuffer buf = ByteBuffer.allocateDirect( width*height*4 );

        buf.order(ByteOrder.LITTLE_ENDIAN);

        GLES20.glReadPixels( left, top, width, height , GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, buf);

        flipUpsideDown(buf,width,height); // GL uses a coordinate system from mathematics; i.e.

                                          // (0,0) is in the lower-left corner. 2D stuff has

                                          // the origin on the upper-left corner; we have to flip

                                          // out bitmap upside down!

        buf.rewind();

        BufferedOutputStream bos = null;

        try

          {

          bos = new BufferedOutputStream(new FileOutputStream(mFilename[i]));

          Bitmap bmp = Bitmap.createBitmap( width, height, Bitmap.Config.ARGB_8888);

          bmp.copyPixelsFromBuffer(buf);

          bmp.compress(Bitmap.CompressFormat.PNG, 90, bos);

          bmp.recycle();

          for(int j=0; j<mNumListeners; j++)

            EffectMessageSender.newMessage( mListeners.elementAt(j),

                                            EffectMessage.EFFECT_FINISHED,

                                           (mID[i]<<EffectTypes.LENGTH)+EffectTypes.OTHER.type,

                                            mType[i],

                                            mBitmapID,

                                            null);

          }

        catch(Exception e)

          {

          for(int j=0; j<mNumListeners; j++)

            EffectMessageSender.newMessage( mListeners.elementAt(j),

                                            EffectMessage.EFFECT_FAILED,

                                           (mID[i]<<EffectTypes.LENGTH)+EffectTypes.OTHER.type,

                                            mType[i],

                                            mBitmapID,

                                            e.getMessage());

          }

        finally

          {

          if (bos != null)

            {

            try {bos.close();}

            catch(IOException io ) {}

            }

          }

        remove(i);

        i--;

        continue;

        }

      else if (mType[i] == EffectNames.SAVE_MP4.ordinal() )

        {

        // TODO: Implement SAVE_MP4 HERE

        }

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  synchronized long add(EffectNames eln, String filename, int left, int top, int width, int height)

    {

    if( mMax[INDEX]>mNumEffects )

      {

      mFilename[mNumEffects] = filename;

      mInterI[mNumEffects] = null;

      mInterP[mNumEffects] = null;

      mUniforms[NUM_UNIFORMS*mNumEffects  ] =  left;

      mUniforms[NUM_UNIFORMS*mNumEffects+1] =   top;

      mUniforms[NUM_UNIFORMS*mNumEffects+2] = width;

      mUniforms[NUM_UNIFORMS*mNumEffects+3] =height;

      return addBase(eln);

      }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void flipUpsideDown(ByteBuffer buf, int width, int height)

    {

    byte[] tmp1 = new byte[width*4];

    byte[] tmp2 = new byte[width*4];

    for(int i=0; i<height/2; i++)

      {

      buf.position((         i)*width*4);

      buf.get(tmp1);

      buf.position((height-1-i)*width*4);

      buf.get(tmp2);

      buf.position((         i)*width*4);

      buf.put(tmp2);

      buf.position((height-1-i)*width*4);

      buf.put(tmp1);

      }

    }

  }

  FRAGMENT ( 0x4 ),

  /**

   * Effects that did not belong to anywhere else - currently only saving the contents of underlying

   * Surface to a PNG or a MP4 file.

   */

  OTHER    ( 0x8 );

    maxtable[3] = 5;  // Max 5 OTHER Effects