Merge "MultiResolutionImageReader: Add overloaded constructor method" into main

package android.hardware.camera2;

import android.annotation.CallbackExecutor;

import android.annotation.FlaggedApi;

import android.annotation.IntRange;

import android.annotation.NonNull;

import android.annotation.Nullable;

import android.util.Log;

import android.view.Surface;

import com.android.internal.camera.flags.Flags;

import java.nio.NioUtils;

import java.util.ArrayList;

        }

    }

    /**

     * <p>

     * Create a new multi-resolution reader based on a group of camera stream properties returned

     * by a camera device, and the desired format, maximum buffer capacity and consumer usage flag.

     * </p>

     * <p>

     * The valid size and formats depend on the camera characteristics.

     * {@code MultiResolutionImageReader} for an image format is supported by the camera device if

     * the format is in the supported multi-resolution output stream formats returned by

     * {@link android.hardware.camera2.params.MultiResolutionStreamConfigurationMap#getOutputFormats}.

     * If the image format is supported, the {@code MultiResolutionImageReader} object can be

     * created with the {@code streams} objects returned by

     * {@link android.hardware.camera2.params.MultiResolutionStreamConfigurationMap#getOutputInfo}.

     * </p>

     * <p>

     * The {@code maxImages} parameter determines the maximum number of

     * {@link Image} objects that can be acquired from each of the {@code ImageReader}

     * within the {@code MultiResolutionImageReader}. However, requesting more buffers will

     * use up more memory, so it is important to use only the minimum number necessary. The

     * application is strongly recommended to acquire no more than {@code maxImages} images

     * from all of the internal ImageReader objects combined. By keeping track of the number of

     * acquired images for the MultiResolutionImageReader, the application doesn't need to do the

     * bookkeeping for each internal ImageReader returned from {@link

     * ImageReader.OnImageAvailableListener#onImageAvailable onImageAvailable} callback.

     * </p>

     * <p>

     * Unlike the normal ImageReader, the MultiResolutionImageReader has a more complex

     * configuration sequence. Instead of passing the same surface to OutputConfiguration and

     * CaptureRequest, the

     * {@link android.hardware.camera2.params.OutputConfiguration#createInstancesForMultiResolutionOutput}

     * call needs to be used to create the OutputConfigurations for session creation, and then

     * {@link #getSurface} is used to get {@link CaptureRequest.Builder#addTarget the target for

     * CaptureRequest}.

     * </p>

     * @param streams The group of multi-resolution stream info, which is used to create

     *            a multi-resolution reader containing a number of ImageReader objects. Each

     *            ImageReader object represents a multi-resolution stream in the group.

     * @param format The format of the Image that this multi-resolution reader will produce.

     *            This must be one of the {@link android.graphics.ImageFormat} or

     *            {@link android.graphics.PixelFormat} constants. Note that not all formats are

     *            supported, like ImageFormat.NV21. The supported multi-resolution

     *            reader format can be queried by {@link

     *            android.hardware.camera2.params.MultiResolutionStreamConfigurationMap#getOutputFormats}.

     * @param maxImages The maximum number of images the user will want to

     *            access simultaneously. This should be as small as possible to

     *            limit memory use. Once maxImages images are obtained by the

     *            user from any given internal ImageReader, one of them has to be released before

     *            a new Image will become available for access through the ImageReader's

     *            {@link ImageReader#acquireLatestImage()} or

     *            {@link ImageReader#acquireNextImage()}. Must be greater than 0.

     * @param usage The intended usage of the images produced by the internal ImageReader. See the usages

     *              on {@link HardwareBuffer} for a list of valid usage bits. See also

     *              {@link HardwareBuffer#isSupported(int, int, int, int, long)} for checking

     *              if a combination is supported. If it's not supported this will throw

     *              an {@link IllegalArgumentException}.

     * @see Image

     * @see

     * android.hardware.camera2.CameraCharacteristics#SCALER_MULTI_RESOLUTION_STREAM_CONFIGURATION_MAP

     * @see

     * android.hardware.camera2.params.MultiResolutionStreamConfigurationMap

     *

     * @hide

     */

    @FlaggedApi(Flags.FLAG_MULTIRESOLUTION_IMAGEREADER_USAGE_CONFIG)

    public MultiResolutionImageReader(

            @NonNull Collection<MultiResolutionStreamInfo> streams,

            @Format             int format,

            @IntRange(from = 1) int maxImages,

            @Usage              long usage) {

        mFormat = format;

        mMaxImages = maxImages;

        if (streams == null || streams.size() <= 1) {

            throw new IllegalArgumentException(

                "The streams info collection must contain at least 2 entries");

        }

        if (mMaxImages < 1) {

            throw new IllegalArgumentException(

                "Maximum outstanding image count must be at least 1");

        }

        if (format == ImageFormat.NV21) {

            throw new IllegalArgumentException(

                    "NV21 format is not supported");

        }

        int numImageReaders = streams.size();

        mReaders = new ImageReader[numImageReaders];

        mStreamInfo = new MultiResolutionStreamInfo[numImageReaders];

        int index = 0;

        for (MultiResolutionStreamInfo streamInfo : streams) {

            mReaders[index] = ImageReader.newInstance(streamInfo.getWidth(),

                    streamInfo.getHeight(), format, maxImages, usage);

            mStreamInfo[index] = streamInfo;

            index++;

        }

    }

    /**

     * Set onImageAvailableListener callback.

     *