Develop Reference

Can I get the Exif data from an Android camera preview without saving to file?

I want to use the Android camera to report lighting and colour information from a sampled patch on the image preview. The camerax preview generates ImageProxy images, and I can get the average LUV data for a patch. I would like to turn this data into absolute light levels using the exposure information and the camera white balance. The exposure data is in the Exif information, and maybe the white balance information too.
I would like this information, however we get it. Exif seems a very likely route, but any other non-Exif solutions are welcome.
At first sight, it looks as if Exif is always read from a file. However, ExifInterface
can be created from an InputStream, and one of the streamType options is STREAM_TYPE_EXIF_DATA_ONLY. This looks promising - it seems something makes and streams just the EXIF data, and a camera preview could easily do just that. Or maybe we can get Exif from the ImageProxy somehow.
I found many old threads on how to get at Exif data to find out the camera orientation. About 4 years ago these people were saying Exif is only read from a file. Is this still so?
Reply to comment:
With due misgiving, I attach my dodgy code...
private class LuvAnalyzer(private val listener:LuvListener) : ImageAnalysis.Analyzer {
private fun ByteBuffer.toByteArray(): ByteArray {
rewind() // Rewind the buffer to zero
val data = ByteArray(remaining())
get(data) // Copy the buffer into a byte array
return data // Return the byte array
}
override fun analyze(image: ImageProxy) {
// Sum for 1/5 width square of YUV_420_888 image
val YUV = DoubleArray(3)
val w = image.width
val h = image.height
val sq = kotlin.math.min(h,w) / 5
val w0 = ((w - sq)/4)*2
val h0 = ((h - sq)/4)*2
var ySum = 0
var uSum = 0
var vSum = 0
val y = image.planes[0].buffer.toByteArray()
val stride = image.planes[0].rowStride
var offset = h0*stride + w0
for (row in 1..sq) {
var o = offset
for (pix in 1..sq) { ySum += y[o++].toInt() and 0xFF }
offset += stride
}
YUV[0] = ySum.toDouble()/(sq*sq).toDouble()
val uv = image.planes[1].buffer.toByteArray()
offset = (h0/2)*stride + w0
for (row in 1..sq/2) {
var o = offset
for (pix in 1..sq/2) {
uSum += uv[o++].toInt() and 0xFF
vSum += uv[o++].toInt() and 0xFF
}
offset += stride
}
YUV[1] = uSum.toDouble()/(sq*sq/4).toDouble()
YUV[2] = vSum.toDouble()/(sq*sq/4).toDouble()
// val exif = Exif.createFromImageProxy(image)
listener(YUV)
image.close()
}
}
private fun startCamera() {
val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
cameraProviderFuture.addListener({
// Used to bind the lifecycle of cameras to the lifecycle owner
val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
// Preview
val preview = Preview.Builder()
.build()
.also {
it.setSurfaceProvider(binding.viewFinder.surfaceProvider)
}
imageCapture = ImageCapture.Builder()
.build()
// Image analyser
val imageAnalyzer = ImageAnalysis.Builder()
.build()
.also {
it.setAnalyzer(cameraExecutor, LuvAnalyzer { LUV ->
// Log.d(TAG, "Average LUV: %.1f %.1f %.1f".format(LUV[0], LUV[1], LUV[2]))
luvText = "Average LUV: %.1f %.1f %.1f".format(LUV[0], LUV[1], LUV[2])
})
}
// Select back camera as a default
val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
try {
// Unbind use cases before rebinding
cameraProvider.unbindAll()
// Bind use cases to camera
cameraProvider.bindToLifecycle(
this, cameraSelector, preview, imageCapture, imageAnalyzer)
} catch(exc: Exception) {
Log.e(TAG, "Use case binding failed", exc)
}
}, ContextCompat.getMainExecutor(this))
}
I am doing my image averaging from an ImageProxy. I am currently trying to get the Exif data from the same ImageProxy because there not saving images to files, because this is intended to provide a stream of colour values. And there is an intriguing Exif.createFromImageProxy(image) (now commented out) which I discovered after writing the original note, but I can't get it to do anything.
I might get the Exif information if I saved an image to a .jpg file and then read it back in again. The camera is putting out a stream of preview images, and the exposure settings may be changing all the time, so I would have to save a stream of images. If I was really stuck, I might try that. But I feel there are enough Exif bits and pieces to get the information live from the camera.
Update
The Google camerax-developers suggest getting the exposure information using the camera2 Extender. I have got it working enough to see the numbers go up and down roughly as they should. This feels a lot better than the Exif route.
I am tempted to mark this as the solution, as it is the solution for me, but I shall leave it open as my original question in the title may have an answer.
val previewBuilder = Preview.Builder()
val previewExtender = Camera2Interop.Extender(previewBuilder)
// Turn AWB off
previewExtender.setCaptureRequestOption(CaptureRequest.CONTROL_AWB_MODE,
CaptureRequest.CONTROL_AWB_MODE_DAYLIGHT)
previewExtender.setSessionCaptureCallback(
object : CameraCaptureSession.CaptureCallback() {
override fun onCaptureCompleted(
session: CameraCaptureSession,
request: CaptureRequest,
result: TotalCaptureResult
) {
result.get(CaptureResult.SENSOR_EXPOSURE_TIME)
result.get(CaptureResult.SENSOR_SENSITIVITY)
result.get(CaptureResult.COLOR_CORRECTION_GAINS)
result.get(CaptureResult.COLOR_CORRECTION_TRANSFORM)
}
}
)

