467 lines
No EOL
19 KiB
Kotlin
467 lines
No EOL
19 KiB
Kotlin
package com.srtk.airlink
|
||
|
||
import android.annotation.SuppressLint
|
||
import android.content.Context
|
||
import android.hardware.camera2.*
|
||
import android.media.MediaCodec
|
||
import android.media.MediaCodecInfo
|
||
import android.media.MediaCodecList
|
||
import android.media.MediaFormat
|
||
import android.os.Build
|
||
import android.os.Handler
|
||
import android.os.HandlerThread
|
||
import android.util.Log
|
||
import android.util.Range
|
||
import android.util.Size
|
||
import android.view.Surface
|
||
import androidx.annotation.RequiresApi
|
||
import kotlinx.coroutines.Dispatchers
|
||
import kotlinx.coroutines.withContext
|
||
import java.net.DatagramPacket
|
||
import java.net.DatagramSocket
|
||
import java.net.InetAddress
|
||
import java.util.concurrent.Semaphore
|
||
import java.util.concurrent.TimeUnit
|
||
import kotlin.math.abs
|
||
import kotlin.math.min
|
||
|
||
data class VideoConfig(val width: Int, val height: Int, val fps: Int) {
|
||
val aspectRatio: String
|
||
get() {
|
||
val ratio = width.toDouble() / height.toDouble()
|
||
return when {
|
||
abs(ratio - 1.77) < 0.05 -> "16:9"
|
||
abs(ratio - 1.33) < 0.05 -> "4:3"
|
||
abs(ratio - 2.0) < 0.1 -> "18:9"
|
||
abs(ratio - 2.16) < 0.1 -> "19.5:9"
|
||
abs(ratio - 1.0) < 0.05 -> "1:1"
|
||
else -> String.format("%.1f:1", ratio)
|
||
}
|
||
}
|
||
override fun toString() = "${height}p"
|
||
fun toDetailedString() = "${width}×${height} @ ${fps}fps"
|
||
}
|
||
|
||
data class CameraCapabilities(
|
||
val supportedConfigs: List<VideoConfig>,
|
||
val maxZoom: Float,
|
||
val hasFlash: Boolean,
|
||
val hasFrontCamera: Boolean,
|
||
val supportedWhiteBalance: List<WhiteBalance>,
|
||
val focusRange: Range<Float>?,
|
||
val exposureRange: Range<Int>?
|
||
)
|
||
|
||
enum class WhiteBalance(val value: Int, val label: String) {
|
||
AUTO(CameraMetadata.CONTROL_AWB_MODE_AUTO, "Auto"),
|
||
WARM(CameraMetadata.CONTROL_AWB_MODE_INCANDESCENT, "Warm"),
|
||
COOL(CameraMetadata.CONTROL_AWB_MODE_FLUORESCENT, "Cool")
|
||
}
|
||
|
||
class CameraStreamer(private val context: Context) {
|
||
private val TAG = "CameraStreamer"
|
||
private val manager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
|
||
private val cameraThread = HandlerThread("CamThread").apply { start() }
|
||
private val camHandler = Handler(cameraThread.looper)
|
||
|
||
private var cameraDevice: CameraDevice? = null
|
||
private var captureSession: CameraCaptureSession? = null
|
||
private var requestBuilder: CaptureRequest.Builder? = null
|
||
private var mediaCodec: MediaCodec? = null
|
||
private var socket: DatagramSocket? = null
|
||
|
||
private var currentIp: InetAddress? = null
|
||
private var currentPort: Int = 0
|
||
|
||
@Volatile private var isStreaming = false
|
||
private val restartLock = Semaphore(1)
|
||
private var currentConfig = VideoConfig(1280, 720, 30)
|
||
|
||
private var zoomRatio = 1f
|
||
private var flashMode = false
|
||
private var wbMode = CameraMetadata.CONTROL_AWB_MODE_AUTO
|
||
private var focusMode = CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_VIDEO
|
||
private var focusDistance = 0f
|
||
private var exposureCompensation = 0
|
||
|
||
private var onErrorCallback: ((String) -> Unit)? = null
|
||
private var connectionManager: ConnectionManager? = null
|
||
|
||
fun setConnectionManager(manager: ConnectionManager) { connectionManager = manager }
|
||
fun setErrorCallback(callback: (String) -> Unit) { onErrorCallback = callback }
|
||
|
||
private fun sendControl(msg: String) {
|
||
val ip = currentIp ?: return
|
||
val port = currentPort
|
||
if (port == 0) return
|
||
Thread {
|
||
try {
|
||
val s = socket ?: DatagramSocket()
|
||
val data = msg.toByteArray()
|
||
for(i in 1..3) {
|
||
s.send(DatagramPacket(data, data.size, ip, port))
|
||
Thread.sleep(5)
|
||
}
|
||
if (socket == null) s.close()
|
||
} catch (e: Exception) {}
|
||
}.start()
|
||
}
|
||
|
||
/**
|
||
* Actually test if encoder can handle this resolution by trying to configure it
|
||
*/
|
||
private fun canEncodeResolution(width: Int, height: Int, fps: Int): Boolean {
|
||
var codec: MediaCodec? = null
|
||
return try {
|
||
val bitrate = when {
|
||
width * height >= 1920 * 1080 -> 4_000_000
|
||
width * height >= 1280 * 720 -> 2_500_000
|
||
else -> 1_500_000
|
||
}
|
||
|
||
val format = MediaFormat.createVideoFormat(
|
||
MediaFormat.MIMETYPE_VIDEO_AVC,
|
||
width,
|
||
height
|
||
).apply {
|
||
setInteger(
|
||
MediaFormat.KEY_COLOR_FORMAT,
|
||
MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface
|
||
)
|
||
setInteger(MediaFormat.KEY_BIT_RATE, bitrate)
|
||
setInteger(MediaFormat.KEY_FRAME_RATE, fps)
|
||
setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1)
|
||
}
|
||
|
||
codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC)
|
||
codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
|
||
codec.reset() // Don't actually start, just test config
|
||
true
|
||
} catch (e: Exception) {
|
||
Log.d(TAG, "✗ ${width}x${height} @ ${fps}fps - Encoder rejected: ${e.message}")
|
||
false
|
||
} finally {
|
||
try {
|
||
codec?.release()
|
||
} catch (e: Exception) {}
|
||
}
|
||
}
|
||
|
||
suspend fun getCameraCapabilities(useFront: Boolean): CameraCapabilities = withContext(Dispatchers.Default) {
|
||
val camId = getCameraId(useFront)
|
||
val chars = manager.getCameraCharacteristics(camId)
|
||
val map = chars.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)!!
|
||
|
||
// Get all sizes supported by camera for MediaCodec
|
||
val cameraSizes = map.getOutputSizes(MediaCodec::class.java)
|
||
.filter { it.width <= 1920 && it.height <= 1080 }
|
||
.toSet()
|
||
|
||
Log.d(TAG, "Testing ${cameraSizes.size} camera resolutions against encoder...")
|
||
|
||
val validConfigs = mutableListOf<VideoConfig>()
|
||
|
||
// Define common resolutions to prioritize
|
||
// val commonResolutions = listOf(
|
||
// Size(1920, 1080), // 1080p 16:9
|
||
// Size(1280, 720), // 720p 16:9
|
||
// Size(960, 720), // 720p 4:3
|
||
// Size(640, 480), // 480p 4:3
|
||
// Size(854, 480), // 480p 16:9
|
||
// Size(1440, 1080), // 1080p 4:3
|
||
// Size(800, 600), // 600p 4:3
|
||
// Size(320, 240), // 240p 4:3
|
||
// )
|
||
|
||
// Test common resolutions first
|
||
// for (size in commonResolutions) {
|
||
// if (!cameraSizes.contains(size)) continue
|
||
//
|
||
// val minFrameDuration = map.getOutputMinFrameDuration(MediaCodec::class.java, size)
|
||
// val maxFps = if (minFrameDuration > 0) {
|
||
// (1_000_000_000.0 / minFrameDuration).toInt()
|
||
// } else 30
|
||
//
|
||
// val targetFps = min(30, maxFps)
|
||
//
|
||
// if (targetFps >= 15 && canEncodeResolution(size.width, size.height, targetFps)) {
|
||
// validConfigs.add(VideoConfig(size.width, size.height, targetFps))
|
||
// Log.d(TAG, "✓ ${size.width}x${size.height} @ ${targetFps}fps")
|
||
// }
|
||
// }
|
||
|
||
// Test remaining camera sizes that aren't in common list
|
||
for (size in cameraSizes) {
|
||
// if (commonResolutions.contains(size)) continue
|
||
if (validConfigs.any { it.width == size.width && it.height == size.height }) continue
|
||
|
||
val ratio = size.width.toDouble() / size.height
|
||
|
||
// Only accept common aspect ratios
|
||
val isCommonAspectRatio = listOf(1.77, 1.33, 2.0, 2.16, 1.0)
|
||
.any { abs(ratio - it) < 0.1 }
|
||
if (!isCommonAspectRatio) continue
|
||
|
||
val minFrameDuration = map.getOutputMinFrameDuration(MediaCodec::class.java, size)
|
||
val maxFps = if (minFrameDuration > 0) {
|
||
(1_000_000_000.0 / minFrameDuration).toInt()
|
||
} else 30
|
||
|
||
val targetFps = min(30, maxFps)
|
||
|
||
if (targetFps >= 15 && canEncodeResolution(size.width, size.height, targetFps)) {
|
||
validConfigs.add(VideoConfig(size.width, size.height, targetFps))
|
||
Log.d(TAG, "✓ ${size.width}x${size.height} @ ${targetFps}fps")
|
||
}
|
||
}
|
||
|
||
// Fallback if nothing found (this should never happen on real devices)
|
||
if (validConfigs.isEmpty()) {
|
||
Log.w(TAG, "No compatible resolutions found! Adding fallback...")
|
||
// Try absolute minimum safe resolution
|
||
if (canEncodeResolution(640, 480, 30)) {
|
||
validConfigs.add(VideoConfig(640, 480, 30))
|
||
} else if (canEncodeResolution(320, 240, 30)) {
|
||
validConfigs.add(VideoConfig(320, 240, 30))
|
||
}
|
||
}
|
||
|
||
val sortedConfigs = validConfigs
|
||
.sortedByDescending { it.width * it.height }
|
||
.distinctBy { "${it.width}x${it.height}" }
|
||
|
||
Log.d(TAG, "✓ Final supported resolutions: ${sortedConfigs.size} configs")
|
||
sortedConfigs.forEach {
|
||
Log.d(TAG, " - ${it.toDetailedString()}")
|
||
}
|
||
|
||
CameraCapabilities(
|
||
sortedConfigs,
|
||
chars.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM) ?: 1f,
|
||
chars.get(CameraCharacteristics.FLASH_INFO_AVAILABLE) == true,
|
||
manager.cameraIdList.any {
|
||
manager.getCameraCharacteristics(it).get(CameraCharacteristics.LENS_FACING) ==
|
||
CameraCharacteristics.LENS_FACING_FRONT
|
||
},
|
||
listOf(WhiteBalance.AUTO, WhiteBalance.WARM, WhiteBalance.COOL),
|
||
chars.get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE)?.let {
|
||
if (it > 0) Range(0f, it) else null
|
||
},
|
||
chars.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE)
|
||
)
|
||
}
|
||
|
||
@RequiresApi(Build.VERSION_CODES.Q)
|
||
fun start(ip: InetAddress, port: Int, config: VideoConfig, useFront: Boolean) {
|
||
currentConfig = config
|
||
currentIp = ip
|
||
currentPort = port
|
||
val camId = getCameraId(useFront)
|
||
|
||
camHandler.post {
|
||
try {
|
||
if (restartLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
|
||
try {
|
||
stopInternal(sendBye = false)
|
||
Thread.sleep(100)
|
||
startInternal(ip, port, camId)
|
||
} finally {
|
||
restartLock.release()
|
||
}
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "Start error", e)
|
||
onErrorCallback?.invoke("Start failed: ${e.message}")
|
||
}
|
||
}
|
||
}
|
||
|
||
@RequiresApi(Build.VERSION_CODES.R)
|
||
fun setZoom(z: Float) { zoomRatio = z; updateSession() }
|
||
@RequiresApi(Build.VERSION_CODES.R)
|
||
fun setTorch(on: Boolean) { flashMode = on; updateSession() }
|
||
@RequiresApi(Build.VERSION_CODES.R)
|
||
fun setWhiteBalance(wb: WhiteBalance) { wbMode = wb.value; updateSession() }
|
||
@RequiresApi(Build.VERSION_CODES.R)
|
||
fun setFocusMode(auto: Boolean) {
|
||
focusMode = if (auto) CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_VIDEO
|
||
else CameraMetadata.CONTROL_AF_MODE_OFF
|
||
updateSession()
|
||
}
|
||
@RequiresApi(Build.VERSION_CODES.R)
|
||
fun setFocusDistance(distance: Float) {
|
||
focusDistance = distance
|
||
focusMode = CameraMetadata.CONTROL_AF_MODE_OFF
|
||
updateSession()
|
||
}
|
||
@RequiresApi(Build.VERSION_CODES.R)
|
||
fun setExposure(value: Int) { exposureCompensation = value; updateSession() }
|
||
|
||
fun stopCapture() {
|
||
sendControl("PAUSE")
|
||
camHandler.post {
|
||
try {
|
||
captureSession?.stopRepeating()
|
||
} catch(e: Exception) {}
|
||
}
|
||
}
|
||
|
||
@RequiresApi(Build.VERSION_CODES.Q)
|
||
@SuppressLint("MissingPermission")
|
||
private fun startInternal(ip: InetAddress, port: Int, camId: String) {
|
||
try {
|
||
socket = DatagramSocket()
|
||
isStreaming = true
|
||
|
||
val width = currentConfig.width
|
||
val height = currentConfig.height
|
||
val fps = currentConfig.fps
|
||
|
||
val bitrate = when {
|
||
width * height >= 1920 * 1080 -> 4_000_000
|
||
width * height >= 1280 * 720 -> 2_500_000
|
||
else -> 1_500_000
|
||
}
|
||
|
||
val format = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height).apply {
|
||
setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface)
|
||
setInteger(MediaFormat.KEY_BIT_RATE, bitrate)
|
||
setInteger(MediaFormat.KEY_FRAME_RATE, fps)
|
||
setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1)
|
||
setInteger(MediaFormat.KEY_PROFILE, MediaCodecInfo.CodecProfileLevel.AVCProfileBaseline)
|
||
}
|
||
|
||
mediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC)
|
||
try {
|
||
mediaCodec?.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
|
||
} catch (e: Exception) {
|
||
format.removeKey(MediaFormat.KEY_PROFILE)
|
||
mediaCodec?.reset()
|
||
mediaCodec?.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
|
||
}
|
||
|
||
val surface = mediaCodec?.createInputSurface() ?: throw Exception("Failed to create surface")
|
||
mediaCodec?.start()
|
||
|
||
Thread {
|
||
Thread.currentThread().priority = Thread.MAX_PRIORITY
|
||
streamLoop(ip, port)
|
||
}.start()
|
||
|
||
manager.openCamera(camId, object : CameraDevice.StateCallback() {
|
||
override fun onOpened(camera: CameraDevice) {
|
||
cameraDevice = camera
|
||
createSession(camera, surface)
|
||
}
|
||
override fun onDisconnected(camera: CameraDevice) { stopInternal() }
|
||
override fun onError(camera: CameraDevice, error: Int) {
|
||
onErrorCallback?.invoke("Camera Error: $error")
|
||
stopInternal()
|
||
}
|
||
}, camHandler)
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "Start Failed", e)
|
||
onErrorCallback?.invoke("Camera failed: ${e.message}")
|
||
stopInternal()
|
||
}
|
||
}
|
||
|
||
private fun createSession(camera: CameraDevice, surface: Surface) {
|
||
try {
|
||
camera.createCaptureSession(listOf(surface), object : CameraCaptureSession.StateCallback() {
|
||
@RequiresApi(Build.VERSION_CODES.R)
|
||
override fun onConfigured(session: CameraCaptureSession) {
|
||
if (!isStreaming) return
|
||
captureSession = session
|
||
try {
|
||
requestBuilder = camera.createCaptureRequest(CameraDevice.TEMPLATE_RECORD).apply {
|
||
addTarget(surface)
|
||
set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO)
|
||
set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, Range(currentConfig.fps, currentConfig.fps))
|
||
set(CaptureRequest.CONTROL_VIDEO_STABILIZATION_MODE, CameraMetadata.CONTROL_VIDEO_STABILIZATION_MODE_OFF)
|
||
}
|
||
updateSession()
|
||
} catch (e: Exception) {}
|
||
}
|
||
override fun onConfigureFailed(session: CameraCaptureSession) {}
|
||
}, camHandler)
|
||
} catch (e: Exception) {}
|
||
}
|
||
|
||
@RequiresApi(Build.VERSION_CODES.R)
|
||
private fun updateSession() {
|
||
val builder = requestBuilder ?: return
|
||
val session = captureSession ?: return
|
||
try {
|
||
if (zoomRatio > 1f) builder.set(CaptureRequest.CONTROL_ZOOM_RATIO, zoomRatio)
|
||
builder.set(CaptureRequest.FLASH_MODE, if (flashMode) CameraMetadata.FLASH_MODE_TORCH else CameraMetadata.FLASH_MODE_OFF)
|
||
builder.set(CaptureRequest.CONTROL_AWB_MODE, wbMode)
|
||
builder.set(CaptureRequest.CONTROL_AF_MODE, focusMode)
|
||
if (focusMode == CameraMetadata.CONTROL_AF_MODE_OFF) builder.set(CaptureRequest.LENS_FOCUS_DISTANCE, focusDistance)
|
||
builder.set(CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, exposureCompensation)
|
||
session.setRepeatingRequest(builder.build(), null, camHandler)
|
||
} catch (e: Exception) {}
|
||
}
|
||
|
||
private fun streamLoop(ip: InetAddress, port: Int) {
|
||
val bufferInfo = MediaCodec.BufferInfo()
|
||
val maxChunkSize = 1400
|
||
var lastUpdate = System.currentTimeMillis()
|
||
|
||
try {
|
||
while (isStreaming) {
|
||
val codec = mediaCodec ?: break
|
||
val index = try { codec.dequeueOutputBuffer(bufferInfo, 10000) } catch (e: Exception) { -1 }
|
||
|
||
if (index >= 0) {
|
||
val buffer = codec.getOutputBuffer(index)
|
||
if (buffer != null) {
|
||
buffer.position(bufferInfo.offset)
|
||
buffer.limit(bufferInfo.offset + bufferInfo.size)
|
||
val data = ByteArray(bufferInfo.size)
|
||
buffer.get(data)
|
||
|
||
var offset = 0
|
||
while (offset < data.size && isStreaming) {
|
||
val chunkSize = min(maxChunkSize, data.size - offset)
|
||
try { socket?.send(DatagramPacket(data, offset, chunkSize, ip, port)) } catch (e: Exception) {}
|
||
offset += chunkSize
|
||
}
|
||
|
||
val now = System.currentTimeMillis()
|
||
if (now - lastUpdate > 500) {
|
||
connectionManager?.updateActivity()
|
||
lastUpdate = now
|
||
}
|
||
}
|
||
codec.releaseOutputBuffer(index, false)
|
||
}
|
||
}
|
||
} catch (e: Exception) {}
|
||
}
|
||
|
||
fun stop() { camHandler.post { stopInternal(sendBye = true) } }
|
||
fun cleanup() { stop(); cameraThread.quitSafely() }
|
||
|
||
private fun stopInternal(sendBye: Boolean = true) {
|
||
if (sendBye && isStreaming) sendControl("BYE")
|
||
|
||
isStreaming = false
|
||
try { captureSession?.stopRepeating(); captureSession?.close() } catch (e: Exception) {}
|
||
captureSession = null
|
||
try { cameraDevice?.close() } catch (e: Exception) {}
|
||
cameraDevice = null
|
||
try { mediaCodec?.stop(); mediaCodec?.release() } catch (e: Exception) {}
|
||
mediaCodec = null
|
||
try { socket?.close() } catch (e: Exception) {}
|
||
socket = null
|
||
}
|
||
|
||
private fun getCameraId(front: Boolean): String {
|
||
val target = if (front) CameraCharacteristics.LENS_FACING_FRONT else CameraCharacteristics.LENS_FACING_BACK
|
||
return manager.cameraIdList.firstOrNull {
|
||
manager.getCameraCharacteristics(it).get(CameraCharacteristics.LENS_FACING) == target
|
||
} ?: manager.cameraIdList[0]
|
||
}
|
||
} |