media/java/android/media/videoeditor/OverlayFrame.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2010 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.media.videoeditor;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.DataOutputStream;
 import java.nio.ByteBuffer;
 import java.nio.IntBuffer;

 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Bitmap.CompressFormat;
 import android.util.Pair;


 /**
  * This class is used to overlay an image on top of a media item.
  * {@hide}
  */
 public class OverlayFrame extends Overlay {
     /**
      *  Instance variables
      */
     private Bitmap mBitmap;
     private String mFilename;
     private String mBitmapFileName;

     private int mOFWidth;
     private int mOFHeight;

     /**
      * resized RGB Image dimensions
      */
     private int mResizedRGBWidth;
     private int mResizedRGBHeight;

     /**
      *  The resize paint
      */
     private static final Paint sResizePaint = new Paint(Paint.FILTER_BITMAP_FLAG);

     /**
      * An object of this type cannot be instantiated by using the default
      * constructor
      */
     @SuppressWarnings("unused")
     private OverlayFrame() {
         this(null, null, (String)null, 0, 0);
     }

     /**
      * Constructor for an OverlayFrame
      *
      * @param mediaItem The media item owner
      * @param overlayId The overlay id
      * @param bitmap The bitmap to be used as an overlay. The size of the
      *      bitmap must equal to the size of the media item to which it is
      *      added. The bitmap is typically a decoded PNG file.
      * @param startTimeMs The overlay start time in milliseconds
      * @param durationMs The overlay duration in milliseconds
      *
      * @throws IllegalArgumentException if the file type is not PNG or the
      *      startTimeMs and durationMs are incorrect.
      */
     public OverlayFrame(MediaItem mediaItem, String overlayId, Bitmap bitmap,
                         long startTimeMs,long durationMs) {
         super(mediaItem, overlayId, startTimeMs, durationMs);
         mBitmap = bitmap;
         mFilename = null;
         mBitmapFileName = null;
         mResizedRGBWidth = 0;
         mResizedRGBHeight = 0;
     }

     /**
      * Constructor for an OverlayFrame. This constructor can be used to
      * restore the overlay after it was saved internally by the video editor.
      *
      * @param mediaItem The media item owner
      * @param overlayId The overlay id
      * @param filename The file name that contains the overlay.
      * @param startTimeMs The overlay start time in milliseconds
      * @param durationMs The overlay duration in milliseconds
      *
      * @throws IllegalArgumentException if the file type is not PNG or the
      *      startTimeMs and durationMs are incorrect.
      */
     OverlayFrame(MediaItem mediaItem, String overlayId, String filename,
                  long startTimeMs,long durationMs) {
         super(mediaItem, overlayId, startTimeMs, durationMs);
         mBitmapFileName = filename;
         mBitmap = BitmapFactory.decodeFile(mBitmapFileName);
         mFilename = null;
         mResizedRGBWidth = 0;
         mResizedRGBHeight = 0;
     }

     /**
      * Get the overlay bitmap.
      *
      * @return Get the overlay bitmap
      */
     public Bitmap getBitmap() {
         return mBitmap;
     }

     /**
      * Get the overlay bitmap.
      *
      * @return Get the overlay bitmap as png file.
      */
     String getBitmapImageFileName() {
         return mBitmapFileName;
     }
     /**
      * Set the overlay bitmap.
      *
      * @param bitmap The overlay bitmap.
      */
     public void setBitmap(Bitmap bitmap) {
         getMediaItem().getNativeContext().setGeneratePreview(true);

         invalidate();

         mBitmap = bitmap;
         if (mFilename != null) {
             /**
              *  Delete the file
              */
             new File(mFilename).delete();
             /**
              *  Invalidate the filename
              */
             mFilename = null;
         }

         /**
          *  Invalidate the transitions if necessary
          */
         getMediaItem().invalidateTransitions(mStartTimeMs, mDurationMs);
     }

     /**
      * Get the file name of this overlay
      */
     String getFilename() {
         return mFilename;
     }

     /*
      * Set the file name of this overlay
      */
     void setFilename(String filename) {
         mFilename = filename;
     }
     /**
      * Save the overlay to the project folder
      *
      * @param path The path where the overlay will be saved
      *
      * @return The filename
      * @throws FileNotFoundException if the bitmap cannot be saved
      * @throws IOException if the bitmap file cannot be saved
      */
     String save(String path) throws FileNotFoundException, IOException {
         if (mFilename != null) {
             return mFilename;
         }

         // Create the compressed PNG file
         mBitmapFileName = path + "/" + "Overlay" + getId() + ".png";
         if (!(new File(mBitmapFileName).exists())) {
             final FileOutputStream out = new FileOutputStream (mBitmapFileName);
             mBitmap.compress(CompressFormat.PNG, 100, out);
             out.flush();
             out.close();
         }

         mOFWidth = mBitmap.getWidth();
         mOFHeight = mBitmap.getHeight();

         mFilename = path + "/" + "Overlay" + getId() + ".rgb";

         /* resize and save rgb as per project aspect ratio */
         MediaArtistNativeHelper nativeHelper = (super.getMediaItem()).getNativeContext();

         /* get height and width for story board aspect ratio */
         final Pair<Integer, Integer> maxResolution;
         final Pair<Integer, Integer>[] resolutions;
         resolutions = MediaProperties.getSupportedResolutions(nativeHelper.nativeHelperGetAspectRatio());

         // Get the highest resolution
         maxResolution = resolutions[resolutions.length - 1];

         /* Generate the rgb file with rendering mode */
         generateOverlayWithRenderingMode (super.getMediaItem(), this,
                 maxResolution.second /* max Height */ ,
                 maxResolution.first /* max Width */);

         return mFilename;
     }

     /**
      * Get the OverlayFrame Height
      */
      int getOverlayFrameHeight() {
          return mOFHeight;
      }

      /**
      * Get the OverlayFrame Width
      */
      int getOverlayFrameWidth() {
          return mOFWidth;
      }

     /*
      * Set the OverlayFrame Height
      */
      void setOverlayFrameHeight(int height) {
          mOFHeight = height;
      }

     /*
      * Set the OverlayFrame Width
      */
      void setOverlayFrameWidth(int width) {
          mOFWidth = width;
      }

     /*
      * Set the resized RGB widht and height
      */
      void setResizedRGBSize(int width, int height) {
         mResizedRGBWidth = width;
         mResizedRGBHeight = height;
      }

     /*
      * Get the resized RGB Height
      */
      int getResizedRGBSizeHeight() {
          return mResizedRGBHeight;
      }

     /*
      * Get the resized RGB Width
      */
      int getResizedRGBSizeWidth() {
          return mResizedRGBWidth;
      }


     /**
      * Delete the overlay files
      */
     void invalidate() {
         if (mBitmap != null) {
             mBitmap.recycle();
             mBitmap = null;
         }

         if (mFilename != null) {
             new File(mFilename).delete();
             mFilename = null;
         }

         if (mBitmapFileName != null) {
             new File(mBitmapFileName).delete();
             mBitmapFileName = null;
         }
     }

      /**
      * Delete the overlay related files
      */
     void invalidateGeneratedFiles() {
         if (mFilename != null) {
             new File(mFilename).delete();
             mFilename = null;
         }

         if (mBitmapFileName != null) {
             new File(mBitmapFileName).delete();
             mBitmapFileName = null;
         }
     }

     void generateOverlayWithRenderingMode (MediaItem mediaItemsList, OverlayFrame overlay, int height , int width)
         throws FileNotFoundException, IOException {

         final MediaItem t = mediaItemsList;

         /* get the rendering mode */
         int renderMode = t.getRenderingMode();

         Bitmap overlayBitmap = ((OverlayFrame)overlay).getBitmap();

         /*
          * Check if the resize of Overlay is needed with rendering mode applied
          * because of change in export dimensions
          */
         int resizedRGBFileHeight = ((OverlayFrame)overlay).getResizedRGBSizeHeight();
         int resizedRGBFileWidth = ((OverlayFrame)overlay).getResizedRGBSizeWidth();

         /* Get original bitmap width if it is not resized */
         if(resizedRGBFileWidth == 0) {
             resizedRGBFileWidth = overlayBitmap.getWidth();
         }
         /* Get original bitmap height if it is not resized */
         if(resizedRGBFileHeight == 0) {
             resizedRGBFileHeight = overlayBitmap.getHeight();
         }

         if (resizedRGBFileWidth != width || resizedRGBFileHeight != height
             || (!(new File(((OverlayFrame)overlay).getFilename()).exists()))) {
             /*
              *  Create the canvas bitmap
              */
             final Bitmap destBitmap = Bitmap.createBitmap((int)width,
                                                       (int)height,
                                                       Bitmap.Config.ARGB_8888);
             final Canvas overlayCanvas = new Canvas(destBitmap);
             final Rect destRect;
             final Rect srcRect;

             switch (renderMode) {
                 case MediaItem.RENDERING_MODE_STRETCH: {
                     destRect = new Rect(0, 0, overlayCanvas.getWidth(),
                                              overlayCanvas.getHeight());
                     srcRect = new Rect(0, 0, overlayBitmap.getWidth(),
                                              overlayBitmap.getHeight());
                     break;
                 }

                 case MediaItem.RENDERING_MODE_BLACK_BORDER: {
                     int left, right, top, bottom;
                     float aROverlayImage, aRCanvas;
                     aROverlayImage = (float)(overlayBitmap.getWidth()) /
                                      (float)(overlayBitmap.getHeight());

                     aRCanvas = (float)(overlayCanvas.getWidth()) /
                                      (float)(overlayCanvas.getHeight());

                     if (aROverlayImage > aRCanvas) {
                         int newHeight = ((overlayCanvas.getWidth() * overlayBitmap.getHeight())
                                          / overlayBitmap.getWidth());
                         left = 0;
                         top  = (overlayCanvas.getHeight() - newHeight) / 2;
                         right = overlayCanvas.getWidth();
                         bottom = top + newHeight;
                     } else {
                         int newWidth = ((overlayCanvas.getHeight() * overlayBitmap.getWidth())
                                             / overlayBitmap.getHeight());
                         left = (overlayCanvas.getWidth() - newWidth) / 2;
                         top  = 0;
                         right = left + newWidth;
                         bottom = overlayCanvas.getHeight();
                     }

                     destRect = new Rect(left, top, right, bottom);
                     srcRect = new Rect(0, 0, overlayBitmap.getWidth(), overlayBitmap.getHeight());
                     break;
                 }

                 case MediaItem.RENDERING_MODE_CROPPING: {
                     // Calculate the source rect
                     int left, right, top, bottom;
                     float aROverlayImage, aRCanvas;
                     aROverlayImage = (float)(overlayBitmap.getWidth()) /
                                      (float)(overlayBitmap.getHeight());
                     aRCanvas = (float)(overlayCanvas.getWidth()) /
                                     (float)(overlayCanvas.getHeight());
                     if (aROverlayImage < aRCanvas) {
                         int newHeight = ((overlayBitmap.getWidth() * overlayCanvas.getHeight())
                                    / overlayCanvas.getWidth());

                         left = 0;
                         top  = (overlayBitmap.getHeight() - newHeight) / 2;
                         right = overlayBitmap.getWidth();
                         bottom = top + newHeight;
                     } else {
                         int newWidth = ((overlayBitmap.getHeight() * overlayCanvas.getWidth())
                                     / overlayCanvas.getHeight());
                         left = (overlayBitmap.getWidth() - newWidth) / 2;
                         top  = 0;
                         right = left + newWidth;
                         bottom = overlayBitmap.getHeight();
                     }

                     srcRect = new Rect(left, top, right, bottom);
                     destRect = new Rect(0, 0, overlayCanvas.getWidth(), overlayCanvas.getHeight());
                     break;
                 }

                 default: {
                     throw new IllegalStateException("Rendering mode: " + renderMode);
                 }
             }

             overlayCanvas.drawBitmap(overlayBitmap, srcRect, destRect, sResizePaint);
             overlayCanvas.setBitmap(null);

             /*
              * Write to the dest file
              */
             String outFileName = ((OverlayFrame)overlay).getFilename();

             /*
              * Save the image to same rgb file
              */
             if (outFileName != null) {
                 new File(outFileName).delete();
             }

             final FileOutputStream fl = new FileOutputStream(outFileName);
             final DataOutputStream dos = new DataOutputStream(fl);

             /*
              * Populate the rgb file with bitmap data
              */
             final int [] framingBuffer = new int[width];
             ByteBuffer byteBuffer = ByteBuffer.allocate(framingBuffer.length * 4);
             IntBuffer intBuffer;

             byte[] array = byteBuffer.array();
             int tmp = 0;
             while(tmp < height) {
                 destBitmap.getPixels(framingBuffer,0,width,0,tmp,width,1);
                 intBuffer = byteBuffer.asIntBuffer();
                 intBuffer.put(framingBuffer,0,width);
                 dos.write(array);
                 tmp += 1;
             }
             fl.flush();
             fl.close();

             /*
              * Set the resized RGB width and height
              */
             ((OverlayFrame)overlay).setResizedRGBSize(width, height);
         }
     }
 }
	/*
	* Copyright (C) 2010 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.media.videoeditor;

	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.DataOutputStream;
	import java.nio.ByteBuffer;
	import java.nio.IntBuffer;

	import android.graphics.Canvas;
	import android.graphics.Paint;
	import android.graphics.Rect;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.graphics.Bitmap.CompressFormat;
	import android.util.Pair;


	/**
	* This class is used to overlay an image on top of a media item.
	* {@hide}
	*/
	public class OverlayFrame extends Overlay {
	/**
	* Instance variables
	*/
	private Bitmap mBitmap;
	private String mFilename;
	private String mBitmapFileName;

	private int mOFWidth;
	private int mOFHeight;

	/**
	* resized RGB Image dimensions
	*/
	private int mResizedRGBWidth;
	private int mResizedRGBHeight;

	/**
	* The resize paint
	*/
	private static final Paint sResizePaint = new Paint(Paint.FILTER_BITMAP_FLAG);

	/**
	* An object of this type cannot be instantiated by using the default
	* constructor
	*/
	@SuppressWarnings("unused")
	private OverlayFrame() {
	this(null, null, (String)null, 0, 0);
	}

	/**
	* Constructor for an OverlayFrame
	*
	* @param mediaItem The media item owner
	* @param overlayId The overlay id
	* @param bitmap The bitmap to be used as an overlay. The size of the
	* bitmap must equal to the size of the media item to which it is
	* added. The bitmap is typically a decoded PNG file.
	* @param startTimeMs The overlay start time in milliseconds
	* @param durationMs The overlay duration in milliseconds
	*
	* @throws IllegalArgumentException if the file type is not PNG or the
	* startTimeMs and durationMs are incorrect.
	*/
	public OverlayFrame(MediaItem mediaItem, String overlayId, Bitmap bitmap,
	long startTimeMs,long durationMs) {
	super(mediaItem, overlayId, startTimeMs, durationMs);
	mBitmap = bitmap;
	mFilename = null;
	mBitmapFileName = null;
	mResizedRGBWidth = 0;
	mResizedRGBHeight = 0;
	}

	/**
	* Constructor for an OverlayFrame. This constructor can be used to
	* restore the overlay after it was saved internally by the video editor.
	*
	* @param mediaItem The media item owner
	* @param overlayId The overlay id
	* @param filename The file name that contains the overlay.
	* @param startTimeMs The overlay start time in milliseconds
	* @param durationMs The overlay duration in milliseconds
	*
	* @throws IllegalArgumentException if the file type is not PNG or the
	* startTimeMs and durationMs are incorrect.
	*/
	OverlayFrame(MediaItem mediaItem, String overlayId, String filename,
	long startTimeMs,long durationMs) {
	super(mediaItem, overlayId, startTimeMs, durationMs);
	mBitmapFileName = filename;
	mBitmap = BitmapFactory.decodeFile(mBitmapFileName);
	mFilename = null;
	mResizedRGBWidth = 0;
	mResizedRGBHeight = 0;
	}

	/**
	* Get the overlay bitmap.
	*
	* @return Get the overlay bitmap
	*/
	public Bitmap getBitmap() {
	return mBitmap;
	}

	/**
	* Get the overlay bitmap.
	*
	* @return Get the overlay bitmap as png file.
	*/
	String getBitmapImageFileName() {
	return mBitmapFileName;
	}
	/**
	* Set the overlay bitmap.
	*
	* @param bitmap The overlay bitmap.
	*/
	public void setBitmap(Bitmap bitmap) {
	getMediaItem().getNativeContext().setGeneratePreview(true);

	invalidate();

	mBitmap = bitmap;
	if (mFilename != null) {
	/**
	* Delete the file
	*/
	new File(mFilename).delete();
	/**
	* Invalidate the filename
	*/
	mFilename = null;
	}

	/**
	* Invalidate the transitions if necessary
	*/
	getMediaItem().invalidateTransitions(mStartTimeMs, mDurationMs);
	}

	/**
	* Get the file name of this overlay
	*/
	String getFilename() {
	return mFilename;
	}

	/*
	* Set the file name of this overlay
	*/
	void setFilename(String filename) {
	mFilename = filename;
	}
	/**
	* Save the overlay to the project folder
	*
	* @param path The path where the overlay will be saved
	*
	* @return The filename
	* @throws FileNotFoundException if the bitmap cannot be saved
	* @throws IOException if the bitmap file cannot be saved
	*/
	String save(String path) throws FileNotFoundException, IOException {
	if (mFilename != null) {
	return mFilename;
	}

	// Create the compressed PNG file
	mBitmapFileName = path + "/" + "Overlay" + getId() + ".png";
	if (!(new File(mBitmapFileName).exists())) {
	final FileOutputStream out = new FileOutputStream (mBitmapFileName);
	mBitmap.compress(CompressFormat.PNG, 100, out);
	out.flush();
	out.close();
	}

	mOFWidth = mBitmap.getWidth();
	mOFHeight = mBitmap.getHeight();

	mFilename = path + "/" + "Overlay" + getId() + ".rgb";

	/* resize and save rgb as per project aspect ratio */
	MediaArtistNativeHelper nativeHelper = (super.getMediaItem()).getNativeContext();

	/* get height and width for story board aspect ratio */
	final Pair<Integer, Integer> maxResolution;
	final Pair<Integer, Integer>[] resolutions;
	resolutions = MediaProperties.getSupportedResolutions(nativeHelper.nativeHelperGetAspectRatio());

	// Get the highest resolution
	maxResolution = resolutions[resolutions.length - 1];

	/* Generate the rgb file with rendering mode */
	generateOverlayWithRenderingMode (super.getMediaItem(), this,
	maxResolution.second /* max Height */ ,
	maxResolution.first /* max Width */);

	return mFilename;
	}

	/**
	* Get the OverlayFrame Height
	*/
	int getOverlayFrameHeight() {
	return mOFHeight;
	}

	/**
	* Get the OverlayFrame Width
	*/
	int getOverlayFrameWidth() {
	return mOFWidth;
	}

	/*
	* Set the OverlayFrame Height
	*/
	void setOverlayFrameHeight(int height) {
	mOFHeight = height;
	}

	/*
	* Set the OverlayFrame Width
	*/
	void setOverlayFrameWidth(int width) {
	mOFWidth = width;
	}

	/*
	* Set the resized RGB widht and height
	*/
	void setResizedRGBSize(int width, int height) {
	mResizedRGBWidth = width;
	mResizedRGBHeight = height;
	}

	/*
	* Get the resized RGB Height
	*/
	int getResizedRGBSizeHeight() {
	return mResizedRGBHeight;
	}

	/*
	* Get the resized RGB Width
	*/
	int getResizedRGBSizeWidth() {
	return mResizedRGBWidth;
	}


	/**
	* Delete the overlay files
	*/
	void invalidate() {
	if (mBitmap != null) {
	mBitmap.recycle();
	mBitmap = null;
	}

	if (mFilename != null) {
	new File(mFilename).delete();
	mFilename = null;
	}

	if (mBitmapFileName != null) {
	new File(mBitmapFileName).delete();
	mBitmapFileName = null;
	}
	}

	/**
	* Delete the overlay related files
	*/
	void invalidateGeneratedFiles() {
	if (mFilename != null) {
	new File(mFilename).delete();
	mFilename = null;
	}

	if (mBitmapFileName != null) {
	new File(mBitmapFileName).delete();
	mBitmapFileName = null;
	}
	}

	void generateOverlayWithRenderingMode (MediaItem mediaItemsList, OverlayFrame overlay, int height , int width)
	throws FileNotFoundException, IOException {

	final MediaItem t = mediaItemsList;

	/* get the rendering mode */
	int renderMode = t.getRenderingMode();

	Bitmap overlayBitmap = ((OverlayFrame)overlay).getBitmap();

	/*
	* Check if the resize of Overlay is needed with rendering mode applied
	* because of change in export dimensions
	*/
	int resizedRGBFileHeight = ((OverlayFrame)overlay).getResizedRGBSizeHeight();
	int resizedRGBFileWidth = ((OverlayFrame)overlay).getResizedRGBSizeWidth();

	/* Get original bitmap width if it is not resized */
	if(resizedRGBFileWidth == 0) {
	resizedRGBFileWidth = overlayBitmap.getWidth();
	}
	/* Get original bitmap height if it is not resized */
	if(resizedRGBFileHeight == 0) {
	resizedRGBFileHeight = overlayBitmap.getHeight();
	}

	if (resizedRGBFileWidth != width \|\| resizedRGBFileHeight != height
	\|\| (!(new File(((OverlayFrame)overlay).getFilename()).exists()))) {
	/*
	* Create the canvas bitmap
	*/
	final Bitmap destBitmap = Bitmap.createBitmap((int)width,
	(int)height,
	Bitmap.Config.ARGB_8888);
	final Canvas overlayCanvas = new Canvas(destBitmap);
	final Rect destRect;
	final Rect srcRect;

	switch (renderMode) {
	case MediaItem.RENDERING_MODE_STRETCH: {
	destRect = new Rect(0, 0, overlayCanvas.getWidth(),
	overlayCanvas.getHeight());
	srcRect = new Rect(0, 0, overlayBitmap.getWidth(),
	overlayBitmap.getHeight());
	break;
	}

	case MediaItem.RENDERING_MODE_BLACK_BORDER: {
	int left, right, top, bottom;
	float aROverlayImage, aRCanvas;
	aROverlayImage = (float)(overlayBitmap.getWidth()) /
	(float)(overlayBitmap.getHeight());

	aRCanvas = (float)(overlayCanvas.getWidth()) /
	(float)(overlayCanvas.getHeight());

	if (aROverlayImage > aRCanvas) {
	int newHeight = ((overlayCanvas.getWidth() * overlayBitmap.getHeight())
	/ overlayBitmap.getWidth());
	left = 0;
	top = (overlayCanvas.getHeight() - newHeight) / 2;
	right = overlayCanvas.getWidth();
	bottom = top + newHeight;
	} else {
	int newWidth = ((overlayCanvas.getHeight() * overlayBitmap.getWidth())
	/ overlayBitmap.getHeight());
	left = (overlayCanvas.getWidth() - newWidth) / 2;
	top = 0;
	right = left + newWidth;
	bottom = overlayCanvas.getHeight();
	}

	destRect = new Rect(left, top, right, bottom);
	srcRect = new Rect(0, 0, overlayBitmap.getWidth(), overlayBitmap.getHeight());
	break;
	}

	case MediaItem.RENDERING_MODE_CROPPING: {
	// Calculate the source rect
	int left, right, top, bottom;
	float aROverlayImage, aRCanvas;
	aROverlayImage = (float)(overlayBitmap.getWidth()) /
	(float)(overlayBitmap.getHeight());
	aRCanvas = (float)(overlayCanvas.getWidth()) /
	(float)(overlayCanvas.getHeight());
	if (aROverlayImage < aRCanvas) {
	int newHeight = ((overlayBitmap.getWidth() * overlayCanvas.getHeight())
	/ overlayCanvas.getWidth());

	left = 0;
	top = (overlayBitmap.getHeight() - newHeight) / 2;
	right = overlayBitmap.getWidth();
	bottom = top + newHeight;
	} else {
	int newWidth = ((overlayBitmap.getHeight() * overlayCanvas.getWidth())
	/ overlayCanvas.getHeight());
	left = (overlayBitmap.getWidth() - newWidth) / 2;
	top = 0;
	right = left + newWidth;
	bottom = overlayBitmap.getHeight();
	}

	srcRect = new Rect(left, top, right, bottom);
	destRect = new Rect(0, 0, overlayCanvas.getWidth(), overlayCanvas.getHeight());
	break;
	}

	default: {
	throw new IllegalStateException("Rendering mode: " + renderMode);
	}
	}

	overlayCanvas.drawBitmap(overlayBitmap, srcRect, destRect, sResizePaint);
	overlayCanvas.setBitmap(null);

	/*
	* Write to the dest file
	*/
	String outFileName = ((OverlayFrame)overlay).getFilename();

	/*
	* Save the image to same rgb file
	*/
	if (outFileName != null) {
	new File(outFileName).delete();
	}

	final FileOutputStream fl = new FileOutputStream(outFileName);
	final DataOutputStream dos = new DataOutputStream(fl);

	/*
	* Populate the rgb file with bitmap data
	*/
	final int [] framingBuffer = new int[width];
	ByteBuffer byteBuffer = ByteBuffer.allocate(framingBuffer.length * 4);
	IntBuffer intBuffer;

	byte[] array = byteBuffer.array();
	int tmp = 0;
	while(tmp < height) {
	destBitmap.getPixels(framingBuffer,0,width,0,tmp,width,1);
	intBuffer = byteBuffer.asIntBuffer();
	intBuffer.put(framingBuffer,0,width);
	dos.write(array);
	tmp += 1;
	}
	fl.flush();
	fl.close();

	/*
	* Set the resized RGB width and height
	*/
	((OverlayFrame)overlay).setResizedRGBSize(width, height);
	}
	}
	}