public final class StreamConfigurationMap extends Object
configurations
to set up
Surfaces
for creating a
capture session
with
CameraDevice.createCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
.
This is the authoritative list for all output formats (and sizes respectively for that format) that are supported by a camera device.
This also contains the minimum frame durations and stall durations for each format/size combination that can be used to calculate effective frame rate when submitting multiple captures.
An instance of this object is available from CameraCharacteristics
using
the CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP
key and the
CameraCharacteristics.get(android.hardware.camera2.CameraCharacteristics.Key<T>)
method.
CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
StreamConfigurationMap configs = characteristics.get(
CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
Constructor and Description |
---|
StreamConfigurationMap(StreamConfiguration[] configurations,
StreamConfigurationDuration[] minFrameDurations,
StreamConfigurationDuration[] stallDurations,
StreamConfiguration[] depthConfigurations,
StreamConfigurationDuration[] depthMinFrameDurations,
StreamConfigurationDuration[] depthStallDurations,
HighSpeedVideoConfiguration[] highSpeedVideoConfigurations,
ReprocessFormatsMap inputOutputFormatsMap,
boolean listHighResolution)
Create a new
StreamConfigurationMap . |
Modifier and Type | Method and Description |
---|---|
boolean |
equals(Object obj)
Check if this
StreamConfigurationMap is equal to another
StreamConfigurationMap . |
Size[] |
getHighResolutionOutputSizes(int format)
Get a list of supported high resolution sizes, which cannot operate at full BURST_CAPTURE
rate.
|
Range<Integer>[] |
getHighSpeedVideoFpsRanges()
Get a list of supported high speed video recording FPS ranges.
|
Range<Integer>[] |
getHighSpeedVideoFpsRangesFor(Size size)
Get the frame per second ranges (fpsMin, fpsMax) for input high speed video size.
|
Size[] |
getHighSpeedVideoSizes()
Get a list of supported high speed video recording sizes.
|
Size[] |
getHighSpeedVideoSizesFor(Range<Integer> fpsRange)
Get the supported video sizes for an input high speed FPS range.
|
int[] |
getInputFormats()
Get the image
format input formats in this stream configuration. |
Size[] |
getInputSizes(int format)
Get the supported input sizes for this input format.
|
int[] |
getOutputFormats()
Get the image
format output formats in this stream configuration. |
<T> long |
getOutputMinFrameDuration(Class<T> klass,
Size size)
Get the minimum
frame duration
for the class/size combination (in nanoseconds). |
long |
getOutputMinFrameDuration(int format,
Size size)
Get the minimum
frame duration
for the format/size combination (in nanoseconds). |
<T> Size[] |
getOutputSizes(Class<T> klass)
Get a list of sizes compatible with
klass to use as an output. |
Size[] |
getOutputSizes(int format)
Get a list of sizes compatible with the requested image
format . |
<T> long |
getOutputStallDuration(Class<T> klass,
Size size)
Get the stall duration for the class/size combination (in nanoseconds).
|
long |
getOutputStallDuration(int format,
Size size)
Get the stall duration for the format/size combination (in nanoseconds).
|
int[] |
getValidOutputFormatsForInput(int inputFormat)
Get the image
format output formats for a reprocessing input format. |
int |
hashCode()
Returns a hash code value for the object.
|
static int[] |
imageFormatToInternal(int[] formats)
Convert image formats from public to internal formats (in-place).
|
static <T> boolean |
isOutputSupportedFor(Class<T> klass)
Determine whether or not output streams can be configured with a particular class
as a consumer.
|
boolean |
isOutputSupportedFor(int format)
Determine whether or not output surfaces with a particular user-defined format can be passed
createCaptureSession . |
boolean |
isOutputSupportedFor(Surface surface)
Determine whether or not the
surface in its current state is suitable to be included
in a capture session as an output. |
String |
toString()
Return this
StreamConfigurationMap as a string representation. |
public StreamConfigurationMap(StreamConfiguration[] configurations, StreamConfigurationDuration[] minFrameDurations, StreamConfigurationDuration[] stallDurations, StreamConfiguration[] depthConfigurations, StreamConfigurationDuration[] depthMinFrameDurations, StreamConfigurationDuration[] depthStallDurations, HighSpeedVideoConfiguration[] highSpeedVideoConfigurations, ReprocessFormatsMap inputOutputFormatsMap, boolean listHighResolution)
StreamConfigurationMap
.
The array parameters ownership is passed to this object after creation; do not write to them after this constructor is invoked.
configurations
- a non-null
array of StreamConfiguration
minFrameDurations
- a non-null
array of StreamConfigurationDuration
stallDurations
- a non-null
array of StreamConfigurationDuration
highSpeedVideoConfigurations
- an array of HighSpeedVideoConfiguration
, null if
camera device does not support high speed video recordinglistHighResolution
- a flag indicating whether the device supports BURST_CAPTURE
and thus needs a separate list of slow high-resolution output sizesNullPointerException
- if any of the arguments except highSpeedVideoConfigurations
were null
or any subelements were null
public final int[] getOutputFormats()
format
output formats in this stream configuration.
All image formats returned by this function will be defined in either ImageFormat
or in PixelFormat
(and there is no possibility of collision).
Formats listed in this array are guaranteed to return true if queried with
isOutputSupportedFor(int)
.
ImageFormat
,
PixelFormat
public final int[] getValidOutputFormatsForInput(int inputFormat)
format
output formats for a reprocessing input format.
When submitting a CaptureRequest
with an input Surface of a given format,
the only allowed target outputs of the CaptureRequest
are the ones with a format
listed in the return value of this method. Including any other output Surface as a target
will throw an IllegalArgumentException. If no output format is supported given the input
format, an empty int[] will be returned.
All image formats returned by this function will be defined in either ImageFormat
or in PixelFormat
(and there is no possibility of collision).
Formats listed in this array are guaranteed to return true if queried with
isOutputSupportedFor(int)
.
ImageFormat
,
PixelFormat
public final int[] getInputFormats()
format
input formats in this stream configuration.
All image formats returned by this function will be defined in either ImageFormat
or in PixelFormat
(and there is no possibility of collision).
ImageFormat
,
PixelFormat
public Size[] getInputSizes(int format)
The format must have come from getInputFormats()
; otherwise
null
is returned.
format
- a format from getInputFormats()
null
if the format was not available.public boolean isOutputSupportedFor(int format)
createCaptureSession
.
This method determines that the output format
is supported by the camera device;
each output surface
target may or may not itself support that format
.
Refer to the class which provides the surface for additional documentation.
Formats for which this returns true
are guaranteed to exist in the result
returned by getOutputSizes(java.lang.Class<T>)
.
format
- an image format from either ImageFormat
or PixelFormat
true
iff using a surface
with this format
will be
supported with CameraDevice.createCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
IllegalArgumentException
- if the image format was not a defined named constant
from either ImageFormat
or PixelFormat
ImageFormat
,
PixelFormat
,
CameraDevice.createCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
public static <T> boolean isOutputSupportedFor(Class<T> klass)
The following list is generally usable for outputs:
ImageReader
-
Recommended for image processing or streaming to external resources (such as a file or
network)
MediaRecorder
-
Recommended for recording video (simple to use)
MediaCodec
-
Recommended for recording video (more complicated to use, with more flexibility)
Allocation
-
Recommended for image processing with RenderScript
SurfaceHolder
-
Recommended for low-power camera preview with SurfaceView
SurfaceTexture
-
Recommended for OpenGL-accelerated preview processing or compositing with
TextureView
Generally speaking this means that creating a Surface
from that class may
provide a producer endpoint that is suitable to be used with
CameraDevice.createCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
.
Since not all of the above classes support output of all format and size combinations,
the particular combination should be queried with isOutputSupportedFor(Surface)
.
klass
- a non-null
Class
object referencetrue
if this class is supported as an output, false
otherwiseNullPointerException
- if klass
was null
CameraDevice.createCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
,
isOutputSupportedFor(Surface)
public boolean isOutputSupportedFor(Surface surface)
surface
in its current state is suitable to be included
in a capture session
as an output.
Not all surfaces are usable with the CameraDevice
, and not all configurations
of that surface
are compatible. Some classes that provide the surface
are
compatible with the CameraDevice
in general
(see isOutputSupportedFor(Class)
, but it is the caller's responsibility to put the
surface
into a state that will be compatible with the CameraDevice
.
Reasons for a surface
being specifically incompatible might be:
getOutputFormats()
getOutputSizes(java.lang.Class<T>)
surface
itself is not in a state where it can service a new producer.
Surfaces from flexible sources will return true even if the exact size of the Surface does not match a camera-supported size, as long as the format (or class) is supported and the camera device supports a size that is equal to or less than 1080p in that format. If such as Surface is used to create a capture session, it will have its size rounded to the nearest supported size, below or equal to 1080p. Flexible sources include SurfaceView, SurfaceTexture, and ImageReader.
This is not an exhaustive list; see the particular class's documentation for further possible reasons of incompatibility.
surface
- a non-null
Surface
object referencetrue
if this is supported, false
otherwiseNullPointerException
- if surface
was null
IllegalArgumentException
- if the Surface endpoint is no longer validCameraDevice.createCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
,
isOutputSupportedFor(Class)
public <T> Size[] getOutputSizes(Class<T> klass)
klass
to use as an output.
Some of the supported classes may support additional formats beyond
ImageFormat.PRIVATE
; this function only returns
sizes for ImageFormat.PRIVATE
. For example, ImageReader
supports ImageFormat.YUV_420_888
and ImageFormat.PRIVATE
, this method will
only return the sizes for ImageFormat.PRIVATE
for ImageReader
class.
If a well-defined format such as NV21
is required, use
getOutputSizes(int)
instead.
The klass
should be a supported output, that querying
#isOutputSupportedFor(Class)
should return true
.
klass
- a non-null
Class
object referenceImageFormat.PRIVATE
format,
or null
iff the klass
is not a supported output.NullPointerException
- if klass
was null
isOutputSupportedFor(Class)
public Size[] getOutputSizes(int format)
format
.
The format
should be a supported format (one of the formats returned by
getOutputFormats()
).
getHighResolutionOutputSizes(int)
method can be used on devices
that support the
BURST_CAPTURE
capability to get a list of high-resolution output sizes that cannot operate at the preferred
20fps rate. This means that for some supported formats, this method will return an empty
list, if all the supported resolutions operate at below 20fps. For devices that do not
support the BURST_CAPTURE capability, all output resolutions are listed through this method.format
- an image format from ImageFormat
or PixelFormat
null
if the format
is not a supported outputImageFormat
,
PixelFormat
,
getOutputFormats()
public Size[] getHighSpeedVideoSizes()
When CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO
is
supported in CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES
, this method will
list the supported high speed video size configurations. All the sizes listed will be a
subset of the sizes reported by getOutputSizes(java.lang.Class<T>)
for processed non-stalling formats
(typically ImageFormat.PRIVATE
ImageFormat.YUV_420_888
, etc.)
To enable high speed video recording, application must create a constrained create high speed
capture session via CameraDevice.createConstrainedHighSpeedCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
, and submit
a CaptureRequest list created by
CameraConstrainedHighSpeedCaptureSession.createHighSpeedRequestList(android.hardware.camera2.CaptureRequest)
to this session. The application must select the video size from this method and
FPS range
from
getHighSpeedVideoFpsRangesFor(android.util.Size)
to configure the constrained high speed session and
generate the high speed request list. For example, if the application intends to do high
speed recording, it can select the maximum size reported by this method to create high speed
capture session. Note that for the use case of multiple output streams, application must
select one unique size from this method to use (e.g., preview and recording streams must have
the same size). Otherwise, the high speed session creation will fail. Once the size is
selected, application can get the supported FPS ranges by
getHighSpeedVideoFpsRangesFor(android.util.Size)
, and use these FPS ranges to setup the recording
request lists via
CameraConstrainedHighSpeedCaptureSession.createHighSpeedRequestList(android.hardware.camera2.CaptureRequest)
.
getHighSpeedVideoFpsRangesFor(Size)
,
CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO
,
CameraDevice.createConstrainedHighSpeedCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
,
CameraConstrainedHighSpeedCaptureSession.createHighSpeedRequestList(android.hardware.camera2.CaptureRequest)
public Range<Integer>[] getHighSpeedVideoFpsRangesFor(Size size)
See getHighSpeedVideoFpsRanges()
for how to enable high speed recording.
The FPS ranges
reported in this method
must not be used to setup capture requests that are submitted to unconstrained capture
sessions, or it will result in IllegalArgumentExceptions
.
See getHighSpeedVideoFpsRanges()
for the characteristics of the returned FPS ranges.
size
- one of the sizes returned by getHighSpeedVideoSizes()
IllegalArgumentException
- if input size does not exist in the return value of
getHighSpeedVideoSizesgetHighSpeedVideoSizes()
,
getHighSpeedVideoFpsRanges()
public Range<Integer>[] getHighSpeedVideoFpsRanges()
When CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO
is
supported in CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES
, this method will
list the supported high speed video FPS range configurations. Application can then use
getHighSpeedVideoSizesFor(android.util.Range<java.lang.Integer>)
to query available sizes for one of returned FPS range.
To enable high speed video recording, application must create a constrained create high speed
capture session via CameraDevice.createConstrainedHighSpeedCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
, and submit
a CaptureRequest list created by
CameraConstrainedHighSpeedCaptureSession.createHighSpeedRequestList(android.hardware.camera2.CaptureRequest)
to this session. The application must select the video size from this method and
FPS range
from
getHighSpeedVideoFpsRangesFor(android.util.Size)
to configure the constrained high speed session and
generate the high speed request list. For example, if the application intends to do high
speed recording, it can select one FPS range reported by this method, query the video sizes
corresponding to this FPS range by getHighSpeedVideoSizesFor(android.util.Range<java.lang.Integer>)
and use one of reported
sizes to create a high speed capture session. Note that for the use case of multiple output
streams, application must select one unique size from this method to use (e.g., preview and
recording streams must have the same size). Otherwise, the high speed session creation will
fail. Once the high speed capture session is created, the application can set the FPS range
in the recording request lists via
CameraConstrainedHighSpeedCaptureSession.createHighSpeedRequestList(android.hardware.camera2.CaptureRequest)
.
The FPS ranges reported by this method will have below characteristics:
getHighSpeedVideoSizesFor(android.util.Range<java.lang.Integer>)
,
CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO
,
CameraDevice.createConstrainedHighSpeedCaptureSession(java.util.List<android.view.Surface>, android.hardware.camera2.CameraCaptureSession.StateCallback, android.os.Handler)
,
CameraDevice#createHighSpeedRequestList
public Size[] getHighSpeedVideoSizesFor(Range<Integer> fpsRange)
See getHighSpeedVideoSizes()
for how to enable high speed recording.
fpsRange
- one of the FPS range returned by getHighSpeedVideoFpsRanges()
IllegalArgumentException
- if input FPS range does not exist in the return value of
getHighSpeedVideoFpsRangesgetHighSpeedVideoFpsRanges()
public Size[] getHighResolutionOutputSizes(int format)
This includes all output sizes that cannot meet the 20 fps frame rate requirements for the
BURST_CAPTURE
capability. This does not include the stall duration, so for example, a JPEG or RAW16 output
resolution with a large stall duration but a minimum frame duration that's above 20 fps will
still be listed in the regular getOutputSizes(java.lang.Class<T>)
list. All the sizes on this list are
still guaranteed to operate at a rate of at least 10 fps, not including stall duration.
For a device that does not support the BURST_CAPTURE capability, this list will be
null
, since resolutions in the getOutputSizes(java.lang.Class<T>)
list are already not
guaranteed to meet >= 20 fps rate requirements. For a device that does support the
BURST_CAPTURE capability, this list may be empty, if all supported resolutions meet the 20
fps requirement.
null
if the
BURST_CAPTURE capability is not supportedpublic long getOutputMinFrameDuration(int format, Size size)
frame duration
for the format/size combination (in nanoseconds).
format
should be one of the ones returned by getOutputFormats()
.
size
should be one of the ones returned by
getOutputSizes(int)
.
This should correspond to the frame duration when only that stream is active, with all
processing (typically in android.*.mode
) set to either OFF
or FAST
.
When multiple streams are used in a request, the minimum frame duration will be
max(individual stream min durations)
.
For devices that do not support manual sensor control
(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR
),
this function may return 0.
format
- an image format from ImageFormat
or PixelFormat
size
- an output-compatible size>
0 in nanoseconds, or
0 if the minimum frame duration is not available.IllegalArgumentException
- if format
or size
was not supportedNullPointerException
- if size
was null
CaptureRequest.SENSOR_FRAME_DURATION
,
getOutputStallDuration(int, Size)
,
ImageFormat
,
PixelFormat
public <T> long getOutputMinFrameDuration(Class<T> klass, Size size)
frame duration
for the class/size combination (in nanoseconds).
This assumes a the klass
is set up to use ImageFormat.PRIVATE
.
For user-defined formats, use getOutputMinFrameDuration(int, Size)
.
klass
should be one of the ones which is supported by
isOutputSupportedFor(Class)
.
size
should be one of the ones returned by
getOutputSizes(int)
.
This should correspond to the frame duration when only that stream is active, with all
processing (typically in android.*.mode
) set to either OFF
or FAST
.
When multiple streams are used in a request, the minimum frame duration will be
max(individual stream min durations)
.
For devices that do not support manual sensor control
(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR
),
this function may return 0.
klass
- a class which is supported by isOutputSupportedFor(Class)
and has a
non-empty array returned by getOutputSizes(Class)
size
- an output-compatible size>
0 in nanoseconds, or
0 if the minimum frame duration is not available.IllegalArgumentException
- if klass
or size
was not supportedNullPointerException
- if size
or klass
was null
CaptureRequest.SENSOR_FRAME_DURATION
,
ImageFormat
,
PixelFormat
public long getOutputStallDuration(int format, Size size)
format
should be one of the ones returned by getOutputFormats()
.
size
should be one of the ones returned by
getOutputSizes(int)
.
A stall duration is how much extra time would get added to the normal minimum frame duration for a repeating request that has streams with non-zero stall.
For example, consider JPEG captures which have the following characteristics:
In other words, using a repeating YUV request would result in a steady frame rate (let's say it's 30 FPS). If a single JPEG request is submitted periodically, the frame rate will stay at 30 FPS (as long as we wait for the previous JPEG to return each time). If we try to submit a repeating YUV + JPEG request, then the frame rate will drop from 30 FPS.
In general, submitting a new request with a non-0 stall time stream will not cause a frame rate drop unless there are still outstanding buffers for that stream from previous requests.
Submitting a repeating request with streams (call this S
) is the same as setting
the minimum frame duration from the normal minimum frame duration corresponding to S
,
added with the maximum stall duration for S
.
If interleaving requests with and without a stall duration, a request will stall by the maximum of the remaining times for each can-stall stream with outstanding buffers.
This means that a stalling request will not have an exposure start until the stall has completed.
This should correspond to the stall duration when only that stream is active, with all
processing (typically in android.*.mode
) set to FAST
or OFF
.
Setting any of the processing modes to HIGH_QUALITY
effectively results in an
indeterminate stall duration for all streams in a request (the regular stall calculation
rules are ignored).
The following formats may always have a stall duration:
The following formats will never have a stall duration:
All other formats may or may not have an allowed stall duration on a per-capability basis;
refer to android.request.availableCapabilities
for more details.
See android.sensor.frameDuration
for more information about calculating the max frame rate (absent stalls).
format
- an image format from ImageFormat
or PixelFormat
size
- an output-compatible size>=
0 in nanosecondsIllegalArgumentException
- if format
or size
was not supportedNullPointerException
- if size
was null
CaptureRequest.SENSOR_FRAME_DURATION
,
ImageFormat
,
PixelFormat
public <T> long getOutputStallDuration(Class<T> klass, Size size)
This assumes a the klass
is set up to use ImageFormat.PRIVATE
.
For user-defined formats, use getOutputMinFrameDuration(int, Size)
.
klass
should be one of the ones with a non-empty array returned by
getOutputSizes(Class)
.
size
should be one of the ones returned by
getOutputSizes(Class)
.
See getOutputStallDuration(int, Size)
for a definition of a
stall duration.
klass
- a class which is supported by isOutputSupportedFor(Class)
and has a
non-empty array returned by getOutputSizes(Class)
size
- an output-compatible size>=
0 in nanosecondsIllegalArgumentException
- if klass
or size
was not supportedNullPointerException
- if size
or klass
was null
CaptureRequest.SENSOR_FRAME_DURATION
,
ImageFormat
,
PixelFormat
public boolean equals(Object obj)
StreamConfigurationMap
is equal to another
StreamConfigurationMap
.
Two vectors are only equal if and only if each of the respective elements is equal.
equals
in class Object
obj
- the reference object with which to compare.true
if the objects were equal, false
otherwiseObject.hashCode()
,
HashMap
public int hashCode()
HashMap
.
The general contract of hashCode
is:
hashCode
method
must consistently return the same integer, provided no information
used in equals
comparisons on the object is modified.
This integer need not remain consistent from one execution of an
application to another execution of the same application.
equals(Object)
method, then calling the hashCode
method on each of
the two objects must produce the same integer result.
Object.equals(java.lang.Object)
method, then calling the hashCode
method on each of the
two objects must produce distinct integer results. However, the
programmer should be aware that producing distinct integer results
for unequal objects may improve the performance of hash tables.
As much as is reasonably practical, the hashCode method defined by
class Object
does return distinct integers for distinct
objects. (This is typically implemented by converting the internal
address of the object into an integer, but this implementation
technique is not required by the
JavaTM programming language.)
hashCode
in class Object
Object.equals(java.lang.Object)
,
System.identityHashCode(java.lang.Object)
public static int[] imageFormatToInternal(int[] formats)
formats
- an array of image formatsformats
imageFormatToInternal(int)
public String toString()
StreamConfigurationMap
as a string representation.
"StreamConfigurationMap(Outputs([w:%d, h:%d, format:%s(%d), min_duration:%d,
stall:%d], ... [w:%d, h:%d, format:%s(%d), min_duration:%d, stall:%d]), Inputs([w:%d, h:%d,
format:%s(%d)], ... [w:%d, h:%d, format:%s(%d)]), ValidOutputFormatsForInput(
[in:%d, out:%d, ... %d], ... [in:%d, out:%d, ... %d]), HighSpeedVideoConfigurations(
[w:%d, h:%d, min_fps:%d, max_fps:%d], ... [w:%d, h:%d, min_fps:%d, max_fps:%d]))"
.
Outputs([w:%d, h:%d, format:%s(%d), min_duration:%d, stall:%d], ...
[w:%d, h:%d, format:%s(%d), min_duration:%d, stall:%d])
, where
[w:%d, h:%d, format:%s(%d), min_duration:%d, stall:%d]
represents an output
configuration's width, height, format, minimal frame duration in nanoseconds, and stall
duration in nanoseconds.
Inputs([w:%d, h:%d, format:%s(%d)], ... [w:%d, h:%d, format:%s(%d)])
, where
[w:%d, h:%d, format:%s(%d)]
represents an input configuration's width, height, and
format.
ValidOutputFormatsForInput([in:%s(%d), out:%s(%d), ... %s(%d)],
... [in:%s(%d), out:%s(%d), ... %s(%d)])
, where [in:%s(%d), out:%s(%d), ... %s(%d)]
represents an input fomat and its valid output formats.
HighSpeedVideoConfigurations([w:%d, h:%d, min_fps:%d, max_fps:%d],
... [w:%d, h:%d, min_fps:%d, max_fps:%d])
, where
[w:%d, h:%d, min_fps:%d, max_fps:%d]
represents a high speed video output
configuration's width, height, minimal frame rate, and maximal frame rate.
toString
in class Object
StreamConfigurationMap