hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity
8780219cf2
yuzu/externals/ffmpeg/libavdevice/android_camera.c
pineappleEA 3d5a9d908a early-access version 1432
2021-02-09 04:25:58 +01:00

872 lines
29 KiB
C
Executable File
Raw Blame History

/*
* Android camera input device
*
* Copyright (C) 2017 Felix Matouschek
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <errno.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <stdint.h>
#include <camera/NdkCameraDevice.h>
#include <camera/NdkCameraManager.h>
#include <media/NdkImage.h>
#include <media/NdkImageReader.h>
#include "libavformat/avformat.h"
#include "libavformat/internal.h"
#include "libavutil/avstring.h"
#include "libavutil/display.h"
#include "libavutil/imgutils.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
#include "libavutil/pixfmt.h"
#include "libavutil/threadmessage.h"
#include "libavutil/time.h"
#include "version.h"
/* This image format is available on all Android devices
* supporting the Camera2 API */
#define IMAGE_FORMAT_ANDROID AIMAGE_FORMAT_YUV_420_888
#define MAX_BUF_COUNT 2
#define VIDEO_STREAM_INDEX 0
#define VIDEO_TIMEBASE_ANDROID 1000000000
#define RETURN_CASE(x) case x: return AV_STRINGIFY(x);
#define RETURN_DEFAULT(x) default: return AV_STRINGIFY(x);
typedef struct AndroidCameraCtx {
const AVClass *class;
int requested_width;
int requested_height;
AVRational framerate;
int camera_index;
int input_queue_size;
uint8_t lens_facing;
int32_t sensor_orientation;
int width;
int height;
int32_t framerate_range[2];
int image_format;
ACameraManager *camera_mgr;
char *camera_id;
ACameraMetadata *camera_metadata;
ACameraDevice *camera_dev;
ACameraDevice_StateCallbacks camera_state_callbacks;
AImageReader *image_reader;
AImageReader_ImageListener image_listener;
ANativeWindow *image_reader_window;
ACaptureSessionOutputContainer *capture_session_output_container;
ACaptureSessionOutput *capture_session_output;
ACameraOutputTarget *camera_output_target;
ACaptureRequest *capture_request;
ACameraCaptureSession_stateCallbacks capture_session_state_callbacks;
ACameraCaptureSession *capture_session;
AVThreadMessageQueue *input_queue;
atomic_int exit;
atomic_int got_image_format;
} AndroidCameraCtx;
static const char *camera_status_string(camera_status_t val)
{
switch(val) {
RETURN_CASE(ACAMERA_OK)
RETURN_CASE(ACAMERA_ERROR_UNKNOWN)
RETURN_CASE(ACAMERA_ERROR_INVALID_PARAMETER)
RETURN_CASE(ACAMERA_ERROR_CAMERA_DISCONNECTED)
RETURN_CASE(ACAMERA_ERROR_NOT_ENOUGH_MEMORY)
RETURN_CASE(ACAMERA_ERROR_METADATA_NOT_FOUND)
RETURN_CASE(ACAMERA_ERROR_CAMERA_DEVICE)
RETURN_CASE(ACAMERA_ERROR_CAMERA_SERVICE)
RETURN_CASE(ACAMERA_ERROR_SESSION_CLOSED)
RETURN_CASE(ACAMERA_ERROR_INVALID_OPERATION)
RETURN_CASE(ACAMERA_ERROR_STREAM_CONFIGURE_FAIL)
RETURN_CASE(ACAMERA_ERROR_CAMERA_IN_USE)
RETURN_CASE(ACAMERA_ERROR_MAX_CAMERA_IN_USE)
RETURN_CASE(ACAMERA_ERROR_CAMERA_DISABLED)
RETURN_CASE(ACAMERA_ERROR_PERMISSION_DENIED)
RETURN_DEFAULT(ACAMERA_ERROR_UNKNOWN)
}
}
static const char *media_status_string(media_status_t val)
{
switch(val) {
RETURN_CASE(AMEDIA_OK)
RETURN_CASE(AMEDIA_ERROR_UNKNOWN)
RETURN_CASE(AMEDIA_ERROR_MALFORMED)
RETURN_CASE(AMEDIA_ERROR_UNSUPPORTED)
RETURN_CASE(AMEDIA_ERROR_INVALID_OBJECT)
RETURN_CASE(AMEDIA_ERROR_INVALID_PARAMETER)
RETURN_CASE(AMEDIA_ERROR_INVALID_OPERATION)
RETURN_CASE(AMEDIA_DRM_NOT_PROVISIONED)
RETURN_CASE(AMEDIA_DRM_RESOURCE_BUSY)
RETURN_CASE(AMEDIA_DRM_DEVICE_REVOKED)
RETURN_CASE(AMEDIA_DRM_SHORT_BUFFER)
RETURN_CASE(AMEDIA_DRM_SESSION_NOT_OPENED)
RETURN_CASE(AMEDIA_DRM_TAMPER_DETECTED)
RETURN_CASE(AMEDIA_DRM_VERIFY_FAILED)
RETURN_CASE(AMEDIA_DRM_NEED_KEY)
RETURN_CASE(AMEDIA_DRM_LICENSE_EXPIRED)
RETURN_CASE(AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE)
RETURN_CASE(AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED)
RETURN_CASE(AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE)
RETURN_CASE(AMEDIA_IMGREADER_CANNOT_UNLOCK_IMAGE)
RETURN_CASE(AMEDIA_IMGREADER_IMAGE_NOT_LOCKED)
RETURN_DEFAULT(AMEDIA_ERROR_UNKNOWN)
}
}
static const char *error_state_callback_string(int val)
{
switch(val) {
RETURN_CASE(ERROR_CAMERA_IN_USE)
RETURN_CASE(ERROR_MAX_CAMERAS_IN_USE)
RETURN_CASE(ERROR_CAMERA_DISABLED)
RETURN_CASE(ERROR_CAMERA_DEVICE)
RETURN_CASE(ERROR_CAMERA_SERVICE)
default:
return "ERROR_CAMERA_UNKNOWN";
}
}
static void camera_dev_disconnected(void *context, ACameraDevice *device)
{
AVFormatContext *avctx = context;
AndroidCameraCtx *ctx = avctx->priv_data;
atomic_store(&ctx->exit, 1);
av_log(avctx, AV_LOG_ERROR, "Camera with id %s disconnected.\n",
ACameraDevice_getId(device));
}
static void camera_dev_error(void *context, ACameraDevice *device, int error)
{
AVFormatContext *avctx = context;
AndroidCameraCtx *ctx = avctx->priv_data;
atomic_store(&ctx->exit, 1);
av_log(avctx, AV_LOG_ERROR, "Error %s on camera with id %s.\n",
error_state_callback_string(error), ACameraDevice_getId(device));
}
static int open_camera(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
camera_status_t ret;
ACameraIdList *camera_ids;
ret = ACameraManager_getCameraIdList(ctx->camera_mgr, &camera_ids);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR, "Failed to get camera id list, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
if (ctx->camera_index < camera_ids->numCameras) {
ctx->camera_id = av_strdup(camera_ids->cameraIds[ctx->camera_index]);
if (!ctx->camera_id) {
av_log(avctx, AV_LOG_ERROR, "Failed to allocate memory for camera_id.\n");
return AVERROR(ENOMEM);
}
} else {
av_log(avctx, AV_LOG_ERROR, "No camera with index %d available.\n",
ctx->camera_index);
return AVERROR(ENXIO);
}
ACameraManager_deleteCameraIdList(camera_ids);
ret = ACameraManager_getCameraCharacteristics(ctx->camera_mgr,
ctx->camera_id, &ctx->camera_metadata);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR, "Failed to get metadata for camera with id %s, error: %s.\n",
ctx->camera_id, camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ctx->camera_state_callbacks.context = avctx;
ctx->camera_state_callbacks.onDisconnected = camera_dev_disconnected;
ctx->camera_state_callbacks.onError = camera_dev_error;
ret = ACameraManager_openCamera(ctx->camera_mgr, ctx->camera_id,
&ctx->camera_state_callbacks, &ctx->camera_dev);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR, "Failed to open camera with id %s, error: %s.\n",
ctx->camera_id, camera_status_string(ret));
return AVERROR_EXTERNAL;
}
return 0;
}
static void get_sensor_orientation(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
ACameraMetadata_const_entry lens_facing;
ACameraMetadata_const_entry sensor_orientation;
ACameraMetadata_getConstEntry(ctx->camera_metadata,
ACAMERA_LENS_FACING, &lens_facing);
ACameraMetadata_getConstEntry(ctx->camera_metadata,
ACAMERA_SENSOR_ORIENTATION, &sensor_orientation);
ctx->lens_facing = lens_facing.data.u8[0];
ctx->sensor_orientation = sensor_orientation.data.i32[0];
}
static void match_video_size(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
ACameraMetadata_const_entry available_configs;
int found = 0;
ACameraMetadata_getConstEntry(ctx->camera_metadata,
ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
&available_configs);
for (int i = 0; i < available_configs.count; i++) {
int32_t input = available_configs.data.i32[i * 4 + 3];
int32_t format = available_configs.data.i32[i * 4 + 0];
if (input) {
continue;
}
if (format == IMAGE_FORMAT_ANDROID) {
int32_t width = available_configs.data.i32[i * 4 + 1];
int32_t height = available_configs.data.i32[i * 4 + 2];
//Same ratio
if ((ctx->requested_width == width && ctx->requested_height == height) ||
(ctx->requested_width == height && ctx->requested_height == width)) {
ctx->width = width;
ctx->height = height;
found = 1;
break;
}
}
}
if (!found || ctx->width == 0 || ctx->height == 0) {
ctx->width = available_configs.data.i32[1];
ctx->height = available_configs.data.i32[2];
av_log(avctx, AV_LOG_WARNING,
"Requested video_size %dx%d not available, falling back to %dx%d\n",
ctx->requested_width, ctx->requested_height, ctx->width, ctx->height);
}
return;
}
static void match_framerate(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
ACameraMetadata_const_entry available_framerates;
int found = 0;
int current_best_match = -1;
int requested_framerate = av_q2d(ctx->framerate);
ACameraMetadata_getConstEntry(ctx->camera_metadata,
ACAMERA_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
&available_framerates);
for (int i = 0; i < available_framerates.count; i++) {
int32_t min = available_framerates.data.i32[i * 2 + 0];
int32_t max = available_framerates.data.i32[i * 2 + 1];
if (requested_framerate == max) {
if (min == max) {
ctx->framerate_range[0] = min;
ctx->framerate_range[1] = max;
found = 1;
break;
} else if (current_best_match >= 0) {
int32_t current_best_match_min = available_framerates.data.i32[current_best_match * 2 + 0];
if (min > current_best_match_min) {
current_best_match = i;
}
} else {
current_best_match = i;
}
}
}
if (!found) {
if (current_best_match >= 0) {
ctx->framerate_range[0] = available_framerates.data.i32[current_best_match * 2 + 0];
ctx->framerate_range[1] = available_framerates.data.i32[current_best_match * 2 + 1];
} else {
ctx->framerate_range[0] = available_framerates.data.i32[0];
ctx->framerate_range[1] = available_framerates.data.i32[1];
}
av_log(avctx, AV_LOG_WARNING,
"Requested framerate %d not available, falling back to min: %d and max: %d fps\n",
requested_framerate, ctx->framerate_range[0], ctx->framerate_range[1]);
}
return;
}
static int get_image_format(AVFormatContext *avctx, AImage *image)
{
AndroidCameraCtx *ctx = avctx->priv_data;
int32_t image_pixelstrides[2];
uint8_t *image_plane_data[2];
int plane_data_length[2];
for (int i = 0; i < 2; i++) {
AImage_getPlanePixelStride(image, i + 1, &image_pixelstrides[i]);
AImage_getPlaneData(image, i + 1, &image_plane_data[i], &plane_data_length[i]);
}
if (image_pixelstrides[0] != image_pixelstrides[1]) {
av_log(avctx, AV_LOG_ERROR,
"Pixel strides of U and V plane should have been the same.\n");
return AVERROR_EXTERNAL;
}
switch (image_pixelstrides[0]) {
case 1:
ctx->image_format = AV_PIX_FMT_YUV420P;
break;
case 2:
if (image_plane_data[0] < image_plane_data[1]) {
ctx->image_format = AV_PIX_FMT_NV12;
} else {
ctx->image_format = AV_PIX_FMT_NV21;
}
break;
default:
av_log(avctx, AV_LOG_ERROR,
"Unknown pixel stride %d of U and V plane, cannot determine camera image format.\n",
image_pixelstrides[0]);
return AVERROR(ENOSYS);
}
return 0;
}
static void image_available(void *context, AImageReader *reader)
{
AVFormatContext *avctx = context;
AndroidCameraCtx *ctx = avctx->priv_data;
media_status_t media_status;
int ret = 0;
AImage *image;
int64_t image_timestamp;
int32_t image_linestrides[4];
uint8_t *image_plane_data[4];
int plane_data_length[4];
AVPacket pkt;
int pkt_buffer_size = 0;
media_status = AImageReader_acquireLatestImage(reader, &image);
if (media_status != AMEDIA_OK) {
if (media_status == AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE) {
av_log(avctx, AV_LOG_WARNING,
"An image reader frame was discarded");
} else {
av_log(avctx, AV_LOG_ERROR,
"Failed to acquire latest image from image reader, error: %s.\n",
media_status_string(media_status));
ret = AVERROR_EXTERNAL;
}
goto error;
}
// Silently drop frames when exit is set
if (atomic_load(&ctx->exit)) {
goto error;
}
// Determine actual image format
if (!atomic_load(&ctx->got_image_format)) {
ret = get_image_format(avctx, image);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
"Could not get image format of camera.\n");
goto error;
} else {
atomic_store(&ctx->got_image_format, 1);
}
}
pkt_buffer_size = av_image_get_buffer_size(ctx->image_format, ctx->width, ctx->height, 32);
AImage_getTimestamp(image, &image_timestamp);
AImage_getPlaneRowStride(image, 0, &image_linestrides[0]);
AImage_getPlaneData(image, 0, &image_plane_data[0], &plane_data_length[0]);
switch (ctx->image_format) {
case AV_PIX_FMT_YUV420P:
AImage_getPlaneRowStride(image, 1, &image_linestrides[1]);
AImage_getPlaneData(image, 1, &image_plane_data[1], &plane_data_length[1]);
AImage_getPlaneRowStride(image, 2, &image_linestrides[2]);
AImage_getPlaneData(image, 2, &image_plane_data[2], &plane_data_length[2]);
break;
case AV_PIX_FMT_NV12:
AImage_getPlaneRowStride(image, 1, &image_linestrides[1]);
AImage_getPlaneData(image, 1, &image_plane_data[1], &plane_data_length[1]);
break;
case AV_PIX_FMT_NV21:
AImage_getPlaneRowStride(image, 2, &image_linestrides[1]);
AImage_getPlaneData(image, 2, &image_plane_data[1], &plane_data_length[1]);
break;
default:
av_log(avctx, AV_LOG_ERROR, "Unsupported camera image format.\n");
ret = AVERROR(ENOSYS);
goto error;
}
ret = av_new_packet(&pkt, pkt_buffer_size);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
"Failed to create new av packet, error: %s.\n", av_err2str(ret));
goto error;
}
pkt.stream_index = VIDEO_STREAM_INDEX;
pkt.pts = image_timestamp;
av_image_copy_to_buffer(pkt.data, pkt_buffer_size,
(const uint8_t * const *) image_plane_data,
image_linestrides, ctx->image_format,
ctx->width, ctx->height, 32);
ret = av_thread_message_queue_send(ctx->input_queue, &pkt, AV_THREAD_MESSAGE_NONBLOCK);
error:
if (ret < 0) {
if (ret != AVERROR(EAGAIN)) {
av_log(avctx, AV_LOG_ERROR,
"Error while processing new image, error: %s.\n", av_err2str(ret));
av_thread_message_queue_set_err_recv(ctx->input_queue, ret);
atomic_store(&ctx->exit, 1);
} else {
av_log(avctx, AV_LOG_WARNING,
"Input queue was full, dropping frame, consider raising the input_queue_size option (current value: %d)\n",
ctx->input_queue_size);
}
if (pkt_buffer_size) {
av_packet_unref(&pkt);
}
}
AImage_delete(image);
return;
}
static int create_image_reader(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
media_status_t ret;
ret = AImageReader_new(ctx->width, ctx->height, IMAGE_FORMAT_ANDROID,
MAX_BUF_COUNT, &ctx->image_reader);
if (ret != AMEDIA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to create image reader, error: %s.\n", media_status_string(ret));
return AVERROR_EXTERNAL;
}
ctx->image_listener.context = avctx;
ctx->image_listener.onImageAvailable = image_available;
ret = AImageReader_setImageListener(ctx->image_reader, &ctx->image_listener);
if (ret != AMEDIA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to set image listener on image reader, error: %s.\n",
media_status_string(ret));
return AVERROR_EXTERNAL;
}
ret = AImageReader_getWindow(ctx->image_reader, &ctx->image_reader_window);
if (ret != AMEDIA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Could not get image reader window, error: %s.\n",
media_status_string(ret));
return AVERROR_EXTERNAL;
}
return 0;
}
static void capture_session_closed(void *context, ACameraCaptureSession *session)
{
av_log(context, AV_LOG_INFO, "Android camera capture session was closed.\n");
}
static void capture_session_ready(void *context, ACameraCaptureSession *session)
{
av_log(context, AV_LOG_INFO, "Android camera capture session is ready.\n");
}
static void capture_session_active(void *context, ACameraCaptureSession *session)
{
av_log(context, AV_LOG_INFO, "Android camera capture session is active.\n");
}
static int create_capture_session(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
camera_status_t ret;
ret = ACaptureSessionOutputContainer_create(&ctx->capture_session_output_container);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to create capture session output container, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ANativeWindow_acquire(ctx->image_reader_window);
ret = ACaptureSessionOutput_create(ctx->image_reader_window, &ctx->capture_session_output);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to create capture session container, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ret = ACaptureSessionOutputContainer_add(ctx->capture_session_output_container,
ctx->capture_session_output);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to add output to output container, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ret = ACameraOutputTarget_create(ctx->image_reader_window, &ctx->camera_output_target);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to create camera output target, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ret = ACameraDevice_createCaptureRequest(ctx->camera_dev, TEMPLATE_RECORD, &ctx->capture_request);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to create capture request, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ret = ACaptureRequest_setEntry_i32(ctx->capture_request, ACAMERA_CONTROL_AE_TARGET_FPS_RANGE,
2, ctx->framerate_range);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to set target fps range in capture request, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ret = ACaptureRequest_addTarget(ctx->capture_request, ctx->camera_output_target);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to add capture request capture request, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ctx->capture_session_state_callbacks.context = avctx;
ctx->capture_session_state_callbacks.onClosed = capture_session_closed;
ctx->capture_session_state_callbacks.onReady = capture_session_ready;
ctx->capture_session_state_callbacks.onActive = capture_session_active;
ret = ACameraDevice_createCaptureSession(ctx->camera_dev, ctx->capture_session_output_container,
&ctx->capture_session_state_callbacks, &ctx->capture_session);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to create capture session, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
ret = ACameraCaptureSession_setRepeatingRequest(ctx->capture_session, NULL, 1, &ctx->capture_request, NULL);
if (ret != ACAMERA_OK) {
av_log(avctx, AV_LOG_ERROR,
"Failed to set repeating request on capture session, error: %s.\n",
camera_status_string(ret));
return AVERROR_EXTERNAL;
}
return 0;
}
static int wait_for_image_format(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
while (!atomic_load(&ctx->got_image_format) && !atomic_load(&ctx->exit)) {
//Wait until first frame arrived and actual image format was determined
usleep(1000);
}
return atomic_load(&ctx->got_image_format);
}
static int add_display_matrix(AVFormatContext *avctx, AVStream *st)
{
AndroidCameraCtx *ctx = avctx->priv_data;
uint8_t *side_data;
int32_t display_matrix[9];
av_display_rotation_set(display_matrix, ctx->sensor_orientation);
if (ctx->lens_facing == ACAMERA_LENS_FACING_FRONT) {
av_display_matrix_flip(display_matrix, 1, 0);
}
side_data = av_stream_new_side_data(st,
AV_PKT_DATA_DISPLAYMATRIX, sizeof(display_matrix));
if (!side_data) {
return AVERROR(ENOMEM);
}
memcpy(side_data, display_matrix, sizeof(display_matrix));
return 0;
}
static int add_video_stream(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
AVStream *st;
AVCodecParameters *codecpar;
st = avformat_new_stream(avctx, NULL);
if (!st) {
return AVERROR(ENOMEM);
}
st->id = VIDEO_STREAM_INDEX;
st->avg_frame_rate = (AVRational) { ctx->framerate_range[1], 1 };
st->r_frame_rate = (AVRational) { ctx->framerate_range[1], 1 };
if (!wait_for_image_format(avctx)) {
return AVERROR_EXTERNAL;
}
codecpar = st->codecpar;
codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
codecpar->format = ctx->image_format;
codecpar->width = ctx->width;
codecpar->height = ctx->height;
avpriv_set_pts_info(st, 64, 1, VIDEO_TIMEBASE_ANDROID);
return add_display_matrix(avctx, st);
}
static int android_camera_read_close(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
atomic_store(&ctx->exit, 1);
if (ctx->capture_session) {
ACameraCaptureSession_stopRepeating(ctx->capture_session);
// Following warning is emitted, after capture session closed callback is received:
// ACameraCaptureSession: Device is closed but session 0 is not notified
// Seems to be a bug in Android, we can ignore this
ACameraCaptureSession_close(ctx->capture_session);
ctx->capture_session = NULL;
}
if (ctx->capture_request) {
ACaptureRequest_removeTarget(ctx->capture_request, ctx->camera_output_target);
ACaptureRequest_free(ctx->capture_request);
ctx->capture_request = NULL;
}
if (ctx->camera_output_target) {
ACameraOutputTarget_free(ctx->camera_output_target);
ctx->camera_output_target = NULL;
}
if (ctx->capture_session_output) {
ACaptureSessionOutputContainer_remove(ctx->capture_session_output_container,
ctx->capture_session_output);
ACaptureSessionOutput_free(ctx->capture_session_output);
ctx->capture_session_output = NULL;
}
if (ctx->image_reader_window) {
ANativeWindow_release(ctx->image_reader_window);
ctx->image_reader_window = NULL;
}
if (ctx->capture_session_output_container) {
ACaptureSessionOutputContainer_free(ctx->capture_session_output_container);
ctx->capture_session_output_container = NULL;
}
if (ctx->camera_dev) {
ACameraDevice_close(ctx->camera_dev);
ctx->camera_dev = NULL;
}
if (ctx->image_reader) {
AImageReader_delete(ctx->image_reader);
ctx->image_reader = NULL;
}
if (ctx->camera_metadata) {
ACameraMetadata_free(ctx->camera_metadata);
ctx->camera_metadata = NULL;
}
av_freep(&ctx->camera_id);
if (ctx->camera_mgr) {
ACameraManager_delete(ctx->camera_mgr);
ctx->camera_mgr = NULL;
}
if (ctx->input_queue) {
AVPacket pkt;
av_thread_message_queue_set_err_send(ctx->input_queue, AVERROR_EOF);
while (av_thread_message_queue_recv(ctx->input_queue, &pkt, AV_THREAD_MESSAGE_NONBLOCK) >= 0) {
av_packet_unref(&pkt);
}
av_thread_message_queue_free(&ctx->input_queue);
}
return 0;
}
static int android_camera_read_header(AVFormatContext *avctx)
{
AndroidCameraCtx *ctx = avctx->priv_data;
int ret;
atomic_init(&ctx->got_image_format, 0);
atomic_init(&ctx->exit, 0);
ret = av_thread_message_queue_alloc(&ctx->input_queue, ctx->input_queue_size, sizeof(AVPacket));
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
"Failed to allocate input queue, error: %s.\n", av_err2str(ret));
goto error;
}
ctx->camera_mgr = ACameraManager_create();
if (!ctx->camera_mgr) {
av_log(avctx, AV_LOG_ERROR, "Failed to create Android camera manager.\n");
ret = AVERROR_EXTERNAL;
goto error;
}
ret = open_camera(avctx);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to open camera.\n");
goto error;
}
get_sensor_orientation(avctx);
match_video_size(avctx);
match_framerate(avctx);
ret = create_image_reader(avctx);
if (ret < 0) {
goto error;
}
ret = create_capture_session(avctx);
if (ret < 0) {
goto error;
}
ret = add_video_stream(avctx);
error:
if (ret < 0) {
android_camera_read_close(avctx);
av_log(avctx, AV_LOG_ERROR, "Failed to open android_camera.\n");
}
return ret;
}
static int android_camera_read_packet(AVFormatContext *avctx, AVPacket *pkt)
{
AndroidCameraCtx *ctx = avctx->priv_data;
int ret;
if (!atomic_load(&ctx->exit)) {
ret = av_thread_message_queue_recv(ctx->input_queue, pkt,
avctx->flags & AVFMT_FLAG_NONBLOCK ? AV_THREAD_MESSAGE_NONBLOCK : 0);
} else {
ret = AVERROR_EOF;
}
if (ret < 0) {
return ret;
} else {
return pkt->size;
}
}
#define OFFSET(x) offsetof(AndroidCameraCtx, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
{ "video_size", "set video size given as a string such as 640x480 or hd720", OFFSET(requested_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC },
{ "framerate", "set video frame rate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "30"}, 0, INT_MAX, DEC },
{ "camera_index", "set index of camera to use", OFFSET(camera_index), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC },
{ "input_queue_size", "set maximum number of frames to buffer", OFFSET(input_queue_size), AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, DEC },
{ NULL },
};
static const AVClass android_camera_class = {
.class_name = "android_camera indev",
.item_name = av_default_item_name,
.option = options,
.version = LIBAVUTIL_VERSION_INT,
.category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
};
AVInputFormat ff_android_camera_demuxer = {
.name = "android_camera",
.long_name = NULL_IF_CONFIG_SMALL("Android camera input device"),
.priv_data_size = sizeof(AndroidCameraCtx),
.read_header = android_camera_read_header,
.read_packet = android_camera_read_packet,
.read_close = android_camera_read_close,
.flags = AVFMT_NOFILE,
.priv_class = &android_camera_class,
};
Reference in New Issue View Git Blame Copy Permalink