Uwaga: ta strona dotyczy pakietu Camera2. Jeśli Twoja aplikacja nie wymaga określonych funkcji niskiego poziomu z Camera2, zalecamy używanie CameraX. Zarówno CameraX, jak i Camera2 obsługują Androida 5.0 (poziom interfejsu API 21) i nowsze wersje.
Aplikacja aparatu może używać więcej niż jednego strumienia klatek jednocześnie. W niektórych przypadkach różne strumienie wymagają nawet innej rozdzielczości klatek lub formatu pikseli. Oto kilka typowych przypadków użycia:
- Nagrywanie filmu: jeden strumień do podglądu, a drugi jest kodowany i zapisywany w pliku.
- Skanowanie kodów kreskowych: jeden strumień do podglądu, drugi do wykrywania kodów kreskowych.
- Fotografia cyfrowa: jeden strumień do podglądu, drugi do wykrywania twarzy lub sceny.
Przetwarzanie klatek wiąże się z niebagatelnym kosztem wydajności, który jest mnożony podczas przetwarzania równoległego strumienia lub potoku.
Zasoby takie jak CPU, GPU i DSP mogą korzystać z funkcji ponownego przetwarzania platformy, ale zasoby takie jak pamięć rosną liniowo.
Wiele celów na żądanie
Kilka strumieni z kamery można połączyć w jedną CameraCaptureRequest. Poniższy fragment kodu pokazuje, jak skonfigurować sesję aparatu z jednym strumieniem do podglądu z aparatu i drugim do przetwarzania obrazu:
val session: CameraCaptureSession = ... // from CameraCaptureSession.StateCallback // You will use the preview capture template for the combined streams // because it is optimized for low latency; for high-quality images, use // TEMPLATE_STILL_CAPTURE, and for a steady frame rate use TEMPLATE_RECORD. val requestTemplate = CameraDevice.TEMPLATE_PREVIEW val combinedRequest = session.device.createCaptureRequest(requestTemplate) // Link the Surface targets with the combined request. combinedRequest.addTarget(previewSurface) combinedRequest.addTarget(imReaderSurface) // In this basic case, the SurfaceView gets updated automatically. ImageReader // has its own callback that you have to listen to in order to retrieve the // frames so there is no need to set up a callback for the capture request. session.setRepeatingRequest(combinedRequest.build(), null, null)
Jeśli prawidłowo skonfigurujesz powierzchnie docelowe, ten kod będzie generować tylko strumienie, które spełniają minimalną liczbę klatek na sekundę określoną przez StreamComfigurationMap.GetOutputMinFrameDuration(int, Size) i StreamComfigurationMap.GetOutputStallDuration(int, Size).
Rzeczywista wydajność różni się w zależności od urządzenia, ale Android gwarantuje obsługę określonych kombinacji w zależności od 3 zmiennych: typu danych wyjściowych, rozmiaru danych wyjściowych i poziomu sprzętu.
Użycie nieobsługiwanej kombinacji zmiennych może działać przy niskiej liczbie klatek. Jeśli nie, zostanie wywołane jedno z wywołań zwrotnych błędu. Dokumentacja createCaptureSession opisuje, co jest gwarantowane.
Typ wyjściowy
Typ danych wyjściowych odnosi się do formatu, w którym kodowane są klatki. Możliwe wartości to PRIV, YUV, JPEG i RAW. Są one opisane w dokumentacji createCaptureSession.
Jeśli chcesz zmaksymalizować zgodność, podczas wybierania typu danych wyjściowych aplikacji użyj ImageFormat.YUV_420_888 do analizy klatek i ImageFormat.JPEG do obrazów statycznych. W przypadku scenariuszy podglądu i nagrywania prawdopodobnie będziesz używać elementu SurfaceView, TextureView, MediaRecorder, MediaCodec lub RenderScript.Allocation. W takich przypadkach nie podawaj formatu pliku graficznego. Ze względu na zgodność będzie on liczony jako ImageFormat.PRIVATE niezależnie od rzeczywistego formatu używanego wewnętrznie. Aby sprawdzić formaty obsługiwane przez urządzenie o danym identyfikatorze CameraCharacteristics, użyj tego kodu:
val characteristics: CameraCharacteristics = ... val supportedFormats = characteristics.get( CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP )?.outputFormats
Rozmiar danych wyjściowych
Wszystkie dostępne rozmiary wyjściowe są wymienione w StreamConfigurationMap.getOutputSizes(), ale tylko 2 z nich są związane ze zgodnością: PREVIEW i MAXIMUM. Rozmiary stanowią górne granice. Jeśli coś o rozmiarze PREVIEW działa, to wszystko o rozmiarze mniejszym niż PREVIEW też będzie działać. To samo dotyczy MAXIMUM. Te rozmiary są opisane w dokumentacji CameraDevice.
Dostępne rozmiary wyjściowe zależą od wybranego formatu. Mając CameraCharacteristics i format, możesz wysłać zapytanie o dostępne rozmiary wyjściowe w ten sposób:
val characteristics: CameraCharacteristics = ... val outputFormat: Int = ... // such as ImageFormat.JPEG val sizes = characteristics.get( CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP )?.getOutputSizes(outputFormat)
W przypadku podglądu i nagrywania z kamery użyj klasy docelowej, aby określić obsługiwane rozmiary. Format będzie obsługiwany przez samą platformę aparatu:
val characteristics: CameraCharacteristics = ... val targetClass: Class<T> = ... // such as SurfaceView::class.java val sizes = characteristics.get( CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP )?.getOutputSizes(targetClass)
Aby uzyskać rozmiar MAXIMUM, posortuj rozmiary wyjściowe według obszaru i zwróć największy:
fun <T> getMaximumOutputSize( characteristics: CameraCharacteristics, targetClass: Class<T>, format: Int? = null ): Size { val config = checkNotNull( characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP) ) // If image format is provided, use it to determine supported sizes; or else use target class. val allSizes = if (format == null) config.getOutputSizes(targetClass) else config.getOutputSizes(format) return allSizes.maxBy { it.height * it.width } }
PREVIEW odnosi się do rozmiaru najlepiej dopasowanego do rozdzielczości ekranu urządzenia lub do 1080p (1920 × 1080) – w zależności od tego, która z tych wartości jest mniejsza. Format obrazu może nie odpowiadać dokładnie formatowi ekranu, więc aby wyświetlić transmisję w trybie pełnoekranowym, może być konieczne zastosowanie formatu letterbox lub przycięcie obrazu. Aby uzyskać odpowiedni rozmiar podglądu, porównaj dostępne rozmiary wyjściowe z rozmiarem wyświetlacza, biorąc pod uwagę, że wyświetlacz może być obrócony.
Poniższy kod definiuje klasę pomocniczą SmartSize, która ułatwi porównywanie rozmiarów:
/** Helper class used to pre-compute shortest and longest sides of a [Size] */
class SmartSize(width: Int, height: Int) {
var size = Size(width, height)
var long = max(size.width, size.height)
var short = min(size.width, size.height)
override fun toString() = "SmartSize(${long}x${short})"
}
/** Standard High Definition size for pictures and video */
val SIZE_1080P: SmartSize = SmartSize(1920, 1080)
/** Returns a [SmartSize] object for the given [Display] */
fun getDisplaySmartSize(display: Display): SmartSize {
val outPoint = Point()
display.getRealSize(outPoint)
return SmartSize(outPoint.x, outPoint.y)
}
/**
* Returns the largest available PREVIEW size. For more information, see:
* https://d.android.com/reference/android/hardware/camera2/CameraDevice
*/
fun<T> getPreviewOutputSize(
display: Display,
characteristics: CameraCharacteristics,
targetClass: Class<T>,
format: Int? = null
): Size {
// Find which is smaller: screen or 1080p
val screenSize = getDisplaySmartSize(display)
val hdScreen = screenSize.long >= SIZE_1080P.long || screenSize.short >= SIZE_1080P.short
val maxSize = if (hdScreen) SIZE_1080P else screenSize
// If image format is provided, use it to determine supported sizes; else use target class
val config = characteristics.get(
CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)!!
if (format == null)
assert(StreamConfigurationMap.isOutputSupportedFor(targetClass))
else
assert(config.isOutputSupportedFor(format))
val allSizes = if (format == null)
config.getOutputSizes(targetClass) else config.getOutputSizes(format)
// Get available sizes and sort them by area from largest to smallest
val validSizes = allSizes
.sortedWith(compareBy { it.height * it.width })
.map { SmartSize(it.width, it.height) }.reversed()
// Then, get the largest output size that is smaller or equal than our max size
return validSizes.first { it.long <= maxSize.long && it.short <= maxSize.short }.size
}
Sprawdzanie obsługiwanego poziomu sprzętu
Aby określić dostępne funkcje w czasie działania, sprawdź obsługiwany poziom sprzętu za pomocą CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL.
Za pomocą obiektu CameraCharacteristics możesz pobrać poziom sprzętu za pomocą jednej instrukcji:
val characteristics: CameraCharacteristics = ... // Hardware level will be one of: // - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY, // - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL, // - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED, // - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL, // - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3 val hardwareLevel = characteristics.get( CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL )
Łączenie wszystkich elementów
Na podstawie typu i rozmiaru danych wyjściowych oraz poziomu sprzętu możesz określić, które kombinacje strumieni są prawidłowe. Poniższa tabela przedstawia konfiguracje obsługiwane przez CameraDevice na poziomie sprzętowym LEGACY.
| Cel 1 | Cel 2 | Cel 3 | Przykładowe przypadki użycia | |||
|---|---|---|---|---|---|---|
| Typ | Wielkość maksymalna | Typ | Wielkość maksymalna | Typ | Wielkość maksymalna | |
PRIV |
MAXIMUM |
Prosty podgląd, przetwarzanie wideo na GPU lub nagrywanie wideo bez podglądu. | ||||
JPEG |
MAXIMUM |
Robienie zdjęć bez wizjera. | ||||
YUV |
MAXIMUM |
przetwarzanie filmów i obrazów w aplikacji; | ||||
PRIV |
PREVIEW |
JPEG |
MAXIMUM |
Standardowe zdjęcia. | ||
YUV |
PREVIEW |
JPEG |
MAXIMUM |
Przetwarzanie w aplikacji i robienie zdjęć. | ||
PRIV |
PREVIEW |
PRIV |
PREVIEW |
Nagrywanie standardowe. | ||
PRIV |
PREVIEW |
YUV |
PREVIEW |
Przetwarzanie podglądu i w aplikacji. | ||
PRIV |
PREVIEW |
YUV |
PREVIEW |
JPEG |
MAXIMUM |
Przechwytywanie zdjęć i przetwarzanie w aplikacji. |
LEGACY to najniższy możliwy poziom sprzętowy. Z tej tabeli wynika, że każde urządzenie obsługujące Camera2 (API na poziomie 21 lub wyższym) może przesyłać do 3 strumieni jednocześnie, jeśli jest odpowiednio skonfigurowane i nie ma zbyt wielu czynników ograniczających wydajność, takich jak pamięć, procesor czy ograniczenia termiczne.
Aplikacja musi też skonfigurować bufory wyjściowe kierowania. Aby na przykład kierować reklamy na urządzenie o poziomie sprzętowym LEGACY, możesz skonfigurować 2 docelowe powierzchnie wyjściowe – jedną z użyciem ImageFormat.PRIVATE, a drugą z użyciem ImageFormat.YUV_420_888. To jest obsługiwana kombinacja, gdy używasz rozmiaru PREVIEW. Aby uzyskać wymagane rozmiary podglądu dla identyfikatora kamery, użyj funkcji zdefiniowanej wcześniej w tym dokumencie i tego kodu:
val characteristics: CameraCharacteristics = ... val context = this as Context // assuming you are inside of an activity val surfaceViewSize = getPreviewOutputSize( context, characteristics, SurfaceView::class.java ) val imageReaderSize = getPreviewOutputSize( context, characteristics, ImageReader::class.java, format = ImageFormat.YUV_420_888 )
Wymaga to poczekania, aż SurfaceView będzie gotowy, za pomocą podanych wywołań zwrotnych:
val surfaceView = findViewById<SurfaceView>(...) surfaceView.holder.addCallback(object : SurfaceHolder.Callback { override fun surfaceCreated(holder: SurfaceHolder) { // You do not need to specify image format, and it will be considered of type PRIV. // Surface is now ready and you could use it as an output target for CameraSession. } // ... })
Możesz wymusić dopasowanie SurfaceView do rozmiaru obrazu z kamery, wywołując funkcję SurfaceHolder.setFixedSize(), lub zastosować podejście podobne do AutoFitSurfaceView z modułu Common w przykładowych kodach kamery na GitHubie, które ustawia rozmiar bezwzględny, biorąc pod uwagę zarówno format obrazu, jak i dostępne miejsce, i automatycznie dostosowuje się do zmian aktywności.
Konfigurowanie drugiej platformy z ImageReader w wybranym formacie jest łatwiejsze, ponieważ nie trzeba czekać na wywołania zwrotne:
val frameBufferCount = 3 // just an example, depends on your usage of ImageReader val imageReader = ImageReader.newInstance( imageReaderSize.width, imageReaderSize.height, ImageFormat.YUV_420_888, frameBufferCount )
Jeśli używasz blokującego bufora docelowego, takiego jak ImageReader, po użyciu klatek odrzuć je:
imageReader.setOnImageAvailableListener({ val frame = it.acquireNextImage() // Do something with "frame" here. it.close() }, null)
Poziom sprzętowy LEGACY jest przeznaczony dla urządzeń o najniższym wspólnym mianowniku. Możesz dodać rozgałęzienie warunkowe i użyć rozmiaru RECORD dla jednej z wyjściowych powierzchni docelowych na urządzeniach o poziomie sprzętowym LIMITED, a nawet zwiększyć go do rozmiaru MAXIMUM na urządzeniach o poziomie sprzętowym FULL.