| /* |
| * Copyright (C) 2021 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.hardware.camera2.params; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| |
| import android.graphics.ImageFormat; |
| import android.graphics.ImageFormat.Format; |
| import android.graphics.PixelFormat; |
| import android.hardware.camera2.params.MultiResolutionStreamInfo; |
| import android.hardware.camera2.params.StreamConfigurationMap; |
| import android.hardware.camera2.utils.HashCodeHelpers; |
| |
| import android.util.Size; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.List; |
| import java.util.Set; |
| |
| import static com.android.internal.util.Preconditions.*; |
| |
| /** |
| * Immutable class to store the information of the multi-resolution streams supported by |
| * the camera device. |
| * |
| * <p>For a {@link |
| * android.hardware.camera2.CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA |
| * logical multi-camera} or an ultra high resolution sensor camera, the maximum resolution of images |
| * produced by the camera device may be variable. For example, for a logical multi-camera, depending |
| * on factors such as current zoom ratio, the camera device may be backed by different physical |
| * cameras. If the physical cameras are of different resolutions, the application may intend to |
| * consume the variable full resolution images from the physical cameras. For an ultra high |
| * resolution sensor camera, the same use case exists where depending on lighting conditions, the |
| * camera device may deem it better to run in default mode and maximum resolution mode. |
| * </p> |
| * |
| * <p>For the use cases described above, multi-resolution output streams can be used by |
| * {@link android.hardware.camera2.MultiResolutionImageReader} to allow the |
| * camera device to output variable size maximum-resolution images.</p> |
| * |
| * <p>Similarly, multi-resolution input streams can be used for reprocessing of variable size |
| * images. In order to reprocess input images of different sizes, the {@link InputConfiguration} |
| * used for creating reprocessable session can be initialized using the group of input stream |
| * configurations returned by {@link #getInputInfo}.</p> |
| */ |
| public final class MultiResolutionStreamConfigurationMap { |
| /** |
| * Create a new {@link MultiResolutionStreamConfigurationMap}. |
| * |
| * @param configurations a non-{@code null} array of multi-resolution stream |
| * configurations supported by this camera device |
| * @hide |
| */ |
| public MultiResolutionStreamConfigurationMap( |
| @NonNull Map<String, StreamConfiguration[]> configurations) { |
| checkNotNull(configurations, "multi-resolution configurations must not be null"); |
| if (configurations.size() == 0) { |
| throw new IllegalArgumentException("multi-resolution configurations must not be empty"); |
| } |
| |
| mConfigurations = configurations; |
| |
| // For each multi-resolution stream configuration, track how many formats and sizes there |
| // are available to configure |
| for (Map.Entry<String, StreamConfiguration[]> entry : |
| mConfigurations.entrySet()) { |
| String cameraId = entry.getKey(); |
| StreamConfiguration[] configs = entry.getValue(); |
| |
| for (int i = 0; i < configs.length; i++) { |
| StreamConfiguration config = configs[i]; |
| int format = config.getFormat(); |
| |
| MultiResolutionStreamInfo multiResolutionStreamInfo = new MultiResolutionStreamInfo( |
| config.getWidth(), config.getHeight(), cameraId); |
| Map<Integer, List<MultiResolutionStreamInfo>> destMap; |
| if (config.isInput()) { |
| destMap = mMultiResolutionInputConfigs; |
| } else { |
| destMap = mMultiResolutionOutputConfigs; |
| } |
| |
| if (!destMap.containsKey(format)) { |
| List<MultiResolutionStreamInfo> multiResolutionStreamInfoList = |
| new ArrayList<MultiResolutionStreamInfo>(); |
| destMap.put(format, multiResolutionStreamInfoList); |
| } |
| destMap.get(format).add(multiResolutionStreamInfo); |
| } |
| } |
| } |
| |
| /** |
| * Size comparator that compares the number of pixels two MultiResolutionStreamInfo size covers. |
| * |
| * <p>If two the areas of two sizes are same, compare the widths.</p> |
| * |
| * @hide |
| */ |
| public static class SizeComparator implements Comparator<MultiResolutionStreamInfo> { |
| @Override |
| public int compare(@NonNull MultiResolutionStreamInfo lhs, |
| @NonNull MultiResolutionStreamInfo rhs) { |
| return StreamConfigurationMap.compareSizes( |
| lhs.getWidth(), lhs.getHeight(), rhs.getWidth(), rhs.getHeight()); |
| } |
| } |
| |
| /** |
| * Get the output formats in this multi-resolution stream configuration. |
| * |
| * <p>A logical multi-camera or an ultra high resolution sensor camera may support |
| * {@link android.hardware.camera2.MultiResolutionImageReader} to dynamically output maximum |
| * resolutions of different sizes (when switching between physical cameras, or between different |
| * modes of an ultra high resolution sensor camera). This function returns the formats |
| * supported for such case.</p> |
| * |
| * <p>All image formats returned by this function will be defined in either {@link ImageFormat} |
| * or in {@link PixelFormat} (and there is no possibility of collision).</p> |
| * |
| * @return an array of integer format, or empty array if multi-resolution output is not |
| * supported |
| * |
| * @see ImageFormat |
| * @see PixelFormat |
| * @see android.hardware.camera2.MultiResolutionImageReader |
| */ |
| public @NonNull @Format int[] getOutputFormats() { |
| return getPublicImageFormats(/*output*/true); |
| } |
| |
| /** |
| * Get the input formats in this multi-resolution stream configuration. |
| * |
| * <p>A logical multi-camera or ultra high resolution sensor camera may support reprocessing |
| * images of different resolutions when switching between physical cameras, or between |
| * different modes of the ultra high resolution sensor camera. This function returns the |
| * formats supported for such case.</p> |
| * |
| * <p>The supported output format for an input format can be queried by calling the camera |
| * device's {@link StreamConfigurationMap#getValidOutputFormatsForInput}.</p> |
| * |
| * <p>All image formats returned by this function will be defined in either {@link ImageFormat} |
| * or in {@link PixelFormat} (and there is no possibility of collision).</p> |
| * |
| * @return an array of integer format, or empty array if no multi-resolution reprocessing is |
| * supported |
| * |
| * @see ImageFormat |
| * @see PixelFormat |
| */ |
| public @NonNull @Format int[] getInputFormats() { |
| return getPublicImageFormats(/*output*/false); |
| } |
| |
| // Get the list of publicly visible multi-resolution input/output stream formats |
| private int[] getPublicImageFormats(boolean output) { |
| Map<Integer, List<MultiResolutionStreamInfo>> multiResolutionConfigs = |
| output ? mMultiResolutionOutputConfigs : mMultiResolutionInputConfigs; |
| int formatCount = multiResolutionConfigs.size(); |
| |
| int[] formats = new int[formatCount]; |
| int i = 0; |
| for (Integer format : multiResolutionConfigs.keySet()) { |
| formats[i++] = StreamConfigurationMap.imageFormatToPublic(format); |
| } |
| |
| return formats; |
| } |
| |
| /** |
| * Get a group of {@code MultiResolutionStreamInfo} with the requested output image |
| * {@code format} |
| * |
| * <p>The {@code format} should be a supported format (one of the formats returned by |
| * {@link #getOutputFormats}).</p> |
| * |
| * @param format an image format from {@link ImageFormat} or {@link PixelFormat} |
| * @return |
| * a group of supported {@link MultiResolutionStreamInfo}. If the {@code format} is not |
| * a supported multi-resolution output, an empty group is returned. |
| * |
| * @see ImageFormat |
| * @see PixelFormat |
| * @see #getOutputFormats |
| */ |
| public @NonNull Collection<MultiResolutionStreamInfo> getOutputInfo(@Format int format) { |
| return getInfo(format, /*false*/ true); |
| } |
| |
| /** |
| * Get a group of {@code MultiResolutionStreamInfo} with the requested input image {@code format} |
| * |
| * <p>The {@code format} should be a supported format (one of the formats returned by |
| * {@link #getInputFormats}).</p> |
| * |
| * @param format an image format from {@link ImageFormat} or {@link PixelFormat} |
| * @return |
| * a group of supported {@link MultiResolutionStreamInfo}. If the {@code format} is not |
| * a supported multi-resolution input, an empty group is returned. |
| * |
| * @see ImageFormat |
| * @see PixelFormat |
| * @see #getInputFormats |
| */ |
| public @NonNull Collection<MultiResolutionStreamInfo> getInputInfo(@Format int format) { |
| return getInfo(format, /*false*/ false); |
| } |
| |
| // Get multi-resolution stream info for a particular format |
| private @NonNull Collection<MultiResolutionStreamInfo> getInfo(int format, boolean output) { |
| int internalFormat = StreamConfigurationMap.imageFormatToInternal(format); |
| Map<Integer, List<MultiResolutionStreamInfo>> multiResolutionConfigs = |
| output ? mMultiResolutionOutputConfigs : mMultiResolutionInputConfigs; |
| if (multiResolutionConfigs.containsKey(internalFormat)) { |
| return Collections.unmodifiableCollection(multiResolutionConfigs.get(internalFormat)); |
| } else { |
| return Collections.emptyList(); |
| } |
| } |
| |
| private void appendConfigurationsString(StringBuilder sb, boolean output) { |
| sb.append(output ? "Outputs(" : "Inputs("); |
| int[] formats = getPublicImageFormats(output); |
| if (formats != null) { |
| for (int format : formats) { |
| Collection<MultiResolutionStreamInfo> streamInfoList = |
| getInfo(format, output); |
| sb.append("[" + StreamConfigurationMap.formatToString(format) + ":"); |
| for (MultiResolutionStreamInfo streamInfo : streamInfoList) { |
| sb.append(String.format("[w:%d, h:%d, id:%s], ", |
| streamInfo.getWidth(), streamInfo.getHeight(), |
| streamInfo.getPhysicalCameraId())); |
| } |
| // Remove the pending ", " |
| if (sb.charAt(sb.length() - 1) == ' ') { |
| sb.delete(sb.length() - 2, sb.length()); |
| } |
| sb.append("]"); |
| } |
| } |
| sb.append(")"); |
| } |
| |
| /** |
| * Check if this {@link MultiResolutionStreamConfigurationMap} is equal to another |
| * {@link MultiResolutionStreamConfigurationMap}. |
| * |
| * @return {@code true} if the objects were equal, {@code false} otherwise |
| */ |
| @Override |
| public boolean equals(final Object obj) { |
| if (obj == null) { |
| return false; |
| } |
| if (this == obj) { |
| return true; |
| } |
| if (obj instanceof MultiResolutionStreamConfigurationMap) { |
| final MultiResolutionStreamConfigurationMap other = |
| (MultiResolutionStreamConfigurationMap) obj; |
| if (!mConfigurations.keySet().equals(other.mConfigurations.keySet())) { |
| return false; |
| } |
| |
| for (String id : mConfigurations.keySet()) { |
| if (!Arrays.equals(mConfigurations.get(id), other.mConfigurations.get(id))) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public int hashCode() { |
| return HashCodeHelpers.hashCodeGeneric( |
| mConfigurations, mMultiResolutionOutputConfigs, mMultiResolutionInputConfigs); |
| } |
| |
| /** |
| * Return this {@link MultiResolutionStreamConfigurationMap} as a string representation. |
| * |
| * <p>{@code "MultiResolutionStreamConfigurationMap(Outputs([format1: [w:%d, h:%d, id:%s], ... |
| * ... [w:%d, h:%d, id:%s]), [format2: [w:%d, h:%d, id:%s], ... [w:%d, h:%d, id:%s]], ...), |
| * Inputs([format1: [w:%d, h:%d, id:%s], ... [w:%d, h:%d, id:%s], ...).</p> |
| * |
| * @return string representation of {@link MultiResolutionStreamConfigurationMap} |
| */ |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder("MultiResolutionStreamConfigurationMap("); |
| appendConfigurationsString(sb, /*output*/ true); |
| sb.append(","); |
| appendConfigurationsString(sb, /*output*/ false); |
| sb.append(")"); |
| |
| return sb.toString(); |
| } |
| |
| |
| private final Map<String, StreamConfiguration[]> mConfigurations; |
| |
| /** Format -> list of MultiResolutionStreamInfo used to create MultiResolutionImageReader */ |
| private final Map<Integer, List<MultiResolutionStreamInfo>> mMultiResolutionOutputConfigs |
| = new HashMap<Integer, List<MultiResolutionStreamInfo>>(); |
| /** Format -> list of MultiResolutionStreamInfo used for multi-resolution reprocessing */ |
| private final Map<Integer, List<MultiResolutionStreamInfo>> mMultiResolutionInputConfigs |
| = new HashMap<Integer, List<MultiResolutionStreamInfo>>(); |
| } |