Camera 2 preview freezes when I uses YUV_420_888 Image Reader as a target surface

I'm working on an application that has requirements to detect objects and faces in a real-time camera feed. for this, I'm using MLkit. I have successfully implemented it object detection part with the back-facing camera with no issue. ML kit recommends using YUV_420_888 with the smallest size possible to have better results. I am using Camera 2 API and here's my code for setting up ImageReader for processing.
class SelfieCaptureFragment : Fragment(R.layout.fragment_selfie_capture) {
protected lateinit var characteristics: CameraCharacteristics
protected lateinit var camera: CameraDevice
protected lateinit var session: CameraCaptureSession
protected lateinit var requestPermissionLauncher: ActivityResultLauncher<String>
protected lateinit var captureImageReader: ImageReader
protected lateinit var analyzeImageReader: ImageReader
/** [HandlerThread] and [Handler] where all camera operations run */
private val cameraThread = HandlerThread("CameraThread").apply { start() }
private val cameraHandler = Handler(cameraThread.looper)
/** [HandlerThread] and [Handler] where all camera still image capturing operations run */
private val captureImageReaderThread = HandlerThread("captureImageReaderThread").apply { start() }
private val captureImageReaderHandler = Handler(captureImageReaderThread.looper)
private val analyzeImageReaderThread = HandlerThread("imageReaderThread").apply { start() }
private val analyzeImageReaderHandler = Handler(analyzeImageReaderThread.looper)
companion object {
/** Maximum number of images that will be held in the reader's buffer */
const val IMAGE_BUFFER_SIZE: Int = 3
}
private fun configureCamera(selectedCameraId: String) {
lifecycleScope.launch(Dispatchers.Main) {
camera = openCamera(cameraManager, selectedCameraId, cameraHandler)
val previewFraction = DisplayUtils
.asFraction(previewSize!!.width.toLong(), previewSize!!.height.toLong())
// Initialize an image reader which will be used to capture still photos
captureSize = characteristics.get(
CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)!!
.getOutputSizes(ImageFormat.JPEG)
.filter { DisplayUtils.asFraction(it.width.toLong(),it.height.toLong()) == previewFraction }
.sortedBy { it.height * it.width}
.reversed()
.first()
analyzeImageSize = characteristics
.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)!!
.getOutputSizes(ImageFormat.YUV_420_888)
.filter { DisplayUtils.asFraction(it.width.toLong(), it.height.toLong()) == previewFraction }
.sortedBy { it.height * it.width}
.first()
if (captureSize != null) {
captureImageReader = ImageReader.newInstance(
captureSize!!.width, captureSize!!.height, ImageFormat.JPEG, IMAGE_BUFFER_SIZE
)
analyzeImageReader = ImageReader.newInstance(
analyzeImageSize!!.width,
analyzeImageSize!!.height,
ImageFormat.YUV_420_888,
IMAGE_BUFFER_SIZE)
Log.d(TAG, "Selected capture size: $captureSize")
Log.d(TAG, "Selected image analyze size: $analyzeImageSize")
val targets = listOf(
binding.cameraSurfaceView.holder.surface,
captureImageReader.surface,
analyzeImageReader.surface
)
session = createCaptureSession(camera, targets, cameraHandler)
val captureBuilder = camera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW)
captureBuilder.set(
CaptureRequest.CONTROL_AF_MODE,
CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE
)
captureBuilder.addTarget(binding.cameraSurfaceView.holder.surface)
captureBuilder.addTarget(analyzeImageReader.surface)
session.setRepeatingRequest(captureBuilder.build(), null, cameraHandler)
}
}
}
}
This code is identical to what I'm using in the back-facing camera to set up the image reader for the object detection part. I have not yet Implemented any logic related to Image processing to detect faces in the camera steam. Error is in the line where I set up the target. captureBuilder.addTarget(analyzeImageReader.surface) If I comment that line camera preview works fine. I get the following error and warning in logcat over and over when the camera preview freezes.
W/libc: Unable to set property "debug.sf.dequeuebuffer" to "1": connection failed; errno=13 (Permission denied)
E/BufferQueueProducer: [ImageReader-256x144f23m3-23007-3](id:59df00000003,api:4,p:4806,c:23007) waitForFreeSlotThenRelock: timeout
I can't understand why it's not working in the front-facing camera. analyze image size return from the analyzeImageReader is 256x144 which is not a big resolution either plus it's the smallest out of all the supported sizes for the format of YUV_420_888. Any Help will be highly appreciated. I thought I have figured it out all when I implemented objected detection part. this was a very unexpected issue.
Edit: I'm still stuck with this issue so I have set up a small project to showcase the whole picture. Please check the repo and help me find a solution.

