Observação:esta página se refere ao pacote Camera2. A menos que seu app exija recursos específicos e de baixo nível do Camera2, recomendamos o uso do CameraX. CameraX e Camera2 oferecem suporte ao Android 5.0 (nível 21 da API) e versões mais recentes.
O recurso de várias câmeras foi lançado no Android 9 (nível 28 da API). Desde o lançamento, foram lançados no mercado com suporte para essa API. Muitos casos de uso com várias câmeras estão fortemente acoplados a uma configuração de hardware específica. Em outras palavras, não todos os casos de uso são compatíveis com todos os dispositivos, o que permite usar várias câmeras apresenta um bom candidato para o recurso do Google Play Exibição.
Veja alguns casos de uso comuns:
- Zoom: alterna entre as câmeras, dependendo da região de corte ou do foco desejado. comprimento.
- Profundidade: usar várias câmeras para criar um mapa de profundidade.
- Bokeh: uso de informações de profundidade inferidas para simular uma conexão estreita semelhante a DSLR intervalo de foco.
A diferença entre as câmeras lógicas e físicas
Entender a API de várias câmeras exige entender a diferença entre câmeras lógicas e físicas. Para referência, considere um dispositivo com três câmeras traseiras. Neste exemplo, cada uma das três câmeras traseiras considerada uma câmera física. Uma câmera lógica é um agrupamento de dois ou mais dessas câmeras físicas. A saída do módulo uma câmera pode ser um fluxo que vem de uma das câmeras físicas subjacentes, ou fluxo fundido emitido por mais de uma câmera física ao mesmo tempo. De qualquer forma, a transmissão é processada pelo hardware da câmera. camada de abstração (HAL).
Muitos fabricantes de smartphones desenvolvem aplicativos próprios para câmeras, que geralmente vêm pré-instalados nos dispositivos. Para usar todos os recursos do hardware, eles podem usar APIs privadas ou ocultas ou receber tratamento especial de a implementação do driver a que outros aplicativos não têm acesso. Algumas dispositivos implementam o conceito de câmeras lógicas, fornecendo um fluxo mesclado de frames das diferentes câmeras físicas, mas somente para alguns aplicativos conteinerizados. Com frequência, apenas uma das câmeras físicas fica exposta ao de análise de dados em nuvem. A situação dos desenvolvedores terceirizados anteriores ao Android 9 é ilustrado no diagrama a seguir:
A partir do Android 9, APIs privadas não são mais permitidas em apps Android. Com a inclusão de suporte a várias câmeras no framework, o Android melhor recomendam que os fabricantes de smartphones exponham uma câmera lógica para todas as câmeras físicas voltadas para a mesma direção. Veja a seguir que os desenvolvedores de terceiros esperam ver em dispositivos com Android 9 e mais alta:
O que a câmera lógica oferece depende totalmente da implementação do OEM da HAL da câmera. Por exemplo, um dispositivo como o Pixel 3 implementa a lógica de tal forma que escolha uma de suas câmeras físicas com base no a distância focal e a região de corte solicitadas.
A API de várias câmeras
A nova API adiciona as novas constantes, classes e métodos a seguir:
CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA
CameraCharacteristics.getPhysicalCameraIds()
CameraCharacteristics.getAvailablePhysicalCameraRequestKeys()
CameraDevice.createCaptureSession(SessionConfiguration config)
CameraCharacteritics.LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE
OutputConfiguration
eSessionConfiguration
Devido a mudanças no Documento de definição de compatibilidade (CDD) do Android, os a API multicâmera também tem algumas expectativas dos desenvolvedores. Dispositivos com duas câmeras existiam antes do Android 9, mas abrindo mais de uma câmera envolvia tentativa e erro ao mesmo tempo. No Android 9 e versões mais recentes, várias câmeras fornece um conjunto de regras para especificar quando é possível abrir um par de instâncias que fazem parte da mesma câmera lógica.
Na maioria dos casos, dispositivos com o Android 9 e versões mais recentes expõem todos os componentes (exceto possivelmente para tipos de sensores menos comuns, como infravermelho), além de uma câmera lógica mais fácil de usar. Para cada combinação de streams um fluxo de uma câmera lógica pode ser substituído pelo dois streams das câmeras físicas subjacentes.
Várias transmissões simultâneas
Como usar simultaneamente vários streams de câmera
aborda as regras para usar várias transmissões simultâneas com uma única câmera.
Com uma adição notável, as mesmas regras se aplicam a várias câmeras.
CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA
explica como substituir um YUV_420_888 lógico ou stream bruto por dois
streams físicos. Ou seja, cada fluxo do tipo YUV ou RAW pode ser substituído por
dois streams de tipo e tamanho idênticos. Comece com um stream da câmera
a seguinte configuração garantida para dispositivos com uma única câmera:
- Stream 1: tipo YUV, tamanho
MAXIMUM
da câmera lógicaid = 0
Assim, um dispositivo compatível com várias câmeras permite que você crie uma sessão substituindo o fluxo YUV lógico por dois físicos:
- Stream 1: tipo YUV, tamanho
MAXIMUM
da câmera físicaid = 1
- Stream 2: tipo YUV, tamanho
MAXIMUM
da câmera físicaid = 2
Só será possível substituir um stream YUV ou RAW por dois equivalentes se
Essas duas câmeras são parte de um agrupamento lógico de câmeras, que está listado em
CameraCharacteristics.getPhysicalCameraIds()
As garantias fornecidas pelo framework são o mínimo necessário para ver frames de mais de uma câmera física simultaneamente. Streams adicionais são suportados na maioria dos dispositivos, às vezes permitindo a abertura de vários e dispositivos de câmera de forma independente. Como não é uma garantia rígida da Isso requer a realização de testes e ajustes por dispositivo usando tentativa e erro.
Criar uma sessão com várias câmeras físicas
Ao usar câmeras físicas em um dispositivo compatível com várias câmeras, abra uma única
CameraDevice
(a câmera lógica) e interagem com ela em um único
sessão. Criar a única sessão usando a API
CameraDevice.createCaptureSession(SessionConfiguration config)
, que foi
adicionados no nível 28 da API. A configuração da sessão tem diversas saídas
do Terraform, cada uma com um conjunto de destinos de saída e, opcionalmente, um
ID desejado da câmera física.
As solicitações de captura têm um destino de saída associado a elas. A estrutura determina para qual câmera física (ou lógica) as solicitações são enviadas com base qual destino de saída está anexado. Se o destino de saída corresponder a um dos de saída que foram enviados como uma configuração de saída junto com uma ID da câmera, essa câmera física recebe e processa a solicitação.
Usar um par de câmeras físicas
Outra adição às APIs de câmera para várias câmeras é a capacidade de identificar câmeras lógicas e encontrar as câmeras físicas atrás delas. Você pode definir para ajudar a identificar possíveis pares de câmeras físicas que você pode usar para substituir um dos streams lógicos de câmera:
Kotlin
/** * Helper class used to encapsulate a logical camera and two underlying * physical cameras */ data class DualCamera(val logicalId: String, val physicalId1: String, val physicalId2: String) fun findDualCameras(manager: CameraManager, facing: Int? = null): List{ val dualCameras = MutableList () // Iterate over all the available camera characteristics manager.cameraIdList.map { Pair(manager.getCameraCharacteristics(it), it) }.filter { // Filter by cameras facing the requested direction facing == null || it.first.get(CameraCharacteristics.LENS_FACING) == facing }.filter { // Filter by logical cameras // CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA requires API >= 28 it.first.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)!!.contains( CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) }.forEach { // All possible pairs from the list of physical cameras are valid results // NOTE: There could be N physical cameras as part of a logical camera grouping // getPhysicalCameraIds() requires API >= 28 val physicalCameras = it.first.physicalCameraIds.toTypedArray() for (idx1 in 0 until physicalCameras.size) { for (idx2 in (idx1 + 1) until physicalCameras.size) { dualCameras.add(DualCamera( it.second, physicalCameras[idx1], physicalCameras[idx2])) } } } return dualCameras }
Java
/** * Helper class used to encapsulate a logical camera and two underlying * physical cameras */ final class DualCamera { final String logicalId; final String physicalId1; final String physicalId2; DualCamera(String logicalId, String physicalId1, String physicalId2) { this.logicalId = logicalId; this.physicalId1 = physicalId1; this.physicalId2 = physicalId2; } } ListfindDualCameras(CameraManager manager, Integer facing) { List dualCameras = new ArrayList<>(); List cameraIdList; try { cameraIdList = Arrays.asList(manager.getCameraIdList()); } catch (CameraAccessException e) { e.printStackTrace(); cameraIdList = new ArrayList<>(); } // Iterate over all the available camera characteristics cameraIdList.stream() .map(id -> { try { CameraCharacteristics characteristics = manager.getCameraCharacteristics(id); return new Pair<>(characteristics, id); } catch (CameraAccessException e) { e.printStackTrace(); return null; } }) .filter(pair -> { // Filter by cameras facing the requested direction return (pair != null) && (facing == null || pair.first.get(CameraCharacteristics.LENS_FACING).equals(facing)); }) .filter(pair -> { // Filter by logical cameras // CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA requires API >= 28 IntPredicate logicalMultiCameraPred = arg -> arg == CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA; return Arrays.stream(pair.first.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)) .anyMatch(logicalMultiCameraPred); }) .forEach(pair -> { // All possible pairs from the list of physical cameras are valid results // NOTE: There could be N physical cameras as part of a logical camera grouping // getPhysicalCameraIds() requires API >= 28 String[] physicalCameras = pair.first.getPhysicalCameraIds().toArray(new String[0]); for (int idx1 = 0; idx1 < physicalCameras.length; idx1++) { for (int idx2 = idx1 + 1; idx2 < physicalCameras.length; idx2++) { dualCameras.add( new DualCamera(pair.second, physicalCameras[idx1], physicalCameras[idx2])); } } }); return dualCameras; }
O manuseio de estado das câmeras físicas é controlado pela câmera lógica. Para abrir uma "câmera dupla". abrir a câmera lógica correspondente ao câmeras:
Kotlin
fun openDualCamera(cameraManager: CameraManager, dualCamera: DualCamera, // AsyncTask is deprecated beginning API 30 executor: Executor = AsyncTask.SERIAL_EXECUTOR, callback: (CameraDevice) -> Unit) { // openCamera() requires API >= 28 cameraManager.openCamera( dualCamera.logicalId, executor, object : CameraDevice.StateCallback() { override fun onOpened(device: CameraDevice) = callback(device) // Omitting for brevity... override fun onError(device: CameraDevice, error: Int) = onDisconnected(device) override fun onDisconnected(device: CameraDevice) = device.close() }) }
Java
void openDualCamera(CameraManager cameraManager, DualCamera dualCamera, Executor executor, CameraDeviceCallback cameraDeviceCallback ) { // openCamera() requires API >= 28 cameraManager.openCamera(dualCamera.logicalId, executor, new CameraDevice.StateCallback() { @Override public void onOpened(@NonNull CameraDevice cameraDevice) { cameraDeviceCallback.callback(cameraDevice); } @Override public void onDisconnected(@NonNull CameraDevice cameraDevice) { cameraDevice.close(); } @Override public void onError(@NonNull CameraDevice cameraDevice, int i) { onDisconnected(cameraDevice); } }); }
Além de selecionar qual câmera abrir, o processo é o mesmo que abrir uma câmera em versões anteriores do Android. Criar uma sessão de captura usando o novo A API de configuração da sessão pede que o framework associe determinados destinos IDs específicos de câmeras físicas:
Kotlin
/** * Helper type definition that encapsulates 3 sets of output targets: * * 1. Logical camera * 2. First physical camera * 3. Second physical camera */ typealias DualCameraOutputs = Triple?, MutableList ?, MutableList ?> fun createDualCameraSession(cameraManager: CameraManager, dualCamera: DualCamera, targets: DualCameraOutputs, // AsyncTask is deprecated beginning API 30 executor: Executor = AsyncTask.SERIAL_EXECUTOR, callback: (CameraCaptureSession) -> Unit) { // Create 3 sets of output configurations: one for the logical camera, and // one for each of the physical cameras. val outputConfigsLogical = targets.first?.map { OutputConfiguration(it) } val outputConfigsPhysical1 = targets.second?.map { OutputConfiguration(it).apply { setPhysicalCameraId(dualCamera.physicalId1) } } val outputConfigsPhysical2 = targets.third?.map { OutputConfiguration(it).apply { setPhysicalCameraId(dualCamera.physicalId2) } } // Put all the output configurations into a single flat array val outputConfigsAll = arrayOf( outputConfigsLogical, outputConfigsPhysical1, outputConfigsPhysical2) .filterNotNull().flatMap { it } // Instantiate a session configuration that can be used to create a session val sessionConfiguration = SessionConfiguration( SessionConfiguration.SESSION_REGULAR, outputConfigsAll, executor, object : CameraCaptureSession.StateCallback() { override fun onConfigured(session: CameraCaptureSession) = callback(session) // Omitting for brevity... override fun onConfigureFailed(session: CameraCaptureSession) = session.device.close() }) // Open the logical camera using the previously defined function openDualCamera(cameraManager, dualCamera, executor = executor) { // Finally create the session and return via callback it.createCaptureSession(sessionConfiguration) } }
Java
/** * Helper class definition that encapsulates 3 sets of output targets: ** 1. Logical camera * 2. First physical camera * 3. Second physical camera */ final class DualCameraOutputs { private final List
logicalCamera; private final List firstPhysicalCamera; private final List secondPhysicalCamera; public DualCameraOutputs(List logicalCamera, List firstPhysicalCamera, List third) { this.logicalCamera = logicalCamera; this.firstPhysicalCamera = firstPhysicalCamera; this.secondPhysicalCamera = third; } public List getLogicalCamera() { return logicalCamera; } public List getFirstPhysicalCamera() { return firstPhysicalCamera; } public List getSecondPhysicalCamera() { return secondPhysicalCamera; } } interface CameraCaptureSessionCallback { void callback(CameraCaptureSession cameraCaptureSession); } void createDualCameraSession(CameraManager cameraManager, DualCamera dualCamera, DualCameraOutputs targets, Executor executor, CameraCaptureSessionCallback cameraCaptureSessionCallback) { // Create 3 sets of output configurations: one for the logical camera, and // one for each of the physical cameras. List outputConfigsLogical = targets.getLogicalCamera().stream() .map(OutputConfiguration::new) .collect(Collectors.toList()); List outputConfigsPhysical1 = targets.getFirstPhysicalCamera().stream() .map(s -> { OutputConfiguration outputConfiguration = new OutputConfiguration(s); outputConfiguration.setPhysicalCameraId(dualCamera.physicalId1); return outputConfiguration; }) .collect(Collectors.toList()); List outputConfigsPhysical2 = targets.getSecondPhysicalCamera().stream() .map(s -> { OutputConfiguration outputConfiguration = new OutputConfiguration(s); outputConfiguration.setPhysicalCameraId(dualCamera.physicalId2); return outputConfiguration; }) .collect(Collectors.toList()); // Put all the output configurations into a single flat array List outputConfigsAll = Stream.of( outputConfigsLogical, outputConfigsPhysical1, outputConfigsPhysical2 ) .filter(Objects::nonNull) .flatMap(Collection::stream) .collect(Collectors.toList()); // Instantiate a session configuration that can be used to create a session SessionConfiguration sessionConfiguration = new SessionConfiguration( SessionConfiguration.SESSION_REGULAR, outputConfigsAll, executor, new CameraCaptureSession.StateCallback() { @Override public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) { cameraCaptureSessionCallback.callback(cameraCaptureSession); } // Omitting for brevity... @Override public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) { cameraCaptureSession.getDevice().close(); } }); // Open the logical camera using the previously defined function openDualCamera(cameraManager, dualCamera, executor, (CameraDevice c) -> // Finally create the session and return via callback c.createCaptureSession(sessionConfiguration)); }
Consulte
createCaptureSession
para saber qual combinação de streams é compatível. Combinar streams
serve para vários streams em uma única câmera lógica. A compatibilidade se estende à
usando a mesma configuração e substituindo um desses streams por dois
de duas câmeras físicas que fazem parte da mesma câmera lógica.
Com o sessão da câmera pronto, envie o pedido capturar solicitações. Cada o destino da solicitação de captura recebe os dados da rede física associada se houver alguma em uso, ou recorrer à câmera lógica.
Exemplo de caso de uso do Zoom
É possível usar a fusão de câmeras físicas em um único stream para que que os usuários possam alternar entre as diferentes câmeras físicas um campo de visão diferente, capturando efetivamente um "nível de zoom" diferente.
Comece selecionando o par de câmeras físicas para permitir que os usuários alternem entre eles. Para obter o efeito máximo, você pode escolher o par de câmeras que fornecem distância focal mínima e máxima disponíveis.
Kotlin
fun findShortLongCameraPair(manager: CameraManager, facing: Int? = null): DualCamera? { return findDualCameras(manager, facing).map { val characteristics1 = manager.getCameraCharacteristics(it.physicalId1) val characteristics2 = manager.getCameraCharacteristics(it.physicalId2) // Query the focal lengths advertised by each physical camera val focalLengths1 = characteristics1.get( CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS) ?: floatArrayOf(0F) val focalLengths2 = characteristics2.get( CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS) ?: floatArrayOf(0F) // Compute the largest difference between min and max focal lengths between cameras val focalLengthsDiff1 = focalLengths2.maxOrNull()!! - focalLengths1.minOrNull()!! val focalLengthsDiff2 = focalLengths1.maxOrNull()!! - focalLengths2.minOrNull()!! // Return the pair of camera IDs and the difference between min and max focal lengths if (focalLengthsDiff1 < focalLengthsDiff2) { Pair(DualCamera(it.logicalId, it.physicalId1, it.physicalId2), focalLengthsDiff1) } else { Pair(DualCamera(it.logicalId, it.physicalId2, it.physicalId1), focalLengthsDiff2) } // Return only the pair with the largest difference, or null if no pairs are found }.maxByOrNull { it.second }?.first }
Java
// Utility functions to find min/max value in float[] float findMax(float[] array) { float max = Float.NEGATIVE_INFINITY; for(float cur: array) max = Math.max(max, cur); return max; } float findMin(float[] array) { float min = Float.NEGATIVE_INFINITY; for(float cur: array) min = Math.min(min, cur); return min; } DualCamera findShortLongCameraPair(CameraManager manager, Integer facing) { return findDualCameras(manager, facing).stream() .map(c -> { CameraCharacteristics characteristics1; CameraCharacteristics characteristics2; try { characteristics1 = manager.getCameraCharacteristics(c.physicalId1); characteristics2 = manager.getCameraCharacteristics(c.physicalId2); } catch (CameraAccessException e) { e.printStackTrace(); return null; } // Query the focal lengths advertised by each physical camera float[] focalLengths1 = characteristics1.get( CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS); float[] focalLengths2 = characteristics2.get( CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS); // Compute the largest difference between min and max focal lengths between cameras Float focalLengthsDiff1 = findMax(focalLengths2) - findMin(focalLengths1); Float focalLengthsDiff2 = findMax(focalLengths1) - findMin(focalLengths2); // Return the pair of camera IDs and the difference between min and max focal lengths if (focalLengthsDiff1 < focalLengthsDiff2) { return new Pair<>(new DualCamera(c.logicalId, c.physicalId1, c.physicalId2), focalLengthsDiff1); } else { return new Pair<>(new DualCamera(c.logicalId, c.physicalId2, c.physicalId1), focalLengthsDiff2); } }) // Return only the pair with the largest difference, or null if no pairs are found .max(Comparator.comparing(pair -> pair.second)).get().first; }
Uma arquitetura sensata para isso seria ter dois
SurfaceViews
: uma para cada transmissão.
Esses SurfaceViews
são trocados com base na interação do usuário, de modo que apenas um seja
visíveis a qualquer momento.
O código a seguir mostra como abrir a câmera lógica e configurar a câmera de saída, criar uma sessão de câmera e iniciar dois streams de visualização:
Kotlin
val cameraManager: CameraManager = ... // Get the two output targets from the activity / fragment val surface1 = ... // from SurfaceView val surface2 = ... // from SurfaceView val dualCamera = findShortLongCameraPair(manager)!! val outputTargets = DualCameraOutputs( null, mutableListOf(surface1), mutableListOf(surface2)) // Here you open the logical camera, configure the outputs and create a session createDualCameraSession(manager, dualCamera, targets = outputTargets) { session -> // Create a single request which has one target for each physical camera // NOTE: Each target receive frames from only its associated physical camera val requestTemplate = CameraDevice.TEMPLATE_PREVIEW val captureRequest = session.device.createCaptureRequest(requestTemplate).apply { arrayOf(surface1, surface2).forEach { addTarget(it) } }.build() // Set the sticky request for the session and you are done session.setRepeatingRequest(captureRequest, null, null) }
Java
CameraManager manager = ...; // Get the two output targets from the activity / fragment Surface surface1 = ...; // from SurfaceView Surface surface2 = ...; // from SurfaceView DualCamera dualCamera = findShortLongCameraPair(manager, null); DualCameraOutputs outputTargets = new DualCameraOutputs( null, Collections.singletonList(surface1), Collections.singletonList(surface2)); // Here you open the logical camera, configure the outputs and create a session createDualCameraSession(manager, dualCamera, outputTargets, null, (session) -> { // Create a single request which has one target for each physical camera // NOTE: Each target receive frames from only its associated physical camera CaptureRequest.Builder captureRequestBuilder; try { captureRequestBuilder = session.getDevice().createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW); Arrays.asList(surface1, surface2).forEach(captureRequestBuilder::addTarget); // Set the sticky request for the session and you are done session.setRepeatingRequest(captureRequestBuilder.build(), null, null); } catch (CameraAccessException e) { e.printStackTrace(); } });
Tudo o que resta a fazer é fornecer uma interface para o usuário alternar entre os dois
superfícies, como um botão ou toque duplo no SurfaceView
. Você pode até
realizar algum tipo de análise de cena e alternar entre os dois fluxos
automaticamente.
Distorção da lente
Todas as lentes produzem uma certa distorção. No Android, é possível consultar
distorção gerada pelas lentes com o uso
CameraCharacteristics.LENS_DISTORTION
,
que substitui a versão descontinuada
CameraCharacteristics.LENS_RADIAL_DISTORTION
Para câmeras lógicas, a distorção é mínima, e o aplicativo pode usar
mais ou menos quadros que vêm da câmera. Para câmeras físicas,
há configurações de lente muito diferentes, especialmente em dispositivos
lentes.
Alguns dispositivos podem implementar a correção automática da distorção por meio de
CaptureRequest.DISTORTION_CORRECTION_MODE
A correção de distorção é ativada por padrão na maioria dos dispositivos.
Kotlin
val cameraSession: CameraCaptureSession = ... // Use still capture template to build the capture request val captureRequest = cameraSession.device.createCaptureRequest( CameraDevice.TEMPLATE_STILL_CAPTURE ) // Determine if this device supports distortion correction val characteristics: CameraCharacteristics = ... val supportsDistortionCorrection = characteristics.get( CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES )?.contains( CameraMetadata.DISTORTION_CORRECTION_MODE_HIGH_QUALITY ) ?: false if (supportsDistortionCorrection) { captureRequest.set( CaptureRequest.DISTORTION_CORRECTION_MODE, CameraMetadata.DISTORTION_CORRECTION_MODE_HIGH_QUALITY ) } // Add output target, set other capture request parameters... // Dispatch the capture request cameraSession.capture(captureRequest.build(), ...)
Java
CameraCaptureSession cameraSession = ...; // Use still capture template to build the capture request CaptureRequest.Builder captureRequestBuilder = null; try { captureRequestBuilder = cameraSession.getDevice().createCaptureRequest( CameraDevice.TEMPLATE_STILL_CAPTURE ); } catch (CameraAccessException e) { e.printStackTrace(); } // Determine if this device supports distortion correction CameraCharacteristics characteristics = ...; boolean supportsDistortionCorrection = Arrays.stream( characteristics.get( CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES )) .anyMatch(i -> i == CameraMetadata.DISTORTION_CORRECTION_MODE_HIGH_QUALITY); if (supportsDistortionCorrection) { captureRequestBuilder.set( CaptureRequest.DISTORTION_CORRECTION_MODE, CameraMetadata.DISTORTION_CORRECTION_MODE_HIGH_QUALITY ); } // Add output target, set other capture request parameters... // Dispatch the capture request cameraSession.capture(captureRequestBuilder.build(), ...);
Definir uma solicitação de captura nesse modo pode afetar o frame rate que pode ser produzidos pela câmera. Você pode optar por configurar a correção da distorção apenas em de imagens estáticas.