Distorted Android

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

// 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 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);

      }

    }

  }