How to get available resolutions using CameraX on Android?

user_1680301 0
Viewed 5950

Is there a way to query the available camera resolutions using CameraX? With Camera2 this is possible using StreamConfigurationMap.getOutputSizes(). However, I can't find a way to do this using CameraX.

It doesn't help that the documentation is quite outdated. Currently it references version 1.0.0-alpha06 and many APIs have changed in the latest 1.0.0-beta01.

EDIT:

There is a way to get the available resolutions using Camera2 APIs (thanks to Wasim's answer below). However, that's only possible after the camera is bound to the lifecycle and therefore the target resolution cannot be changed anymore, which makes it quite useless.

Sure I can specify the target resolution without knowing the available ones but this way I have no control over the resulted aspect ratio. In my case, I end up with a 16:9 Preview and a 4:3 ImageAnalysis although the targetResolution for my ImageAnalysis is in 16:9 (224x126).

For the record, this is how you could get the output sizes:

val camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageAnalyzer)
val cameraId = Camera2CameraInfo.extractCameraId(camera.cameraInfo)
val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
val characteristics = cameraManager.getCameraCharacteristics(cameraId)
val streamConfigurationMap = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
val outputSizes = streamConfigurationMap.getOutputSizes(format)

Still looking for an actual solution. Thanks in advance.

android-camerax android
5 Answers

This could help anyone googling here.

Android CameraX, get camera characteristics such as CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE.

For 2021 the syntax is like ...

So, you've gone through the process of getting the camera ...

theCamera = cameraProvider.bindToLifecycle((LifecycleOwner)this,
              yourCameraSelector, yourImageAnalysis, yourPreview);

the code nowadays is:

CameraCharacteristics camChars = Camera2CameraInfo
   .extractCameraCharacteristics(theCamera.getCameraInfo());
float discoveredMinFocusDistance = camChars
   .get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE);

You'll probably need a

@SuppressLint("UnsafeExperimentalUsageError")
CameraCharacteristics camChars =  ...

for that first line.

user_2948840

This worked for me:

val camera = cameraProvider.bindToLifecycle(mainActivity, cameraSelector, CameraManager.imageAnalysis)

val cameraId = Camera2CameraInfo.from(camera.cameraInfo).cameraId
val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
val characteristics = cameraManager.getCameraCharacteristics(cameraId)
val configs: StreamConfigurationMap? = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)

val imageAnalysisSizes = configs?.getOutputSizes(ImageFormat.YUV_420_888)
imageAnalysisSizes?.forEach {
    Log.i("LOG", "Image capturing YUV_420_888 available output size: $it")
}

val previewSizes = configs?.getOutputSizes(SurfaceTexture::class.java)
previewSizes?.forEach {
    Log.i("LOG", "Preview available output size: $it")
}
user_56074570

You can always use camera2 api StreamConfigurationMap.getOutputSizes() to get supported resolution even in CameraX. As CameraX is build on top of camera2 it shouldn't matter.

if you want to know what resolution are supported by camerax, there isn't any API. But you can always set resolution of your choice and cameraX will take care of scaling it to nearest supported resolution.

user_118617340

Because RecommendedStreamConfigurationMap is not compatable for older platform, so I find below code from camerax

val camera = cameraProvider.bindToLifecycle(...)
val characteristics = CameraCharacteristicsCompat.toCameraCharacteristicsCompat(Camera2CameraInfo.extractCameraCharacteristics(camera.cameraInfo))
val previewSizes = CamcorderProfileResolutionQuirk(characteristics).supportedResolutions

it works for me, copied from camerax CamcorderProfileResolutionQuirk.java

user_194564970

I figured out that you can bind it to the lifecycle with NO use-cases (only 2 arguments) and then query all the camera qualities available. Once that is done, feel free to unbind and then rebind with the use cases and the proper camera qualities (it looks like only binding to lifecycle does not take that much of a toll since the camera isn't actually started).

Here is what I did:

//Add all available camera qualities here for later use
val listOfQualitiesToEnumerate = arrayListOf<String>()

val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
cameraProviderFuture.addListener({
    val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
    val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
    try {
        // Unbind use cases before rebinding
        cameraProvider.unbindAll()
        //Bind cameraProvider with no use cases just to grab camera qualities available
        camera = cameraProvider.bindToLifecycle(this, cameraSelector)
        val supportedQualities = QualitySelector.getSupportedQualities(camera.cameraInfo)
        for (quality in supportedQualities) {
        when (quality) {
            Quality.UHD -> {
                //Add "Ultra High Definition (UHD) - 2160p" to the list
                listOfQualitiesToEnumerate.add("Ultra High Definition (UHD) - 2160p")
            }
            Quality.FHD -> {
                //Add "Full High Definition (FHD) - 1080p" to the list
                listOfQualitiesToEnumerate.add("Full High Definition (FHD) - 1080p")
            }
            Quality.HD -> {
                //Add "High Definition (HD) - 720p" to the list
                listOfQualitiesToEnumerate.add("High Definition (HD) - 720p")
            }
            Quality.SD -> {
                //Add "Standard Definition (SD) - 480p" to the list
                listOfQualitiesToEnumerate.add("Standard Definition (SD) - 480p")
            }
        }
    } catch(exception: Exception) {
        Log.e(TAG, "Camera binding failed", exception)
    }
}, ContextCompat.getMainExecutor(this))

Once you get all the information you need (also using Camera2 to get specific resolutions) you can unbind and then rebind with the proper information applied to your use cases.

user_91916170
Related