Merge "Camera2: add highSpeedVideoConfig wrapper and APIs" into lmp-dev (8f8141e2) · Commits · e / os / android_frameworks_base

api/current.txt

+4 −0

Original line number	Diff line number	Diff line
		@@ -13128,6 +13128,10 @@ package android.hardware.camera2.params {
		}

		public final class StreamConfigurationMap {
		method public android.util.Range<java.lang.Integer>[] getHighSpeedVideoFpsRanges();
		method public android.util.Range<java.lang.Integer>[] getHighSpeedVideoFpsRangesFor(android.util.Size);
		method public android.util.Size[] getHighSpeedVideoSizes();
		method public android.util.Size[] getHighSpeedVideoSizesFor(android.util.Range<java.lang.Integer>);
		method public final int[] getOutputFormats();
		method public long getOutputMinFrameDuration(int, android.util.Size);
		method public long getOutputMinFrameDuration(java.lang.Class<T>, android.util.Size);

core/java/android/hardware/camera2/CameraCharacteristics.java

+5 −3

Original line number	Diff line number	Diff line
		@@ -516,7 +516,9 @@ public final class CameraCharacteristics extends CameraMetadata<CameraCharacteri
		* to do high speed recording, it can select the maximum size reported by this metadata to
		* configure output streams. Once the size is selected, application can filter this metadata
		* by selected size and get the supported fps ranges, and use these fps ranges to setup the
		* recording requests.</p>
		* recording requests. Note that for the use case of multiple output streams, application
		* must select one unique size from this metadata to use. Otherwise a request error might
		* occur.</p>
		* <p>For normal video recording use case, where some application will NOT set
		* {@link CaptureRequest#CONTROL_SCENE_MODE android.control.sceneMode} to HIGH_SPEED_VIDEO in capture requests, the fps ranges
		* reported in this metadata must not be used to setup capture requests, or it will cause
		@@ -526,8 +528,8 @@ public final class CameraCharacteristics extends CameraMetadata<CameraCharacteri
		* @see CaptureRequest#CONTROL_SCENE_MODE
		* @hide
		*/
		public static final Key<int[]> CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS =
		new Key<int[]>("android.control.availableHighSpeedVideoConfigurations", int[].class);
		public static final Key<android.hardware.camera2.params.HighSpeedVideoConfiguration[]> CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS =
		new Key<android.hardware.camera2.params.HighSpeedVideoConfiguration[]>("android.control.availableHighSpeedVideoConfigurations", android.hardware.camera2.params.HighSpeedVideoConfiguration[].class);

		/**
		* <p>The set of edge enhancement modes supported by this camera device.</p>

core/java/android/hardware/camera2/impl/CameraMetadataNative.java

+7 −1

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@ import android.hardware.camera2.marshal.impl.MarshalQueryableBoolean;
		import android.hardware.camera2.marshal.impl.MarshalQueryableBlackLevelPattern;
		import android.hardware.camera2.marshal.impl.MarshalQueryableColorSpaceTransform;
		import android.hardware.camera2.marshal.impl.MarshalQueryableEnum;
		import android.hardware.camera2.marshal.impl.MarshalQueryableHighSpeedVideoConfiguration;
		import android.hardware.camera2.marshal.impl.MarshalQueryableMeteringRectangle;
		import android.hardware.camera2.marshal.impl.MarshalQueryableNativeByteToInteger;
		import android.hardware.camera2.marshal.impl.MarshalQueryablePair;
		@@ -45,6 +46,7 @@ import android.hardware.camera2.marshal.impl.MarshalQueryableStreamConfiguration
		import android.hardware.camera2.marshal.impl.MarshalQueryableStreamConfigurationDuration;
		import android.hardware.camera2.marshal.impl.MarshalQueryableString;
		import android.hardware.camera2.params.Face;
		import android.hardware.camera2.params.HighSpeedVideoConfiguration;
		import android.hardware.camera2.params.LensShadingMap;
		import android.hardware.camera2.params.StreamConfiguration;
		import android.hardware.camera2.params.StreamConfigurationDuration;
		@@ -747,8 +749,11 @@ public class CameraMetadataNative implements Parcelable {
		CameraCharacteristics.SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
		StreamConfigurationDuration[] stallDurations = getBase(
		CameraCharacteristics.SCALER_AVAILABLE_STALL_DURATIONS);
		HighSpeedVideoConfiguration[] highSpeedVideoConfigurations = getBase(
		CameraCharacteristics.CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS);

		return new StreamConfigurationMap(configurations, minFrameDurations, stallDurations);
		return new StreamConfigurationMap(
		configurations, minFrameDurations, stallDurations, highSpeedVideoConfigurations);
		}

		private <T> Integer getMaxRegions(Key<T> key) {
		@@ -1115,6 +1120,7 @@ public class CameraMetadataNative implements Parcelable {
		new MarshalQueryableStreamConfigurationDuration(),
		new MarshalQueryableRggbChannelVector(),
		new MarshalQueryableBlackLevelPattern(),
		new MarshalQueryableHighSpeedVideoConfiguration(),

		// generic parcelable marshaler (MUST BE LAST since it has lowest priority)
		new MarshalQueryableParcelable(),

core/java/android/hardware/camera2/marshal/impl/MarshalQueryableHighSpeedVideoConfiguration.java

0 → 100644

+83 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 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.marshal.impl;

		import android.hardware.camera2.marshal.Marshaler;
		import android.hardware.camera2.marshal.MarshalQueryable;
		import android.hardware.camera2.params.HighSpeedVideoConfiguration;
		import android.hardware.camera2.utils.TypeReference;

		import static android.hardware.camera2.impl.CameraMetadataNative.*;
		import static android.hardware.camera2.marshal.MarshalHelpers.*;

		import java.nio.ByteBuffer;

		/**
		* Marshaler for {@code android.control.availableHighSpeedVideoConfigurations} custom class
		* {@link HighSpeedVideoConfiguration}
		*
		* <p>Data is stored as {@code (width, height, fpsMin, fpsMax)} tuples (int32).</p>
		*/
		public class MarshalQueryableHighSpeedVideoConfiguration
		implements MarshalQueryable<HighSpeedVideoConfiguration> {
		private static final int SIZE = SIZEOF_INT32 * 4;

		private class MarshalerHighSpeedVideoConfiguration
		extends Marshaler<HighSpeedVideoConfiguration> {
		protected MarshalerHighSpeedVideoConfiguration(
		TypeReference<HighSpeedVideoConfiguration> typeReference,
		int nativeType) {
		super(MarshalQueryableHighSpeedVideoConfiguration.this, typeReference, nativeType);
		}

		@Override
		public void marshal(HighSpeedVideoConfiguration value, ByteBuffer buffer) {
		buffer.putInt(value.getWidth());
		buffer.putInt(value.getHeight());
		buffer.putInt(value.getFpsMin());
		buffer.putInt(value.getFpsMax());
		}

		@Override
		public HighSpeedVideoConfiguration unmarshal(ByteBuffer buffer) {
		int width = buffer.getInt();
		int height = buffer.getInt();
		int fpsMin = buffer.getInt();
		int fpsMax = buffer.getInt();

		return new HighSpeedVideoConfiguration(width, height, fpsMin, fpsMax);
		}

		@Override
		public int getNativeSize() {
		return SIZE;
		}

		}

		@Override
		public Marshaler<HighSpeedVideoConfiguration> createMarshaler(
		TypeReference<HighSpeedVideoConfiguration> managedType, int nativeType) {
		return new MarshalerHighSpeedVideoConfiguration(managedType, nativeType);
		}

		@Override
		public boolean isTypeMappingSupported(TypeReference<HighSpeedVideoConfiguration> managedType,
		int nativeType) {
		return nativeType == TYPE_INT32 &&
		managedType.getType().equals(HighSpeedVideoConfiguration.class);
		}
		}

core/java/android/hardware/camera2/params/HighSpeedVideoConfiguration.java

0 → 100644

+157 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 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 static com.android.internal.util.Preconditions.*;

		import android.hardware.camera2.CameraCharacteristics;
		import android.hardware.camera2.utils.HashCodeHelpers;
		import android.util.Range;
		import android.util.Size;

		/**
		* Immutable class to store the available
		* {@link CameraCharacteristics#CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS high speed video
		* configurations}
		*
		* @see CameraCharacteristics#CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS
		*
		* @hide
		*/
		public final class HighSpeedVideoConfiguration {

		/**
		* Create a new {@link HighSpeedVideoConfiguration}.
		*
		* @param width image width, in pixels (positive)
		* @param height image height, in pixels (positive)
		* @param fpsMin minimum frames per second for the configuration (positive)
		* @param fpsMax maximum frames per second for the configuration (larger or equal to 60)
		*
		* @throws IllegalArgumentException
		* if width/height/fpsMin were not positive or fpsMax less than 60
		*
		* @hide
		*/
		public HighSpeedVideoConfiguration(
		final int width, final int height, final int fpsMin, final int fpsMax) {
		if (fpsMax < 60) {
		throw new IllegalArgumentException("fpsMax must be at least 60");
		}
		mFpsMax = fpsMax;
		mWidth = checkArgumentPositive(width, "width must be positive");
		mHeight = checkArgumentPositive(height, "height must be positive");
		mFpsMin = checkArgumentPositive(fpsMin, "fpsMin must be positive");
		mSize = new Size(mWidth, mHeight);
		mFpsRange = new Range<Integer>(mFpsMin, mFpsMax);
		}

		/**
		* Return the width of the high speed video configuration.
		*
		* @return width > 0
		*/
		public int getWidth() {
		return mWidth;
		}

		/**
		* Return the height of the high speed video configuration.
		*
		* @return height > 0
		*/
		public int getHeight() {
		return mHeight;
		}

		/**
		* Return the minimum frame per second of the high speed video configuration.
		*
		* @return fpsMin > 0
		*/
		public int getFpsMin() {
		return mFpsMin;
		}

		/**
		* Return the maximum frame per second of the high speed video configuration.
		*
		* @return fpsMax >= 60
		*/
		public int getFpsMax() {
		return mFpsMax;
		}

		/**
		* Convenience method to return the size of this high speed video configuration.
		*
		* @return a Size with positive width and height
		*/
		public Size getSize() {
		return mSize;
		}

		/**
		* Convenience method to return the FPS range of this high speed video configuration.
		*
		* @return a Range with high bound >= 60
		*/
		public Range<Integer> getFpsRange() {
		return mFpsRange;
		}

		/**
		* Check if this {@link HighSpeedVideoConfiguration} is equal to another
		* {@link HighSpeedVideoConfiguration}.
		*
		* <p>Two configurations are equal if and only if each of the respective elements is equal.</p>
		*
		* @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 HighSpeedVideoConfiguration) {
		final HighSpeedVideoConfiguration other = (HighSpeedVideoConfiguration) obj;
		return mWidth == other.mWidth &&
		mHeight == other.mHeight &&
		mFpsMin == other.mFpsMin &&
		mFpsMax == other.mFpsMax;
		}
		return false;
		}

		/**
		* {@inheritDoc}
		*/
		@Override
		public int hashCode() {
		return HashCodeHelpers.hashCode(mWidth, mHeight, mFpsMin, mFpsMax);
		}

		private final int mWidth;
		private final int mHeight;
		private final int mFpsMin;
		private final int mFpsMax;
		private final Size mSize;
		private final Range<Integer> mFpsRange;
		}