src/com/android/camera/settings/ResolutionUtil.java - platform/packages/apps/Camera2 - Git at Google

 /*
  * Copyright (C) 2013 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 com.android.camera.settings;

 import android.content.Context;
 import android.util.DisplayMetrics;
 import android.view.WindowManager;

 import com.android.camera.exif.Rational;
 import com.android.camera.util.AndroidServices;
 import com.android.camera.util.ApiHelper;
 import com.android.camera.util.Size;

 import com.google.common.collect.Lists;

 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;

 import javax.annotation.Nonnull;
 import javax.annotation.ParametersAreNonnullByDefault;


 /**
  * This class is used to help manage the many different resolutions available on
  * the device. <br/>
  * It allows you to specify which aspect ratios to offer the user, and then
  * chooses which resolutions are the most pertinent to avoid overloading the
  * user with so many options.
  */
 public class ResolutionUtil {
     /**
      * Different aspect ratio constants.
      */
     public static final Rational ASPECT_RATIO_16x9 = new Rational(16, 9);
     public static final Rational ASPECT_RATIO_4x3 = new Rational(4, 3);
     private static final double ASPECT_RATIO_TOLERANCE = 0.05;

     public static final String NEXUS_5_LARGE_16_BY_9 = "1836x3264";
     public static final float NEXUS_5_LARGE_16_BY_9_ASPECT_RATIO = 16f / 9f;
     public static Size NEXUS_5_LARGE_16_BY_9_SIZE = new Size(3264, 1836);

     /**
      * These are the preferred aspect ratios for the settings. We will take HAL
      * supported aspect ratios that are within ASPECT_RATIO_TOLERANCE of these values.
      * We will also take the maximum supported resolution for full sensor image.
      */
     private static Float[] sDesiredAspectRatios = {
             16.0f / 9.0f, 4.0f / 3.0f
     };

     private static Size[] sDesiredAspectRatioSizes = {
             new Size(16, 9), new Size(4, 3)
     };

     /**
      * A resolution bucket holds a list of sizes that are of a given aspect
      * ratio.
      */
     private static class ResolutionBucket {
         public Float aspectRatio;
         /**
          * This is a sorted list of sizes, going from largest to smallest.
          */
         public List<Size> sizes = new LinkedList<Size>();
         /**
          * This is the head of the sizes array.
          */
         public Size largest;
         /**
          * This is the area of the largest size, used for sorting
          * ResolutionBuckets.
          */
         public Integer maxPixels = 0;

         /**
          * Use this to add a new resolution to this bucket. It will insert it
          * into the sizes array and update appropriate members.
          *
          * @param size the new size to be added
          */
         public void add(Size size) {
             sizes.add(size);
             Collections.sort(sizes, new Comparator<Size>() {
                 @Override
                 public int compare(Size size, Size size2) {
                     // sort area greatest to least
                     return Integer.compare(size2.width() * size2.height(),
                             size.width() * size.height());
                 }
             });
             maxPixels = sizes.get(0).width() * sizes.get(0).height();
         }
     }

     /**
      * Given a list of camera sizes, this uses some heuristics to decide which
      * options to present to a user. It currently returns up to 3 sizes for each
      * aspect ratio. The aspect ratios returned include the ones in
      * sDesiredAspectRatios, and the largest full sensor ratio. T his guarantees
      * that users can use a full-sensor size, as well as any of the preferred
      * aspect ratios from above;
      *
      * @param sizes A super set of all sizes to be displayed
      * @param isBackCamera true if these are sizes for the back camera
      * @return The list of sizes to display grouped first by aspect ratio
      *         (sorted by maximum area), and sorted within aspect ratio by area)
      */
     public static List<Size> getDisplayableSizesFromSupported(List<Size> sizes, boolean isBackCamera) {
         List<ResolutionBucket> buckets = parseAvailableSizes(sizes, isBackCamera);

         List<Float> sortedDesiredAspectRatios = new ArrayList<Float>();
         // We want to make sure we support the maximum pixel aspect ratio, even
         // if it doesn't match a desired aspect ratio
         sortedDesiredAspectRatios.add(buckets.get(0).aspectRatio.floatValue());

         // Now go through the buckets from largest mp to smallest, adding
         // desired ratios
         for (ResolutionBucket bucket : buckets) {
             Float aspectRatio = bucket.aspectRatio;
             if (Arrays.asList(sDesiredAspectRatios).contains(aspectRatio)
                     && !sortedDesiredAspectRatios.contains(aspectRatio)) {
                 sortedDesiredAspectRatios.add(aspectRatio);
             }
         }

         List<Size> result = new ArrayList<Size>(sizes.size());
         for (Float targetRatio : sortedDesiredAspectRatios) {
             for (ResolutionBucket bucket : buckets) {
                 Number aspectRatio = bucket.aspectRatio;
                 if (Math.abs(aspectRatio.floatValue() - targetRatio) <= ASPECT_RATIO_TOLERANCE) {
                     result.addAll(pickUpToThree(bucket.sizes));
                 }
             }
         }
         return result;
     }

     /**
      * Get the area in pixels of a size.
      *
      * @param size the size to measure
      * @return the area.
      */
     private static int area(Size size) {
         if (size == null) {
             return 0;
         }
         return size.width() * size.height();
     }

     /**
      * Given a list of sizes of a similar aspect ratio, it tries to pick evenly
      * spaced out options. It starts with the largest, then tries to find one at
      * 50% of the last chosen size for the subsequent size.
      *
      * @param sizes A list of Sizes that are all of a similar aspect ratio
      * @return A list of at least one, and no more than three representative
      *         sizes from the list.
      */
     private static List<Size> pickUpToThree(List<Size> sizes) {
         List<Size> result = new ArrayList<Size>();
         Size largest = sizes.get(0);
         result.add(largest);
         Size lastSize = largest;
         for (Size size : sizes) {
             double targetArea = Math.pow(.5, result.size()) * area(largest);
             if (area(size) < targetArea) {
                 // This candidate is smaller than half the mega pixels of the
                 // last one. Let's see whether the previous size, or this size
                 // is closer to the desired target.
                 if (!result.contains(lastSize)
                         && (targetArea - area(lastSize) < area(size) - targetArea)) {
                     result.add(lastSize);
                 } else {
                     result.add(size);
                 }
             }
             lastSize = size;
             if (result.size() == 3) {
                 break;
             }
         }

         // If we have less than three, we can add the smallest size.
         if (result.size() < 3 && !result.contains(lastSize)) {
             result.add(lastSize);
         }
         return result;
     }

     /**
      * Take an aspect ratio and squish it into a nearby desired aspect ratio, if
      * possible.
      *
      * @param aspectRatio the aspect ratio to fuzz
      * @return the closest desiredAspectRatio within ASPECT_RATIO_TOLERANCE, or the
      *         original ratio
      */
     private static float fuzzAspectRatio(float aspectRatio) {
         for (float desiredAspectRatio : sDesiredAspectRatios) {
             if ((Math.abs(aspectRatio - desiredAspectRatio)) < ASPECT_RATIO_TOLERANCE) {
                 return desiredAspectRatio;
             }
         }
         return aspectRatio;
     }

     /**
      * This takes a bunch of supported sizes and buckets them by aspect ratio.
      * The result is a list of buckets sorted by each bucket's largest area.
      * They are sorted from largest to smallest. This will bucket aspect ratios
      * that are close to the sDesiredAspectRatios in to the same bucket.
      *
      * @param sizes all supported sizes for a camera
      * @param isBackCamera true if these are sizes for the back camera
      * @return all of the sizes grouped by their closest aspect ratio
      */
     private static List<ResolutionBucket> parseAvailableSizes(List<Size> sizes, boolean isBackCamera) {
         HashMap<Float, ResolutionBucket> aspectRatioToBuckets = new HashMap<Float, ResolutionBucket>();

         for (Size size : sizes) {
             Float aspectRatio = (float) size.getWidth() / (float) size.getHeight();
             // If this aspect ratio is close to a desired Aspect Ratio,
             // fuzz it so that they are bucketed together
             aspectRatio = fuzzAspectRatio(aspectRatio);
             ResolutionBucket bucket = aspectRatioToBuckets.get(aspectRatio);
             if (bucket == null) {
                 bucket = new ResolutionBucket();
                 bucket.aspectRatio = aspectRatio;
                 aspectRatioToBuckets.put(aspectRatio, bucket);
             }
             bucket.add(size);
         }
         if (ApiHelper.IS_NEXUS_5 && isBackCamera) {
             aspectRatioToBuckets.get(16 / 9.0f).add(NEXUS_5_LARGE_16_BY_9_SIZE);
         }
         List<ResolutionBucket> sortedBuckets = new ArrayList<ResolutionBucket>(
                 aspectRatioToBuckets.values());
         Collections.sort(sortedBuckets, new Comparator<ResolutionBucket>() {
             @Override
             public int compare(ResolutionBucket resolutionBucket, ResolutionBucket resolutionBucket2) {
                 return Integer.compare(resolutionBucket2.maxPixels, resolutionBucket.maxPixels);
             }
         });
         return sortedBuckets;
     }

     /**
      * Given a size, return a string describing the aspect ratio by reducing the
      *
      * @param size the size to describe
      * @return a string description of the aspect ratio
      */
     public static String aspectRatioDescription(Size size) {
         Size aspectRatio = reduce(size);
         return aspectRatio.width() + "x" + aspectRatio.height();
     }

     /**
      * Reduce an aspect ratio to its lowest common denominator. The ratio of the
      * input and output sizes is guaranteed to be the same.
      *
      * @param aspectRatio the aspect ratio to reduce
      * @return The reduced aspect ratio which may equal the original.
      */
     public static Size reduce(Size aspectRatio) {
         BigInteger width = BigInteger.valueOf(aspectRatio.width());
         BigInteger height = BigInteger.valueOf(aspectRatio.height());
         BigInteger gcd = width.gcd(height);
         int numerator = Math.max(width.intValue(), height.intValue()) / gcd.intValue();
         int denominator = Math.min(width.intValue(), height.intValue()) / gcd.intValue();
         return new Size(numerator, denominator);
     }

     /**
      * Given a size return the numerator of its aspect ratio
      *
      * @param size the size to measure
      * @return the numerator
      */
     public static int aspectRatioNumerator(Size size) {
         Size aspectRatio = reduce(size);
         return aspectRatio.width();
     }

     /**
      * Given a size, return the closest aspect ratio that falls close to the
      * given size.
      *
      * @param size the size to approximate
      * @return the closest desired aspect ratio, or the original aspect ratio if
      *         none were close enough
      */
     public static Size getApproximateSize(Size size) {
         Size aspectRatio = reduce(size);
         float fuzzy = fuzzAspectRatio(size.width() / (float) size.height());
         int index = Arrays.asList(sDesiredAspectRatios).indexOf(fuzzy);
         if (index != -1) {
             aspectRatio = sDesiredAspectRatioSizes[index];
         }
         return aspectRatio;
     }

     /**
      * Given a size return the numerator of its aspect ratio
      *
      * @param size
      * @return the denominator
      */
     public static int aspectRatioDenominator(Size size) {
         BigInteger width = BigInteger.valueOf(size.width());
         BigInteger height = BigInteger.valueOf(size.height());
         BigInteger gcd = width.gcd(height);
         int denominator = Math.min(width.intValue(), height.intValue()) / gcd.intValue();
         return denominator;
     }

     /**
      * Returns the aspect ratio for the given size.
      *
      * @param size The given size.
      * @return A {@link Rational} which represents the aspect ratio.
      */
     public static Rational getAspectRatio(Size size) {
         int width = size.getWidth();
         int height = size.getHeight();
         int numerator = width;
         int denominator = height;
         if (height > width) {
             numerator = height;
             denominator = width;
         }
         return new Rational(numerator, denominator);
     }

     public static boolean hasSameAspectRatio(Rational ar1, Rational ar2) {
         return Math.abs(ar1.toDouble() - ar2.toDouble()) < ASPECT_RATIO_TOLERANCE;
     }

     /**
      * Selects the maximal resolution for the given desired aspect ratio from all available
      * resolutions.  If no resolution exists for the desired aspect ratio, return a resolution
      * with the maximum number of pixels.
      *
      * @param desiredAspectRatio The desired aspect ratio.
      * @param sizes All available resolutions.
      * @return The maximal resolution for desired aspect ratio ; if no sizes are found, then
      *      return size of (0,0)
      */
     public static Size getLargestPictureSize(Rational desiredAspectRatio, List<Size> sizes) {
         int maxPixelNumNoAspect = 0;
         Size maxSize = new Size(0, 0);

         // Fix for b/21758681
         // Do first pass with the candidate with closest size, regardless of aspect ratio,
         // to loosen the requirement of valid preview sizes.  As long as one size exists
         // in the list, we should pass back a valid size.
         for (Size size : sizes) {
             int pixelNum = size.getWidth() * size.getHeight();
             if (pixelNum > maxPixelNumNoAspect) {
                 maxPixelNumNoAspect = pixelNum;
                 maxSize = size;
             }
         }

         // With second pass, override first pass with the candidate with closest
         // size AND similar aspect ratio.  If there are no valid candidates are found
         // in the second pass, take the candidate from the first pass.
         int maxPixelNumWithAspect = 0;
         for (Size size : sizes) {
             Rational aspectRatio = getAspectRatio(size);
             // Skip if the aspect ratio is not desired.
             if (!hasSameAspectRatio(aspectRatio, desiredAspectRatio)) {
                 continue;
             }
             int pixelNum = size.getWidth() * size.getHeight();
             if (pixelNum > maxPixelNumWithAspect) {
                 maxPixelNumWithAspect = pixelNum;
                 maxSize = size;
             }
         }

         return maxSize;
     }

     public static DisplayMetrics getDisplayMetrics(Context context) {
         DisplayMetrics displayMetrics = new DisplayMetrics();
         WindowManager wm = AndroidServices.instance().provideWindowManager();
         if (wm != null) {
             wm.getDefaultDisplay().getMetrics(displayMetrics);
         }
         return displayMetrics;
     }

     /**
      * Takes selected sizes and a list of blacklisted sizes. All the blacklistes
      * sizes will be removed from the 'sizes' list.
      *
      * @param sizes the sizes to be filtered.
      * @param blacklistString a String containing a comma-separated list of
      *            sizes that should be removed from the original list.
      * @return A list that contains the filtered items.
      */
     @ParametersAreNonnullByDefault
     public static List<Size> filterBlackListedSizes(List<Size> sizes, String blacklistString) {
         String[] blacklistStringArray = blacklistString.split(",");
         if (blacklistStringArray.length == 0) {
             return sizes;
         }

         Set<String> blacklistedSizes = new HashSet(Lists.newArrayList(blacklistStringArray));
         List<Size> newSizeList = new ArrayList<>();
         for (Size size : sizes) {
             if (!isBlackListed(size, blacklistedSizes)) {
                 newSizeList.add(size);
             }
         }
         return newSizeList;
     }

     /**
      * Returns whether the given size is within the blacklist string.
      *
      * @param size the size to check
      * @param blacklistString a String containing a comma-separated list of
      *            sizes that should not be available on the device.
      * @return Whether the given size is blacklisted.
      */
     public static boolean isBlackListed(@Nonnull Size size, @Nonnull String blacklistString) {
         String[] blacklistStringArray = blacklistString.split(",");
         if (blacklistStringArray.length == 0) {
             return false;
         }
         Set<String> blacklistedSizes = new HashSet(Lists.newArrayList(blacklistStringArray));
         return isBlackListed(size, blacklistedSizes);
     }

     private static boolean isBlackListed(@Nonnull Size size, @Nonnull Set<String> blacklistedSizes) {
         String sizeStr = size.getWidth() + "x" + size.getHeight();
         return blacklistedSizes.contains(sizeStr);
     }
 }
	/*
	* Copyright (C) 2013 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 com.android.camera.settings;

	import android.content.Context;
	import android.util.DisplayMetrics;
	import android.view.WindowManager;

	import com.android.camera.exif.Rational;
	import com.android.camera.util.AndroidServices;
	import com.android.camera.util.ApiHelper;
	import com.android.camera.util.Size;

	import com.google.common.collect.Lists;

	import java.math.BigInteger;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Set;

	import javax.annotation.Nonnull;
	import javax.annotation.ParametersAreNonnullByDefault;


	/**
	* This class is used to help manage the many different resolutions available on
	* the device. <br/>
	* It allows you to specify which aspect ratios to offer the user, and then
	* chooses which resolutions are the most pertinent to avoid overloading the
	* user with so many options.
	*/
	public class ResolutionUtil {
	/**
	* Different aspect ratio constants.
	*/
	public static final Rational ASPECT_RATIO_16x9 = new Rational(16, 9);
	public static final Rational ASPECT_RATIO_4x3 = new Rational(4, 3);
	private static final double ASPECT_RATIO_TOLERANCE = 0.05;

	public static final String NEXUS_5_LARGE_16_BY_9 = "1836x3264";
	public static final float NEXUS_5_LARGE_16_BY_9_ASPECT_RATIO = 16f / 9f;
	public static Size NEXUS_5_LARGE_16_BY_9_SIZE = new Size(3264, 1836);

	/**
	* These are the preferred aspect ratios for the settings. We will take HAL
	* supported aspect ratios that are within ASPECT_RATIO_TOLERANCE of these values.
	* We will also take the maximum supported resolution for full sensor image.
	*/
	private static Float[] sDesiredAspectRatios = {
	16.0f / 9.0f, 4.0f / 3.0f
	};

	private static Size[] sDesiredAspectRatioSizes = {
	new Size(16, 9), new Size(4, 3)
	};

	/**
	* A resolution bucket holds a list of sizes that are of a given aspect
	* ratio.
	*/
	private static class ResolutionBucket {
	public Float aspectRatio;
	/**
	* This is a sorted list of sizes, going from largest to smallest.
	*/
	public List<Size> sizes = new LinkedList<Size>();
	/**
	* This is the head of the sizes array.
	*/
	public Size largest;
	/**
	* This is the area of the largest size, used for sorting
	* ResolutionBuckets.
	*/
	public Integer maxPixels = 0;

	/**
	* Use this to add a new resolution to this bucket. It will insert it
	* into the sizes array and update appropriate members.
	*
	* @param size the new size to be added
	*/
	public void add(Size size) {
	sizes.add(size);
	Collections.sort(sizes, new Comparator<Size>() {
	@Override
	public int compare(Size size, Size size2) {
	// sort area greatest to least
	return Integer.compare(size2.width() * size2.height(),
	size.width() * size.height());
	}
	});
	maxPixels = sizes.get(0).width() * sizes.get(0).height();
	}
	}

	/**
	* Given a list of camera sizes, this uses some heuristics to decide which
	* options to present to a user. It currently returns up to 3 sizes for each
	* aspect ratio. The aspect ratios returned include the ones in
	* sDesiredAspectRatios, and the largest full sensor ratio. T his guarantees
	* that users can use a full-sensor size, as well as any of the preferred
	* aspect ratios from above;
	*
	* @param sizes A super set of all sizes to be displayed
	* @param isBackCamera true if these are sizes for the back camera
	* @return The list of sizes to display grouped first by aspect ratio
	* (sorted by maximum area), and sorted within aspect ratio by area)
	*/
	public static List<Size> getDisplayableSizesFromSupported(List<Size> sizes, boolean isBackCamera) {
	List<ResolutionBucket> buckets = parseAvailableSizes(sizes, isBackCamera);

	List<Float> sortedDesiredAspectRatios = new ArrayList<Float>();
	// We want to make sure we support the maximum pixel aspect ratio, even
	// if it doesn't match a desired aspect ratio
	sortedDesiredAspectRatios.add(buckets.get(0).aspectRatio.floatValue());

	// Now go through the buckets from largest mp to smallest, adding
	// desired ratios
	for (ResolutionBucket bucket : buckets) {
	Float aspectRatio = bucket.aspectRatio;
	if (Arrays.asList(sDesiredAspectRatios).contains(aspectRatio)
	&& !sortedDesiredAspectRatios.contains(aspectRatio)) {
	sortedDesiredAspectRatios.add(aspectRatio);
	}
	}

	List<Size> result = new ArrayList<Size>(sizes.size());
	for (Float targetRatio : sortedDesiredAspectRatios) {
	for (ResolutionBucket bucket : buckets) {
	Number aspectRatio = bucket.aspectRatio;
	if (Math.abs(aspectRatio.floatValue() - targetRatio) <= ASPECT_RATIO_TOLERANCE) {
	result.addAll(pickUpToThree(bucket.sizes));
	}
	}
	}
	return result;
	}

	/**
	* Get the area in pixels of a size.
	*
	* @param size the size to measure
	* @return the area.
	*/
	private static int area(Size size) {
	if (size == null) {
	return 0;
	}
	return size.width() * size.height();
	}

	/**
	* Given a list of sizes of a similar aspect ratio, it tries to pick evenly
	* spaced out options. It starts with the largest, then tries to find one at
	* 50% of the last chosen size for the subsequent size.
	*
	* @param sizes A list of Sizes that are all of a similar aspect ratio
	* @return A list of at least one, and no more than three representative
	* sizes from the list.
	*/
	private static List<Size> pickUpToThree(List<Size> sizes) {
	List<Size> result = new ArrayList<Size>();
	Size largest = sizes.get(0);
	result.add(largest);
	Size lastSize = largest;
	for (Size size : sizes) {
	double targetArea = Math.pow(.5, result.size()) * area(largest);
	if (area(size) < targetArea) {
	// This candidate is smaller than half the mega pixels of the
	// last one. Let's see whether the previous size, or this size
	// is closer to the desired target.
	if (!result.contains(lastSize)
	&& (targetArea - area(lastSize) < area(size) - targetArea)) {
	result.add(lastSize);
	} else {
	result.add(size);
	}
	}
	lastSize = size;
	if (result.size() == 3) {
	break;
	}
	}

	// If we have less than three, we can add the smallest size.
	if (result.size() < 3 && !result.contains(lastSize)) {
	result.add(lastSize);
	}
	return result;
	}

	/**
	* Take an aspect ratio and squish it into a nearby desired aspect ratio, if
	* possible.
	*
	* @param aspectRatio the aspect ratio to fuzz
	* @return the closest desiredAspectRatio within ASPECT_RATIO_TOLERANCE, or the
	* original ratio
	*/
	private static float fuzzAspectRatio(float aspectRatio) {
	for (float desiredAspectRatio : sDesiredAspectRatios) {
	if ((Math.abs(aspectRatio - desiredAspectRatio)) < ASPECT_RATIO_TOLERANCE) {
	return desiredAspectRatio;
	}
	}
	return aspectRatio;
	}

	/**
	* This takes a bunch of supported sizes and buckets them by aspect ratio.
	* The result is a list of buckets sorted by each bucket's largest area.
	* They are sorted from largest to smallest. This will bucket aspect ratios
	* that are close to the sDesiredAspectRatios in to the same bucket.
	*
	* @param sizes all supported sizes for a camera
	* @param isBackCamera true if these are sizes for the back camera
	* @return all of the sizes grouped by their closest aspect ratio
	*/
	private static List<ResolutionBucket> parseAvailableSizes(List<Size> sizes, boolean isBackCamera) {
	HashMap<Float, ResolutionBucket> aspectRatioToBuckets = new HashMap<Float, ResolutionBucket>();

	for (Size size : sizes) {
	Float aspectRatio = (float) size.getWidth() / (float) size.getHeight();
	// If this aspect ratio is close to a desired Aspect Ratio,
	// fuzz it so that they are bucketed together
	aspectRatio = fuzzAspectRatio(aspectRatio);
	ResolutionBucket bucket = aspectRatioToBuckets.get(aspectRatio);
	if (bucket == null) {
	bucket = new ResolutionBucket();
	bucket.aspectRatio = aspectRatio;
	aspectRatioToBuckets.put(aspectRatio, bucket);
	}
	bucket.add(size);
	}
	if (ApiHelper.IS_NEXUS_5 && isBackCamera) {
	aspectRatioToBuckets.get(16 / 9.0f).add(NEXUS_5_LARGE_16_BY_9_SIZE);
	}
	List<ResolutionBucket> sortedBuckets = new ArrayList<ResolutionBucket>(
	aspectRatioToBuckets.values());
	Collections.sort(sortedBuckets, new Comparator<ResolutionBucket>() {
	@Override
	public int compare(ResolutionBucket resolutionBucket, ResolutionBucket resolutionBucket2) {
	return Integer.compare(resolutionBucket2.maxPixels, resolutionBucket.maxPixels);
	}
	});
	return sortedBuckets;
	}

	/**
	* Given a size, return a string describing the aspect ratio by reducing the
	*
	* @param size the size to describe
	* @return a string description of the aspect ratio
	*/
	public static String aspectRatioDescription(Size size) {
	Size aspectRatio = reduce(size);
	return aspectRatio.width() + "x" + aspectRatio.height();
	}

	/**
	* Reduce an aspect ratio to its lowest common denominator. The ratio of the
	* input and output sizes is guaranteed to be the same.
	*
	* @param aspectRatio the aspect ratio to reduce
	* @return The reduced aspect ratio which may equal the original.
	*/
	public static Size reduce(Size aspectRatio) {
	BigInteger width = BigInteger.valueOf(aspectRatio.width());
	BigInteger height = BigInteger.valueOf(aspectRatio.height());
	BigInteger gcd = width.gcd(height);
	int numerator = Math.max(width.intValue(), height.intValue()) / gcd.intValue();
	int denominator = Math.min(width.intValue(), height.intValue()) / gcd.intValue();
	return new Size(numerator, denominator);
	}

	/**
	* Given a size return the numerator of its aspect ratio
	*
	* @param size the size to measure
	* @return the numerator
	*/
	public static int aspectRatioNumerator(Size size) {
	Size aspectRatio = reduce(size);
	return aspectRatio.width();
	}

	/**
	* Given a size, return the closest aspect ratio that falls close to the
	* given size.
	*
	* @param size the size to approximate
	* @return the closest desired aspect ratio, or the original aspect ratio if
	* none were close enough
	*/
	public static Size getApproximateSize(Size size) {
	Size aspectRatio = reduce(size);
	float fuzzy = fuzzAspectRatio(size.width() / (float) size.height());
	int index = Arrays.asList(sDesiredAspectRatios).indexOf(fuzzy);
	if (index != -1) {
	aspectRatio = sDesiredAspectRatioSizes[index];
	}
	return aspectRatio;
	}

	/**
	* Given a size return the numerator of its aspect ratio
	*
	* @param size
	* @return the denominator
	*/
	public static int aspectRatioDenominator(Size size) {
	BigInteger width = BigInteger.valueOf(size.width());
	BigInteger height = BigInteger.valueOf(size.height());
	BigInteger gcd = width.gcd(height);
	int denominator = Math.min(width.intValue(), height.intValue()) / gcd.intValue();
	return denominator;
	}

	/**
	* Returns the aspect ratio for the given size.
	*
	* @param size The given size.
	* @return A {@link Rational} which represents the aspect ratio.
	*/
	public static Rational getAspectRatio(Size size) {
	int width = size.getWidth();
	int height = size.getHeight();
	int numerator = width;
	int denominator = height;
	if (height > width) {
	numerator = height;
	denominator = width;
	}
	return new Rational(numerator, denominator);
	}

	public static boolean hasSameAspectRatio(Rational ar1, Rational ar2) {
	return Math.abs(ar1.toDouble() - ar2.toDouble()) < ASPECT_RATIO_TOLERANCE;
	}

	/**
	* Selects the maximal resolution for the given desired aspect ratio from all available
	* resolutions. If no resolution exists for the desired aspect ratio, return a resolution
	* with the maximum number of pixels.
	*
	* @param desiredAspectRatio The desired aspect ratio.
	* @param sizes All available resolutions.
	* @return The maximal resolution for desired aspect ratio ; if no sizes are found, then
	* return size of (0,0)
	*/
	public static Size getLargestPictureSize(Rational desiredAspectRatio, List<Size> sizes) {
	int maxPixelNumNoAspect = 0;
	Size maxSize = new Size(0, 0);

	// Fix for b/21758681
	// Do first pass with the candidate with closest size, regardless of aspect ratio,
	// to loosen the requirement of valid preview sizes. As long as one size exists
	// in the list, we should pass back a valid size.
	for (Size size : sizes) {
	int pixelNum = size.getWidth() * size.getHeight();
	if (pixelNum > maxPixelNumNoAspect) {
	maxPixelNumNoAspect = pixelNum;
	maxSize = size;
	}
	}

	// With second pass, override first pass with the candidate with closest
	// size AND similar aspect ratio. If there are no valid candidates are found
	// in the second pass, take the candidate from the first pass.
	int maxPixelNumWithAspect = 0;
	for (Size size : sizes) {
	Rational aspectRatio = getAspectRatio(size);
	// Skip if the aspect ratio is not desired.
	if (!hasSameAspectRatio(aspectRatio, desiredAspectRatio)) {
	continue;
	}
	int pixelNum = size.getWidth() * size.getHeight();
	if (pixelNum > maxPixelNumWithAspect) {
	maxPixelNumWithAspect = pixelNum;
	maxSize = size;
	}
	}

	return maxSize;
	}

	public static DisplayMetrics getDisplayMetrics(Context context) {
	DisplayMetrics displayMetrics = new DisplayMetrics();
	WindowManager wm = AndroidServices.instance().provideWindowManager();
	if (wm != null) {
	wm.getDefaultDisplay().getMetrics(displayMetrics);
	}
	return displayMetrics;
	}

	/**
	* Takes selected sizes and a list of blacklisted sizes. All the blacklistes
	* sizes will be removed from the 'sizes' list.
	*
	* @param sizes the sizes to be filtered.
	* @param blacklistString a String containing a comma-separated list of
	* sizes that should be removed from the original list.
	* @return A list that contains the filtered items.
	*/
	@ParametersAreNonnullByDefault
	public static List<Size> filterBlackListedSizes(List<Size> sizes, String blacklistString) {
	String[] blacklistStringArray = blacklistString.split(",");
	if (blacklistStringArray.length == 0) {
	return sizes;
	}

	Set<String> blacklistedSizes = new HashSet(Lists.newArrayList(blacklistStringArray));
	List<Size> newSizeList = new ArrayList<>();
	for (Size size : sizes) {
	if (!isBlackListed(size, blacklistedSizes)) {
	newSizeList.add(size);
	}
	}
	return newSizeList;
	}

	/**
	* Returns whether the given size is within the blacklist string.
	*
	* @param size the size to check
	* @param blacklistString a String containing a comma-separated list of
	* sizes that should not be available on the device.
	* @return Whether the given size is blacklisted.
	*/
	public static boolean isBlackListed(@Nonnull Size size, @Nonnull String blacklistString) {
	String[] blacklistStringArray = blacklistString.split(",");
	if (blacklistStringArray.length == 0) {
	return false;
	}
	Set<String> blacklistedSizes = new HashSet(Lists.newArrayList(blacklistStringArray));
	return isBlackListed(size, blacklistedSizes);
	}

	private static boolean isBlackListed(@Nonnull Size size, @Nonnull Set<String> blacklistedSizes) {
	String sizeStr = size.getWidth() + "x" + size.getHeight();
	return blacklistedSizes.contains(sizeStr);
	}
	}