101 lines
3.2 KiB
Kotlin
101 lines
3.2 KiB
Kotlin
package com.mrousavy.camera.utils
|
|
|
|
import android.graphics.Bitmap
|
|
import android.graphics.BitmapFactory
|
|
import android.graphics.ImageFormat
|
|
import android.graphics.Matrix
|
|
import android.util.Log
|
|
import androidx.camera.core.ImageProxy
|
|
import com.mrousavy.camera.CameraView
|
|
import com.mrousavy.camera.InvalidFormatError
|
|
import java.io.ByteArrayOutputStream
|
|
import java.io.File
|
|
import java.io.FileOutputStream
|
|
import java.nio.ByteBuffer
|
|
import kotlin.system.measureTimeMillis
|
|
|
|
|
|
// TODO: Fix this flip() function (this outputs a black image)
|
|
fun flip(imageBytes: ByteArray, imageWidth: Int): ByteArray {
|
|
// separate out the sub arrays
|
|
var holder = ByteArray(imageBytes.size)
|
|
var subArray = ByteArray(imageWidth)
|
|
var subCount = 0
|
|
for (i in imageBytes.indices) {
|
|
subArray[subCount] = imageBytes[i]
|
|
subCount++
|
|
if (i % imageWidth == 0) {
|
|
subArray.reverse()
|
|
if (i == imageWidth) {
|
|
holder = subArray
|
|
} else {
|
|
holder += subArray
|
|
}
|
|
subCount = 0
|
|
subArray = ByteArray(imageWidth)
|
|
}
|
|
}
|
|
subArray = ByteArray(imageWidth)
|
|
System.arraycopy(imageBytes, imageBytes.size - imageWidth, subArray, 0, subArray.size)
|
|
return holder + subArray
|
|
}
|
|
|
|
// TODO: This function is slow. Figure out a faster way to flip images, preferably via directly manipulating the byte[] Exif flags
|
|
fun flipImage(imageBytes: ByteArray): ByteArray {
|
|
val bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
|
|
val matrix = Matrix()
|
|
matrix.preScale(-1f, 1f)
|
|
val newBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
|
|
val stream = ByteArrayOutputStream()
|
|
newBitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream)
|
|
return stream.toByteArray()
|
|
}
|
|
|
|
fun ImageProxy.save(file: File, flipHorizontally: Boolean) {
|
|
when (format) {
|
|
// TODO: ImageFormat.RAW_SENSOR
|
|
// TODO: ImageFormat.DEPTH_JPEG
|
|
ImageFormat.JPEG -> {
|
|
val buffer = planes[0].buffer
|
|
var bytes = ByteArray(buffer.remaining())
|
|
|
|
// copy image from buffer to byte array
|
|
buffer.get(bytes)
|
|
|
|
if (flipHorizontally) {
|
|
val milliseconds = measureTimeMillis {
|
|
bytes = flipImage(bytes)
|
|
}
|
|
Log.i(CameraView.TAG_PERF, "Flipping Image took $milliseconds ms.")
|
|
}
|
|
|
|
val output = FileOutputStream(file)
|
|
output.write(bytes)
|
|
output.close()
|
|
}
|
|
ImageFormat.YUV_420_888 -> {
|
|
// "prebuffer" simply contains the meta information about the following planes.
|
|
val prebuffer = ByteBuffer.allocate(16)
|
|
prebuffer.putInt(width)
|
|
.putInt(height)
|
|
.putInt(planes[1].pixelStride)
|
|
.putInt(planes[1].rowStride)
|
|
|
|
val output = FileOutputStream(file)
|
|
output.write(prebuffer.array()) // write meta information to file
|
|
// Now write the actual planes.
|
|
var buffer: ByteBuffer
|
|
var bytes: ByteArray
|
|
|
|
for (i in 0..2) {
|
|
buffer = planes[i].buffer
|
|
bytes = ByteArray(buffer.remaining()) // makes byte array large enough to hold image
|
|
buffer.get(bytes) // copies image from buffer to byte array
|
|
output.write(bytes) // write the byte array to file
|
|
}
|
|
output.close()
|
|
}
|
|
else -> throw InvalidFormatError(format)
|
|
}
|
|
}
|