Referência da estrutura camera3_capture_result
#include <
camera3.h
>
Campos de dados |
|
| uint32_t | frame_number |
| const camera_metadata_t * | resultado |
| uint32_t | num_output_buffers |
| const camera3_stream_buffer_t * | output_buffers |
| const camera3_stream_buffer_t * | input_buffer |
| uint32_t | partial_result |
Descrição detalhada
camera3_capture_result_t:
O resultado de uma única captura/reprocessamento pelo dispositivo HAL da câmera. Ele é enviado ao framework de forma assíncrona com process_capture_result(), em resposta a uma única solicitação de captura enviada ao HAL com process_capture_request(). Várias chamadas de process_capture_result() podem ser realizadas pelo HAL para cada solicitação.
Cada chamada, com o mesmo número de frame, pode conter um subconjunto dos buffers de saída e/ou dos metadados do resultado. Os metadados só podem ser fornecidos uma vez para um determinado número de frame. Todas as outras chamadas precisam definir os metadados do resultado como NULL.
A estrutura de resultados contém os metadados de saída dessa captura e o conjunto de buffers de saída que foram/serão preenchidos para essa captura. Cada buffer de saída pode vir com uma cerca de sincronização de liberação que o framework vai aguardar antes da leitura, caso o buffer ainda não tenha sido preenchido pelo HAL.
>= CAMERA_DEVICE_API_VERSION_3_2:
Os metadados podem ser fornecidos várias vezes para um único número de frame. O framework vai 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 precisará retorná-lo em uma das chamadas process_capture_result, e a chamada poderá ser apenas para retornar o buffer de entrada, sem metadados e buffers de saída. As cercas de sincronização precisam ser processadas da mesma forma que para buffers de saída.
Considerações sobre performance:
Os aplicativos também vão receber 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 do que é conhecido no início do pipeline.
Um caso de uso comum é calcular o estado do AF no meio do pipeline. Ao enviar o estado de volta ao framework imediatamente, temos um aumento de 50% no desempenho e na capacidade de resposta percebida do foco automático.
Documentação do campo
| uint32_t frame_number |
O número de frames é um número inteiro de incremento definido pelo framework na solicitação enviada para identificar exclusivamente essa captura. Ele 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 stream de entrada para essa captura. Ele pode não ser consumido no momento em que o HAL chama process_capture_result(); o framework vai aguardar as cercas de sincronização de liberação fornecidas pelo HAL antes de reutilizar o buffer.
O HAL precisa processar as cercas de sincronização da mesma forma que elas são processadas para output_buffers.
Apenas um buffer de entrada pode ser enviado por solicitação. Assim como os buffers de saída, a ordem dos buffers de entrada retornados precisa ser mantida pelo HAL.
Considerações sobre performance:
O buffer de entrada precisa ser retornado o mais cedo possível. Se o HAL oferecer suporte a limites de sincronização, ele poderá chamar process_capture_result para devolvê-lo com os limites de sincronização definidos adequadamente. Se as cercas de sincronização não tiverem suporte, o buffer só poderá ser retornado quando for consumido, o que pode levar muito tempo. O HAL pode copiar esse buffer de entrada para que ele seja retornado mais cedo.
| uint32_t num_output_buffers |
O número de buffers de saída retornados nesta estrutura de resultados. Precisa ser menor ou igual à contagem da solicitação de captura correspondente. Se esse valor 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 precisa ser feita para retornar os buffers de saída restantes ao framework. Esse valor só pode ser zero se a estrutura incluir metadados de resultado válidos ou se um buffer de entrada for retornado nesse resultado.
| const camera3_stream_buffer_t * output_buffers |
Os identificadores dos buffers de stream de saída para essa captura. Eles podem não ser preenchidos no momento em que o HAL chama process_capture_result(); o framework vai esperar pelas cercas de sincronização de lançamento fornecidas pelo HAL antes de ler os buffers.
O HAL precisa definir a cerca de sincronização de liberação do buffer de stream para um fd de sincronização válido ou -1 se o buffer já estiver preenchido.
Se o HAL encontrar um erro ao processar o buffer e o buffer não estiver preenchido, o campo de status do buffer precisará ser definido como CAMERA3_BUFFER_STATUS_ERROR. Se o HAL não esperou na cerca de aquisição antes de encontrar o erro, a cerca de aquisição precisa ser copiada para a cerca de liberação, para permitir que o framework aguarde na cerca antes de reutilizar o buffer.
A cerca de aquisição precisa ser definida como -1 para todos os buffers de saída. Se num_output_buffers for zero, ele poderá ser NULO. Nesse caso, pelo menos mais uma chamada process_capture_result precisa ser feita pelo HAL para fornecer os buffers de saída.
Quando process_capture_result é chamado com um novo buffer para um frame, todos os buffers de frames anteriores para esse stream correspondente precisam ter sido entregues (as cercas não precisam ter sido sinalizadas).
>= CAMERA_DEVICE_API_VERSION_3_2:
Os buffers Gralloc de um frame podem ser enviados para o framework antes do SHUTTER-notify correspondente.
Considerações sobre performance:
Os buffers enviados para o framework não serão enviados para a camada do aplicativo até que um carimbo de data/hora de início de exposição seja recebido por uma chamada SHUTTER notify(). É altamente recomendável enviar essa chamada o mais cedo possível.
| uint32_t partial_result |
>= CAMERA_DEVICE_API_VERSION_3_2:
Para aproveitar os resultados parciais, o HAL precisa definir os metadados estáticos android.request.partialResultCount para o número de resultados parciais que ele vai enviar para cada frame.
Cada novo resultado de captura com um resultado parcial precisa definir esse campo (partial_result) para um valor distinto entre 1 e android.request.partialResultCount.
Os HALs que não quiserem aproveitar esse recurso não podem definir um android.request.partialResultCount ou partial_result para um valor diferente de 1.
Esse valor precisa ser definido como 0 quando um resultado de captura contém apenas buffers e nenhum metadado.
| const camera_metadata_t * result |
Os metadados do resultado dessa captura. Ele 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 ativados, e a saída de todas as unidades de estatísticas ativadas.
Apenas uma chamada para process_capture_result() com um frame_number específico pode incluir os metadados do resultado. Todas as outras chamadas para o mesmo frame_number precisam definir esse valor como NULL.
Se houver um erro na geração dos metadados, o resultado será um buffer de metadados vazio, e notify() 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 frame. Cada novo resultado parcial para esse frame também precisa definir um valor de partial_result distinto.
Se o método notify tiver sido chamado com ERROR_RESULT, todos os resultados parciais para esse frame serão ignorados pelo framework.
A documentação desse struct foi gerada com base no seguinte arquivo:
- hardware/libhardware/include/hardware/ camera3.h