Hope this helps: I had a similar issue with one phone model (Samsung A50). I managed to solve it by changing this:
captureImageReader.setOnImageAvailableListener(null, null)
To:
captureImageReader.setOnImageAvailableListener({ reader ->
reader.acquireLatestImage().close()
},imageReaderHandler)

How to decrease frame rate of Android CameraX ImageAnalysis?

How to decrease the frame rate to 1 fps in image analysis so that I don't detect barcode multiple times. In my use-case, scanning the same barcode multiple times with a 1-second interval should increment a counter. So I want it to work correctly. (Similar to product scanner at shop tills)
cameraX version : 1.0.0-beta02
Similar questions :
How to increase frame rate with Android CameraX ImageAnalysis?
In this, the answer is based on the preview config & analysis config Builders, which was in cameraX alpha versions. But it is not found in beta versions.
How to pause barcode scanning in android ML-kit when using ByteBuffer from SurfaceView
In this, the image analysis is throttled, but I want the call to the image analyzer to be at a lower frame rate. i.e Call from image analysis usecase to image analyzer should be once in a second.
Current implementation :
https://proandroiddev.com/update-android-camerax-4a44c3e4cdcc
Following this doc, to throttle image analysis.
override fun analyze(image: ImageProxy) {
val currentTimestamp = System.currentTimeMillis()
if (currentTimestamp - lastAnalyzedTimestamp >= TimeUnit.SECONDS.toMillis(1)) {
// Image analysis code
}
image.close()
}
A better solution would be helpful.

Tried bmdelacruz's solution. Had issues with closing the image.
Was getting an error similar to this.
Couldn't get it working.
Using delay worked well for me.
Code
CoroutineScope(Dispatchers.IO).launch {
delay(1000 - (System.currentTimeMillis() - currentTimestamp))
imageProxy.close()
}
Complete BarcodeAnalyser code
class BarcodeAnalyser(
private val onBarcodesDetected: (barcodes: List<Barcode>) -> Unit,
) : ImageAnalysis.Analyzer {
private val barcodeScannerOptions = BarcodeScannerOptions.Builder()
.setBarcodeFormats(Barcode.FORMAT_ALL_FORMATS)
.build()
private val barcodeScanner = BarcodeScanning.getClient(barcodeScannerOptions)
var currentTimestamp: Long = 0
override fun analyze(
imageProxy: ImageProxy,
) {
currentTimestamp = System.currentTimeMillis()
imageProxy.image?.let { imageToAnalyze ->
val imageToProcess =
InputImage.fromMediaImage(imageToAnalyze, imageProxy.imageInfo.rotationDegrees)
barcodeScanner.process(imageToProcess)
.addOnSuccessListener { barcodes ->
// Success handling
}
.addOnFailureListener { exception ->
// Failure handling
}
.addOnCompleteListener {
CoroutineScope(Dispatchers.IO).launch {
delay(1000 - (System.currentTimeMillis() - currentTimestamp))
imageProxy.close()
}
}
}
}
}

You can take advantage of the fact that the next analysis will not begin until you close the provided ImageProxy.
In my case, I just put the thread to sleep since my analyzer's executor is a single thread executor.
class MyAnalyzer : ImageAnalysis.Analyzer {
override fun analyze(image: ImageProxy) {
val elapsedAnalysisTime = measureTimeMillis {
// do your stuff here
}
image.use {
if (elapsedAnalysisTime < 1000) {
Thread.sleep(1000 - elapsedAnalysisTime)
}
}
}
}

private var firstDetected = true
for (barcode in barcodes) {
if (barcodes.size > 0 && firstDetected) {
LoggingUtility.writeLog("Analyzer",
"MLKitBarcode Result",
"Barcode is ${barcode.rawValue!!}")
firstDetected = false
}
}
This might help

App crashed with "Fail to find supported surface info - CameraId:null" CameraX

