Referência de estrutura camera3_capture_result
#include < camera3.h >
Campos de dados | |
| uint32_t | número do quadro |
| const camera_metadata_t * | resultado |
| uint32_t | num_output_buffers |
| const camera3_stream_buffer_t * | buffer_de saída |
| const camera3_stream_buffer_t * | buffer_de entrada |
| uint32_t | resultado_parcial |
Descrição detalhada
camera3_capture_result_t:
O resultado de uma única captura/reprocessamento pelo dispositivo HAL da câmera. Isso é enviado para a estrutura de forma assíncrona com process_capture_result(), em resposta a uma única solicitação de captura enviada ao HAL com process_capture_request(). Múltiplas chamadas process_capture_result() podem ser executadas pelo HAL para cada solicitação.
Cada chamada, todas com o mesmo número de quadro, pode conter algum subconjunto dos buffers de saída e/ou os metadados de resultado. Os metadados só podem ser fornecidos uma vez para um determinado número de quadro; todas as outras chamadas devem definir os metadados do resultado como NULL.
A estrutura de resultado contém os metadados de saída desta captura e o conjunto de buffers de saída que foram/serão preenchidos para esta captura. Cada buffer de saída pode vir com uma cerca de sincronização de liberação que o framework aguardará antes de ler, caso o buffer ainda não tenha sido preenchido pelo HAL.
>= CAMERA_DEVICE_API_VERSION_3_2:
Os metadados podem ser fornecidos múltiplas vezes para um único número de quadro. A estrutura acumulará o conjunto de resultados final combinando cada resultado parcial no conjunto de resultados total.
Se um buffer de entrada for fornecido em uma solicitação, o HAL deverá retorná-lo em uma das chamadas process_capture_result, e a chamada pode ser apenas para retornar o buffer de entrada, sem metadados e buffers de saída; as cercas de sincronização devem ser tratadas da mesma forma que são feitas para buffers de saída.
Considerações de desempenho:
Os aplicativos também receberão esses resultados parciais imediatamente, portanto, o envio de resultados parciais é uma otimização de desempenho altamente recomendada para evitar a latência total do pipeline antes de enviar os resultados para o que é conhecido logo no início do pipeline.
Um caso de uso típico pode ser o cálculo do estado AF no meio do pipeline; ao enviar o estado de volta à estrutura imediatamente, obtemos um aumento de 50% no desempenho e na capacidade de resposta percebida do foco automático.
Documentação de campo
| uint32_t número_do_quadro |
O número do quadro é um número inteiro incremental definido pela estrutura na solicitação enviada para identificar exclusivamente esta captura. Também é usado para identificar a solicitação em notificações assíncronas enviadas para camera3_callback_ops_t.notify() .
| const camera3_stream_buffer_t * input_buffer |
>= CAMERA_DEVICE_API_VERSION_3_2:
O identificador do buffer de fluxo de entrada para esta captura. Pode ainda não ter sido consumido no momento em que o HAL chama process_capture_result(); a estrutura aguardará as cercas de sincronização de liberação fornecidas pelo HAL antes de reutilizar o buffer.
O HAL deve tratar as cercas de sincronização da mesma forma que são feitas para output_buffers.
Apenas um buffer de entrada pode ser enviado por solicitação. Da mesma forma que os buffers de saída, a ordem dos buffers de entrada retornados deve ser mantida pelo HAL.
Considerações de desempenho:
O buffer de entrada deve ser retornado o mais cedo possível. Se o HAL suportar limites de sincronização, ele poderá chamar process_capture_result para devolvê-lo com limites de sincronização configurados adequadamente. Se as barreiras de sincronização não forem suportadas, o buffer só poderá ser retornado quando for consumido, o que pode levar muito tempo; o HAL pode optar por copiar esse buffer de entrada para fazer com que o buffer retorne mais cedo.
| uint32_t num_output_buffers |
O número de buffers de saída retornados nesta estrutura de resultados. Deve ser menor ou igual à contagem da solicitação de captura correspondente. Se for menor que a contagem de buffer na solicitação de captura, pelo menos mais uma chamada para process_capture_result com o mesmo frame_number deverá ser feita, para retornar os buffers de saída restantes para a estrutura. Isso só poderá ser zero se a estrutura incluir metadados de resultado válidos ou se um buffer de entrada for retornado neste resultado.
| const camera3_stream_buffer_t * saída_buffers |
Os identificadores dos buffers de fluxo de saída para esta captura. Eles podem ainda não estar preenchidos no momento em que o HAL chama process_capture_result(); a estrutura aguardará as cercas de sincronização de liberação fornecidas pelo HAL antes de ler os buffers.
O HAL deve definir o limite de sincronização de liberação do buffer de fluxo para um fd de sincronização válido ou para -1 se o buffer já tiver sido preenchido.
Se o HAL encontrar um erro ao processar o buffer e o buffer não for preenchido, o campo de status do buffer deverá ser definido como CAMERA3_BUFFER_STATUS_ERROR. Se o HAL não esperou no limite de aquisição antes de encontrar o erro, o limite de aquisição deverá ser copiado no limite de liberação, para permitir que a estrutura espere no limite antes de reutilizar o buffer.
O limite de aquisição deve ser definido como -1 para todos os buffers de saída. Se num_output_buffers for zero, pode ser NULL. Nesse caso, pelo menos mais uma chamada process_capture_result deve ser feita pelo HAL para fornecer os buffers de saída.
Quando process_capture_result é chamado com um novo buffer para um quadro, todos os buffers de quadros anteriores para esse fluxo correspondente já devem ter sido entregues (as cercas ainda não precisam ter sido sinalizadas).
>= CAMERA_DEVICE_API_VERSION_3_2:
Buffers Gralloc para um quadro podem ser enviados para a estrutura antes da notificação SHUTTER correspondente.
Considerações de desempenho:
Os buffers entregues à estrutura não serão despachados para a camada de aplicação até que um carimbo de data/hora de início de exposição seja recebido por meio de uma chamada SHUTTER notify(). É altamente recomendável despachar essa chamada o mais cedo possível.
| uint32_t resultado_parcial |
>= CAMERA_DEVICE_API_VERSION_3_2:
Para aproveitar os resultados parciais, o HAL deve definir os metadados estáticos android.request.partialResultCount para o número de resultados parciais que enviará para cada quadro.
Cada novo resultado de captura com um resultado parcial deve definir este campo (partial_result) com um valor inclusivo distinto entre 1 e android.request.partialResultCount.
HALs que não desejam aproveitar esse recurso não devem definir um android.request.partialResultCount ou parcial_result com um valor diferente de 1.
Este valor deve ser definido como 0 quando um resultado de captura contém apenas buffers e nenhum metadado.
| const camera_metadata_t * resultado |
Os metadados de resultado desta captura. Contém informações sobre os parâmetros finais de captura, o estado do hardware de captura e pós-processamento, o estado dos algoritmos 3A, se habilitados, e a saída de quaisquer unidades estatísticas habilitadas.
Apenas uma chamada para process_capture_result() com um determinado frame_number pode incluir os metadados do resultado. Todas as outras chamadas para o mesmo frame_number devem ser definidas como NULL.
Se houve um erro ao produzir os metadados do resultado, o resultado deverá ser um buffer de metadados vazio e notify() deverá ser chamado com ERROR_RESULT.
>= CAMERA_DEVICE_API_VERSION_3_2:
Várias chamadas para process_capture_result() com um determinado frame_number podem incluir os metadados do resultado.
Os metadados parciais enviados não devem incluir nenhuma chave de metadados retornada em um resultado parcial anterior para um determinado quadro. Cada novo resultado parcial para esse quadro também deve definir um valor parcial_result distinto.
Se notify tiver sido chamado com ERROR_RESULT, todos os outros resultados parciais desse quadro serão ignorados pela estrutura.
A documentação desta estrutura foi gerada a partir do seguinte arquivo:
- hardware/libhardware/incluir/hardware/ camera3.h