path: root/src/com/android/camera/settings/ResolutionUtil.java

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