I am using new CameraX API (alpha 5).
On devices like: LGE, Samsung, Motorola, OPPO crash with message:
Fail to find supported surface info - CameraId:null
occur.
This crashes are rare, but unacceptable.
Error occur in method:
private fun initCamera(cameraMode: CameraMode) {
val lensFacing = if (cameraMode == CameraMode.DEFAULT) CameraX.LensFacing.BACK else CameraX.LensFacing.FRONT
val metrics = DisplayMetrics().also { textureView?.display?.getRealMetrics(it) }
val resolution = Size(metrics.widthPixels, metrics.heightPixels)
val previewConfig = PreviewConfig.Builder()
.setTargetResolution(resolution)
.setLensFacing(lensFacing)
.build()
preview?.let { CameraX.unbind(preview) }
preview = Preview(previewConfig)
preview?.setOnPreviewOutputUpdateListener { previewOutput ->
val parent = textureView?.parent as ViewGroup
parent.removeView(textureView)
parent.addView(textureView, 0)
textureView?.surfaceTexture = previewOutput.surfaceTexture
}
CameraX.bindToLifecycle(this, preview)
}
in line:
preview = Preview(previewConfig)
It is looks like that it cannot create preview for this devices because cannot get camera.
Is anyone know the possible workaround for this problem?
P.S:
I checked. This devices (device models in which crash occur) has both cameras (front, back).

Android CameraX, increase ImageAnalysis frame rate

I need to take as many frames as possible from the preview of the camera.
I'm doing this to start the camera using CameraX:
private fun startCamera() {
// Create configuration object for the viewfinder use case
val metrics = DisplayMetrics().also { view_finder.display.getRealMetrics(it) }
// define the screen size
val screenSize = Size(metrics.widthPixels, metrics.heightPixels)
val screenAspectRatio = Rational(metrics.widthPixels, metrics.heightPixels)
val previewConfig = PreviewConfig.Builder()
.setLensFacing(CameraX.LensFacing.BACK) // defaults to Back camera
.setTargetAspectRatio(screenAspectRatio)
.setTargetResolution(screenSize)
.build()
// Build the viewfinder use case
val preview = Preview(previewConfig)
// Every time the viewfinder is updated, recompute layout
preview.setOnPreviewOutputUpdateListener {
// To update the SurfaceTexture, we have to remove it and re-add it
val parent = view_finder.parent as ViewGroup
parent.removeView(view_finder)
parent.addView(view_finder, 0)
view_finder.surfaceTexture = it.surfaceTexture
updateTransform()
}
val analyzerConfig = ImageAnalysisConfig.Builder().apply {
// Use a worker thread for image analysis to prevent glitches
val analyzerThread = HandlerThread("AnalysisThread").apply {
start()
}
setLensFacing(CameraX.LensFacing.BACK) // defaults to Back camera
setTargetAspectRatio(screenAspectRatio)
setMaxResolution(Size(600, 320))
setCallbackHandler(Handler(analyzerThread.looper))
setImageReaderMode(ImageAnalysis.ImageReaderMode.ACQUIRE_LATEST_IMAGE)
}.build()
val analyzerUseCase = ImageAnalysis(analyzerConfig).apply {
analyzer = context?.let { FrameCapturer(it) }
}
//====================== Image Analysis Config code End==========================
CameraX.bindToLifecycle(this, preview, analyzerUseCase)
}
My FrameCapturer class is:
class FrameCapturer(context: Context): ImageAnalysis.Analyzer {
private var mListener = context as FrameCapturerListener
override fun analyze(image: ImageProxy?, rotationDegrees: Int) {
val buffer = image?.planes?.get(0)?.buffer
// Extract image data from callback object
val data = buffer?.toByteArray()
// Convert the data into an array of pixel values
//val pixels = data?.map { it.toInt() and 0xFF }
mListener.updateFps()
}
private fun ByteBuffer.toByteArray(): ByteArray {
rewind() // Rewind the buffer to zero
val data = ByteArray(remaining())
get(data) // Copy the buffer into a byte array
return data // Return the byte array
}
interface FrameCapturerListener {
fun updateFps()
}
And my updateFps function is:
fun updateFps() {
fps += 1
if (!isCountDownStarted) {
var timer = object : CountDownTimer(1000, 1000) {
override fun onTick(millisUntilFinished: Long) {
}
override fun onFinish() {
Log.d("CameraFragment", fps.toString())
fps = 0
isCountDownStarted = false
}
}.start()
isCountDownStarted = true
}
}
I'm around 16-22 fps, even if I don't convert the image to an array of byte in the FrameCapturer class. So, it seems like the Analyzer take only 20 image per second. Is there a way to increase the fps? I need to take at least 40-60 image per second, because I need to do post-processing with machine learning for each frame, so they will probably drop to 20-30 after ML analysis.
EDIT: I discover that with the Pixel 2xl I got 60fps without any drop..with my device (Xiaomi Redmi Note 5 Pro) I got only 25 fps...Can I optimize the code in any way to increase FPS?