git.sesse.net Git - ffmpeg/blob - libavdevice/android_camera.c

   1 /*
   2  * Android camera input device
   3  *
   4  * Copyright (C) 2017 Felix Matouschek
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include <errno.h>
  24 #include <pthread.h>
  25 #include <stdatomic.h>
  26 #include <stdbool.h>
  27 #include <stdint.h>
  28
  29 #include <camera/NdkCameraDevice.h>
  30 #include <camera/NdkCameraManager.h>
  31 #include <media/NdkImage.h>
  32 #include <media/NdkImageReader.h>
  33
  34 #include "libavformat/avformat.h"
  35 #include "libavformat/internal.h"
  36 #include "libavutil/avstring.h"
  37 #include "libavutil/display.h"
  38 #include "libavutil/imgutils.h"
  39 #include "libavutil/log.h"
  40 #include "libavutil/opt.h"
  41 #include "libavutil/parseutils.h"
  42 #include "libavutil/pixfmt.h"
  43 #include "libavutil/threadmessage.h"
  44 #include "libavutil/time.h"
  45
  46 #include "version.h"
  47
  48 /* This image format is available on all Android devices
  49  * supporting the Camera2 API */
  50 #define IMAGE_FORMAT_ANDROID AIMAGE_FORMAT_YUV_420_888
  51
  52 #define MAX_BUF_COUNT 2
  53 #define VIDEO_STREAM_INDEX 0
  54 #define VIDEO_TIMEBASE_ANDROID 1000000000
  55
  56 #define RETURN_CASE(x) case x: return AV_STRINGIFY(x);
  57 #define RETURN_DEFAULT(x) default: return AV_STRINGIFY(x);
  58
  59 typedef struct AndroidCameraCtx {
  60     const AVClass *class;
  61
  62     int requested_width;
  63     int requested_height;
  64     AVRational framerate;
  65     int camera_index;
  66     int input_queue_size;
  67
  68     uint8_t lens_facing;
  69     int32_t sensor_orientation;
  70     int width;
  71     int height;
  72     int32_t framerate_range[2];
  73     int image_format;
  74
  75     ACameraManager *camera_mgr;
  76     char *camera_id;
  77     ACameraMetadata *camera_metadata;
  78     ACameraDevice *camera_dev;
  79     ACameraDevice_StateCallbacks camera_state_callbacks;
  80     AImageReader *image_reader;
  81     AImageReader_ImageListener image_listener;
  82     ANativeWindow *image_reader_window;
  83     ACaptureSessionOutputContainer *capture_session_output_container;
  84     ACaptureSessionOutput *capture_session_output;
  85     ACameraOutputTarget *camera_output_target;
  86     ACaptureRequest *capture_request;
  87     ACameraCaptureSession_stateCallbacks capture_session_state_callbacks;
  88     ACameraCaptureSession *capture_session;
  89
  90     AVThreadMessageQueue *input_queue;
  91     atomic_int exit;
  92     atomic_int got_image_format;
  93 } AndroidCameraCtx;
  94
  95 static const char *camera_status_string(camera_status_t val)
  96 {
  97     switch(val) {
  98         RETURN_CASE(ACAMERA_OK)
  99         RETURN_CASE(ACAMERA_ERROR_UNKNOWN)
 100         RETURN_CASE(ACAMERA_ERROR_INVALID_PARAMETER)
 101         RETURN_CASE(ACAMERA_ERROR_CAMERA_DISCONNECTED)
 102         RETURN_CASE(ACAMERA_ERROR_NOT_ENOUGH_MEMORY)
 103         RETURN_CASE(ACAMERA_ERROR_METADATA_NOT_FOUND)
 104         RETURN_CASE(ACAMERA_ERROR_CAMERA_DEVICE)
 105         RETURN_CASE(ACAMERA_ERROR_CAMERA_SERVICE)
 106         RETURN_CASE(ACAMERA_ERROR_SESSION_CLOSED)
 107         RETURN_CASE(ACAMERA_ERROR_INVALID_OPERATION)
 108         RETURN_CASE(ACAMERA_ERROR_STREAM_CONFIGURE_FAIL)
 109         RETURN_CASE(ACAMERA_ERROR_CAMERA_IN_USE)
 110         RETURN_CASE(ACAMERA_ERROR_MAX_CAMERA_IN_USE)
 111         RETURN_CASE(ACAMERA_ERROR_CAMERA_DISABLED)
 112         RETURN_CASE(ACAMERA_ERROR_PERMISSION_DENIED)
 113         RETURN_DEFAULT(ACAMERA_ERROR_UNKNOWN)
 114     }
 115 }
 116
 117 static const char *media_status_string(media_status_t val)
 118 {
 119     switch(val) {
 120         RETURN_CASE(AMEDIA_OK)
 121         RETURN_CASE(AMEDIA_ERROR_UNKNOWN)
 122         RETURN_CASE(AMEDIA_ERROR_MALFORMED)
 123         RETURN_CASE(AMEDIA_ERROR_UNSUPPORTED)
 124         RETURN_CASE(AMEDIA_ERROR_INVALID_OBJECT)
 125         RETURN_CASE(AMEDIA_ERROR_INVALID_PARAMETER)
 126         RETURN_CASE(AMEDIA_ERROR_INVALID_OPERATION)
 127         RETURN_CASE(AMEDIA_DRM_NOT_PROVISIONED)
 128         RETURN_CASE(AMEDIA_DRM_RESOURCE_BUSY)
 129         RETURN_CASE(AMEDIA_DRM_DEVICE_REVOKED)
 130         RETURN_CASE(AMEDIA_DRM_SHORT_BUFFER)
 131         RETURN_CASE(AMEDIA_DRM_SESSION_NOT_OPENED)
 132         RETURN_CASE(AMEDIA_DRM_TAMPER_DETECTED)
 133         RETURN_CASE(AMEDIA_DRM_VERIFY_FAILED)
 134         RETURN_CASE(AMEDIA_DRM_NEED_KEY)
 135         RETURN_CASE(AMEDIA_DRM_LICENSE_EXPIRED)
 136         RETURN_CASE(AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE)
 137         RETURN_CASE(AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED)
 138         RETURN_CASE(AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE)
 139         RETURN_CASE(AMEDIA_IMGREADER_CANNOT_UNLOCK_IMAGE)
 140         RETURN_CASE(AMEDIA_IMGREADER_IMAGE_NOT_LOCKED)
 141         RETURN_DEFAULT(AMEDIA_ERROR_UNKNOWN)
 142     }
 143 }
 144
 145 static const char *error_state_callback_string(int val)
 146 {
 147     switch(val) {
 148         RETURN_CASE(ERROR_CAMERA_IN_USE)
 149         RETURN_CASE(ERROR_MAX_CAMERAS_IN_USE)
 150         RETURN_CASE(ERROR_CAMERA_DISABLED)
 151         RETURN_CASE(ERROR_CAMERA_DEVICE)
 152         RETURN_CASE(ERROR_CAMERA_SERVICE)
 153         default:
 154             return "ERROR_CAMERA_UNKNOWN";
 155     }
 156 }
 157
 158 static void camera_dev_disconnected(void *context, ACameraDevice *device)
 159 {
 160     AVFormatContext *avctx = context;
 161     AndroidCameraCtx *ctx = avctx->priv_data;
 162     atomic_store(&ctx->exit, 1);
 163     av_log(avctx, AV_LOG_ERROR, "Camera with id %s disconnected.\n",
 164            ACameraDevice_getId(device));
 165 }
 166
 167 static void camera_dev_error(void *context, ACameraDevice *device, int error)
 168 {
 169     AVFormatContext *avctx = context;
 170     AndroidCameraCtx *ctx = avctx->priv_data;
 171     atomic_store(&ctx->exit, 1);
 172     av_log(avctx, AV_LOG_ERROR, "Error %s on camera with id %s.\n",
 173            error_state_callback_string(error), ACameraDevice_getId(device));
 174 }
 175
 176 static int open_camera(AVFormatContext *avctx)
 177 {
 178     AndroidCameraCtx *ctx = avctx->priv_data;
 179     camera_status_t ret;
 180     ACameraIdList *camera_ids;
 181
 182     ret = ACameraManager_getCameraIdList(ctx->camera_mgr, &camera_ids);
 183     if (ret != ACAMERA_OK) {
 184         av_log(avctx, AV_LOG_ERROR, "Failed to get camera id list, error: %s.\n",
 185                camera_status_string(ret));
 186         return AVERROR_EXTERNAL;
 187     }
 188
 189     if (ctx->camera_index < camera_ids->numCameras) {
 190         ctx->camera_id = av_strdup(camera_ids->cameraIds[ctx->camera_index]);
 191         if (!ctx->camera_id) {
 192             av_log(avctx, AV_LOG_ERROR, "Failed to allocate memory for camera_id.\n");
 193             return AVERROR(ENOMEM);
 194         }
 195     } else {
 196         av_log(avctx, AV_LOG_ERROR, "No camera with index %d available.\n",
 197                ctx->camera_index);
 198         return AVERROR(ENXIO);
 199     }
 200
 201     ACameraManager_deleteCameraIdList(camera_ids);
 202
 203     ret = ACameraManager_getCameraCharacteristics(ctx->camera_mgr,
 204             ctx->camera_id, &ctx->camera_metadata);
 205     if (ret != ACAMERA_OK) {
 206         av_log(avctx, AV_LOG_ERROR, "Failed to get metadata for camera with id %s, error: %s.\n",
 207                ctx->camera_id, camera_status_string(ret));
 208         return AVERROR_EXTERNAL;
 209     }
 210
 211     ctx->camera_state_callbacks.context = avctx;
 212     ctx->camera_state_callbacks.onDisconnected = camera_dev_disconnected;
 213     ctx->camera_state_callbacks.onError = camera_dev_error;
 214
 215     ret = ACameraManager_openCamera(ctx->camera_mgr, ctx->camera_id,
 216                                     &ctx->camera_state_callbacks, &ctx->camera_dev);
 217     if (ret != ACAMERA_OK) {
 218         av_log(avctx, AV_LOG_ERROR, "Failed to open camera with id %s, error: %s.\n",
 219                ctx->camera_id, camera_status_string(ret));
 220         return AVERROR_EXTERNAL;
 221     }
 222
 223     return 0;
 224 }
 225
 226 static void get_sensor_orientation(AVFormatContext *avctx)
 227 {
 228     AndroidCameraCtx *ctx = avctx->priv_data;
 229     ACameraMetadata_const_entry lens_facing;
 230     ACameraMetadata_const_entry sensor_orientation;
 231
 232     ACameraMetadata_getConstEntry(ctx->camera_metadata,
 233                                   ACAMERA_LENS_FACING, &lens_facing);
 234     ACameraMetadata_getConstEntry(ctx->camera_metadata,
 235                                   ACAMERA_SENSOR_ORIENTATION, &sensor_orientation);
 236
 237     ctx->lens_facing = lens_facing.data.u8[0];
 238     ctx->sensor_orientation = sensor_orientation.data.i32[0];
 239 }
 240
 241 static void match_video_size(AVFormatContext *avctx)
 242 {
 243     AndroidCameraCtx *ctx = avctx->priv_data;
 244     ACameraMetadata_const_entry available_configs;
 245     int found = 0;
 246
 247     ACameraMetadata_getConstEntry(ctx->camera_metadata,
 248                                   ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
 249                                   &available_configs);
 250
 251     for (int i = 0; i < available_configs.count; i++) {
 252         int32_t input = available_configs.data.i32[i * 4 + 3];
 253         int32_t format = available_configs.data.i32[i * 4 + 0];
 254
 255         if (input) {
 256             continue;
 257         }
 258
 259         if (format == IMAGE_FORMAT_ANDROID) {
 260             int32_t width = available_configs.data.i32[i * 4 + 1];
 261             int32_t height = available_configs.data.i32[i * 4 + 2];
 262
 263             //Same ratio
 264             if ((ctx->requested_width == width && ctx->requested_height == height) ||
 265                     (ctx->requested_width == height && ctx->requested_height == width)) {
 266                 ctx->width = width;
 267                 ctx->height = height;
 268                 found = 1;
 269                 break;
 270             }
 271         }
 272     }
 273
 274     if (!found || ctx->width == 0 || ctx->height == 0) {
 275         ctx->width = available_configs.data.i32[1];
 276         ctx->height = available_configs.data.i32[2];
 277
 278         av_log(avctx, AV_LOG_WARNING,
 279                "Requested video_size %dx%d not available, falling back to %dx%d\n",
 280                ctx->requested_width, ctx->requested_height, ctx->width, ctx->height);
 281     }
 282
 283     return;
 284 }
 285
 286 static void match_framerate(AVFormatContext *avctx)
 287 {
 288     AndroidCameraCtx *ctx = avctx->priv_data;
 289     ACameraMetadata_const_entry available_framerates;
 290     int found = 0;
 291     int current_best_match = -1;
 292     int requested_framerate = av_q2d(ctx->framerate);
 293
 294     ACameraMetadata_getConstEntry(ctx->camera_metadata,
 295                                   ACAMERA_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
 296                                   &available_framerates);
 297
 298     for (int i = 0; i < available_framerates.count; i++) {
 299         int32_t min = available_framerates.data.i32[i * 2 + 0];
 300         int32_t max = available_framerates.data.i32[i * 2 + 1];
 301
 302         if (requested_framerate == max) {
 303             if (min == max) {
 304                 ctx->framerate_range[0] = min;
 305                 ctx->framerate_range[1] = max;
 306                 found = 1;
 307                 break;
 308             } else if (current_best_match >= 0) {
 309                 int32_t current_best_match_min = available_framerates.data.i32[current_best_match * 2 + 0];
 310                 if (min > current_best_match_min) {
 311                     current_best_match = i;
 312                 }
 313             } else {
 314                 current_best_match = i;
 315             }
 316         }
 317     }
 318
 319     if (!found) {
 320         if (current_best_match >= 0) {
 321             ctx->framerate_range[0] = available_framerates.data.i32[current_best_match * 2 + 0];
 322             ctx->framerate_range[1] = available_framerates.data.i32[current_best_match * 2 + 1];
 323
 324         } else {
 325             ctx->framerate_range[0] = available_framerates.data.i32[0];
 326             ctx->framerate_range[1] = available_framerates.data.i32[1];
 327         }
 328
 329         av_log(avctx, AV_LOG_WARNING,
 330                "Requested framerate %d not available, falling back to min: %d and max: %d fps\n",
 331                requested_framerate, ctx->framerate_range[0], ctx->framerate_range[1]);
 332     }
 333
 334     return;
 335 }
 336
 337 static int get_image_format(AVFormatContext *avctx, AImage *image)
 338 {
 339     AndroidCameraCtx *ctx = avctx->priv_data;
 340     int32_t image_pixelstrides[2];
 341     uint8_t *image_plane_data[2];
 342     int plane_data_length[2];
 343
 344     for (int i = 0; i < 2; i++) {
 345         AImage_getPlanePixelStride(image, i + 1, &image_pixelstrides[i]);
 346         AImage_getPlaneData(image, i + 1, &image_plane_data[i], &plane_data_length[i]);
 347     }
 348
 349     if (image_pixelstrides[0] != image_pixelstrides[1]) {
 350         av_log(avctx, AV_LOG_ERROR,
 351                "Pixel strides of U and V plane should have been the same.\n");
 352         return AVERROR_EXTERNAL;
 353     }
 354
 355     switch (image_pixelstrides[0]) {
 356         case 1:
 357             ctx->image_format = AV_PIX_FMT_YUV420P;
 358             break;
 359         case 2:
 360             if (image_plane_data[0] < image_plane_data[1]) {
 361                 ctx->image_format = AV_PIX_FMT_NV12;
 362             } else {
 363                 ctx->image_format = AV_PIX_FMT_NV21;
 364             }
 365             break;
 366         default:
 367             av_log(avctx, AV_LOG_ERROR,
 368                    "Unknown pixel stride %d of U and V plane, cannot determine camera image format.\n",
 369                    image_pixelstrides[0]);
 370             return AVERROR(ENOSYS);
 371     }
 372
 373     return 0;
 374 }
 375
 376 static void image_available(void *context, AImageReader *reader)
 377 {
 378     AVFormatContext *avctx = context;
 379     AndroidCameraCtx *ctx = avctx->priv_data;
 380     media_status_t media_status;
 381     int ret = 0;
 382
 383     AImage *image;
 384     int64_t image_timestamp;
 385     int32_t image_linestrides[4];
 386     uint8_t *image_plane_data[4];
 387     int plane_data_length[4];
 388
 389     AVPacket pkt;
 390     int pkt_buffer_size = 0;
 391
 392     media_status = AImageReader_acquireLatestImage(reader, &image);
 393     if (media_status != AMEDIA_OK) {
 394         if (media_status == AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE) {
 395             av_log(avctx, AV_LOG_WARNING,
 396                    "An image reader frame was discarded");
 397         } else {
 398             av_log(avctx, AV_LOG_ERROR,
 399                    "Failed to acquire latest image from image reader, error: %s.\n",
 400                    media_status_string(media_status));
 401             ret = AVERROR_EXTERNAL;
 402         }
 403         goto error;
 404     }
 405
 406     // Silently drop frames when exit is set
 407     if (atomic_load(&ctx->exit)) {
 408         goto error;
 409     }
 410
 411     // Determine actual image format
 412     if (!atomic_load(&ctx->got_image_format)) {
 413         ret = get_image_format(avctx, image);
 414         if (ret < 0) {
 415             av_log(avctx, AV_LOG_ERROR,
 416                    "Could not get image format of camera.\n");
 417             goto error;
 418         } else {
 419             atomic_store(&ctx->got_image_format, 1);
 420         }
 421     }
 422
 423     pkt_buffer_size = av_image_get_buffer_size(ctx->image_format, ctx->width, ctx->height, 32);
 424     AImage_getTimestamp(image, &image_timestamp);
 425
 426     AImage_getPlaneRowStride(image, 0, &image_linestrides[0]);
 427     AImage_getPlaneData(image, 0, &image_plane_data[0], &plane_data_length[0]);
 428
 429     switch (ctx->image_format) {
 430         case AV_PIX_FMT_YUV420P:
 431             AImage_getPlaneRowStride(image, 1, &image_linestrides[1]);
 432             AImage_getPlaneData(image, 1, &image_plane_data[1], &plane_data_length[1]);
 433             AImage_getPlaneRowStride(image, 2, &image_linestrides[2]);
 434             AImage_getPlaneData(image, 2, &image_plane_data[2], &plane_data_length[2]);
 435             break;
 436         case AV_PIX_FMT_NV12:
 437             AImage_getPlaneRowStride(image, 1, &image_linestrides[1]);
 438             AImage_getPlaneData(image, 1, &image_plane_data[1], &plane_data_length[1]);
 439             break;
 440         case AV_PIX_FMT_NV21:
 441             AImage_getPlaneRowStride(image, 2, &image_linestrides[1]);
 442             AImage_getPlaneData(image, 2, &image_plane_data[1], &plane_data_length[1]);
 443             break;
 444         default:
 445             av_log(avctx, AV_LOG_ERROR, "Unsupported camera image format.\n");
 446             ret = AVERROR(ENOSYS);
 447             goto error;
 448     }
 449
 450     ret = av_new_packet(&pkt, pkt_buffer_size);
 451     if (ret < 0) {
 452         av_log(avctx, AV_LOG_ERROR,
 453                "Failed to create new av packet, error: %s.\n", av_err2str(ret));
 454         goto error;
 455     }
 456
 457     pkt.stream_index = VIDEO_STREAM_INDEX;
 458     pkt.pts = image_timestamp;
 459     av_image_copy_to_buffer(pkt.data, pkt_buffer_size,
 460                             (const uint8_t * const *) image_plane_data,
 461                             image_linestrides, ctx->image_format,
 462                             ctx->width, ctx->height, 32);
 463
 464     ret = av_thread_message_queue_send(ctx->input_queue, &pkt, AV_THREAD_MESSAGE_NONBLOCK);
 465
 466 error:
 467     if (ret < 0) {
 468         if (ret != AVERROR(EAGAIN)) {
 469             av_log(avctx, AV_LOG_ERROR,
 470                    "Error while processing new image, error: %s.\n", av_err2str(ret));
 471             av_thread_message_queue_set_err_recv(ctx->input_queue, ret);
 472             atomic_store(&ctx->exit, 1);
 473         } else {
 474             av_log(avctx, AV_LOG_WARNING,
 475                    "Input queue was full, dropping frame, consider raising the input_queue_size option (current value: %d)\n",
 476                    ctx->input_queue_size);
 477         }
 478         if (pkt_buffer_size) {
 479             av_packet_unref(&pkt);
 480         }
 481     }
 482
 483     AImage_delete(image);
 484
 485     return;
 486 }
 487
 488 static int create_image_reader(AVFormatContext *avctx)
 489 {
 490     AndroidCameraCtx *ctx = avctx->priv_data;
 491     media_status_t ret;
 492
 493     ret = AImageReader_new(ctx->width, ctx->height, IMAGE_FORMAT_ANDROID,
 494                            MAX_BUF_COUNT, &ctx->image_reader);
 495     if (ret != AMEDIA_OK) {
 496         av_log(avctx, AV_LOG_ERROR,
 497                "Failed to create image reader, error: %s.\n", media_status_string(ret));
 498         return AVERROR_EXTERNAL;
 499     }
 500
 501     ctx->image_listener.context = avctx;
 502     ctx->image_listener.onImageAvailable = image_available;
 503
 504     ret = AImageReader_setImageListener(ctx->image_reader, &ctx->image_listener);
 505     if (ret != AMEDIA_OK) {
 506         av_log(avctx, AV_LOG_ERROR,
 507                "Failed to set image listener on image reader, error: %s.\n",
 508                media_status_string(ret));
 509         return AVERROR_EXTERNAL;
 510     }
 511
 512     ret = AImageReader_getWindow(ctx->image_reader, &ctx->image_reader_window);
 513     if (ret != AMEDIA_OK) {
 514         av_log(avctx, AV_LOG_ERROR,
 515                "Could not get image reader window, error: %s.\n",
 516                media_status_string(ret));
 517         return AVERROR_EXTERNAL;
 518     }
 519
 520     return 0;
 521 }
 522
 523 static void capture_session_closed(void *context, ACameraCaptureSession *session)
 524 {
 525     av_log(context, AV_LOG_INFO, "Android camera capture session was closed.\n");
 526 }
 527
 528 static void capture_session_ready(void *context, ACameraCaptureSession *session)
 529 {
 530     av_log(context, AV_LOG_INFO, "Android camera capture session is ready.\n");
 531 }
 532
 533 static void capture_session_active(void *context, ACameraCaptureSession *session)
 534 {
 535     av_log(context, AV_LOG_INFO, "Android camera capture session is active.\n");
 536 }
 537
 538 static int create_capture_session(AVFormatContext *avctx)
 539 {
 540     AndroidCameraCtx *ctx = avctx->priv_data;
 541     camera_status_t ret;
 542
 543     ret = ACaptureSessionOutputContainer_create(&ctx->capture_session_output_container);
 544     if (ret != ACAMERA_OK) {
 545         av_log(avctx, AV_LOG_ERROR,
 546                "Failed to create capture session output container, error: %s.\n",
 547                camera_status_string(ret));
 548         return AVERROR_EXTERNAL;
 549     }
 550
 551     ANativeWindow_acquire(ctx->image_reader_window);
 552
 553     ret = ACaptureSessionOutput_create(ctx->image_reader_window, &ctx->capture_session_output);
 554     if (ret != ACAMERA_OK) {
 555         av_log(avctx, AV_LOG_ERROR,
 556                "Failed to create capture session container, error: %s.\n",
 557                camera_status_string(ret));
 558         return AVERROR_EXTERNAL;
 559     }
 560
 561     ret = ACaptureSessionOutputContainer_add(ctx->capture_session_output_container,
 562                                              ctx->capture_session_output);
 563     if (ret != ACAMERA_OK) {
 564         av_log(avctx, AV_LOG_ERROR,
 565                "Failed to add output to output container, error: %s.\n",
 566                camera_status_string(ret));
 567         return AVERROR_EXTERNAL;
 568     }
 569
 570     ret = ACameraOutputTarget_create(ctx->image_reader_window, &ctx->camera_output_target);
 571     if (ret != ACAMERA_OK) {
 572         av_log(avctx, AV_LOG_ERROR,
 573                "Failed to create camera output target, error: %s.\n",
 574                camera_status_string(ret));
 575         return AVERROR_EXTERNAL;
 576     }
 577
 578     ret = ACameraDevice_createCaptureRequest(ctx->camera_dev, TEMPLATE_RECORD, &ctx->capture_request);
 579     if (ret != ACAMERA_OK) {
 580         av_log(avctx, AV_LOG_ERROR,
 581                "Failed to create capture request, error: %s.\n",
 582                camera_status_string(ret));
 583         return AVERROR_EXTERNAL;
 584     }
 585
 586     ret = ACaptureRequest_setEntry_i32(ctx->capture_request, ACAMERA_CONTROL_AE_TARGET_FPS_RANGE,
 587                                        2, ctx->framerate_range);
 588     if (ret != ACAMERA_OK) {
 589         av_log(avctx, AV_LOG_ERROR,
 590                "Failed to set target fps range in capture request, error: %s.\n",
 591                camera_status_string(ret));
 592         return AVERROR_EXTERNAL;
 593     }
 594
 595     ret = ACaptureRequest_addTarget(ctx->capture_request, ctx->camera_output_target);
 596     if (ret != ACAMERA_OK) {
 597         av_log(avctx, AV_LOG_ERROR,
 598                "Failed to add capture request capture request, error: %s.\n",
 599                camera_status_string(ret));
 600         return AVERROR_EXTERNAL;
 601     }
 602
 603     ctx->capture_session_state_callbacks.context = avctx;
 604     ctx->capture_session_state_callbacks.onClosed = capture_session_closed;
 605     ctx->capture_session_state_callbacks.onReady = capture_session_ready;
 606     ctx->capture_session_state_callbacks.onActive = capture_session_active;
 607
 608     ret = ACameraDevice_createCaptureSession(ctx->camera_dev, ctx->capture_session_output_container,
 609                                              &ctx->capture_session_state_callbacks, &ctx->capture_session);
 610     if (ret != ACAMERA_OK) {
 611         av_log(avctx, AV_LOG_ERROR,
 612                "Failed to create capture session, error: %s.\n",
 613                camera_status_string(ret));
 614         return AVERROR_EXTERNAL;
 615     }
 616
 617     ret = ACameraCaptureSession_setRepeatingRequest(ctx->capture_session, NULL, 1, &ctx->capture_request, NULL);
 618     if (ret != ACAMERA_OK) {
 619         av_log(avctx, AV_LOG_ERROR,
 620                "Failed to set repeating request on capture session, error: %s.\n",
 621                camera_status_string(ret));
 622         return AVERROR_EXTERNAL;
 623     }
 624
 625     return 0;
 626 }
 627
 628 static int wait_for_image_format(AVFormatContext *avctx)
 629 {
 630     AndroidCameraCtx *ctx = avctx->priv_data;
 631
 632     while (!atomic_load(&ctx->got_image_format) && !atomic_load(&ctx->exit)) {
 633         //Wait until first frame arrived and actual image format was determined
 634         usleep(1000);
 635     }
 636
 637     return atomic_load(&ctx->got_image_format);
 638 }
 639
 640 static int add_display_matrix(AVFormatContext *avctx, AVStream *st)
 641 {
 642     AndroidCameraCtx *ctx = avctx->priv_data;
 643     uint8_t *side_data;
 644     int32_t display_matrix[9];
 645
 646     av_display_rotation_set(display_matrix, ctx->sensor_orientation);
 647
 648     if (ctx->lens_facing == ACAMERA_LENS_FACING_FRONT) {
 649         av_display_matrix_flip(display_matrix, 1, 0);
 650     }
 651
 652     side_data = av_stream_new_side_data(st,
 653             AV_PKT_DATA_DISPLAYMATRIX, sizeof(display_matrix));
 654
 655     if (!side_data) {
 656         return AVERROR(ENOMEM);
 657     }
 658
 659     memcpy(side_data, display_matrix, sizeof(display_matrix));
 660
 661     return 0;
 662 }
 663
 664 static int add_video_stream(AVFormatContext *avctx)
 665 {
 666     AndroidCameraCtx *ctx = avctx->priv_data;
 667     AVStream *st;
 668     AVCodecParameters *codecpar;
 669
 670     st = avformat_new_stream(avctx, NULL);
 671     if (!st) {
 672         return AVERROR(ENOMEM);
 673     }
 674
 675     st->id = VIDEO_STREAM_INDEX;
 676     st->avg_frame_rate = (AVRational) { ctx->framerate_range[1], 1 };
 677     st->r_frame_rate = (AVRational) { ctx->framerate_range[1], 1 };
 678
 679     if (!wait_for_image_format(avctx)) {
 680         return AVERROR_EXTERNAL;
 681     }
 682
 683     codecpar = st->codecpar;
 684     codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 685     codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
 686     codecpar->format = ctx->image_format;
 687     codecpar->width = ctx->width;
 688     codecpar->height = ctx->height;
 689
 690     avpriv_set_pts_info(st, 64, 1, VIDEO_TIMEBASE_ANDROID);
 691
 692     return add_display_matrix(avctx, st);
 693 }
 694
 695 static int android_camera_read_close(AVFormatContext *avctx)
 696 {
 697     AndroidCameraCtx *ctx = avctx->priv_data;
 698
 699     atomic_store(&ctx->exit, 1);
 700
 701     if (ctx->capture_session) {
 702         ACameraCaptureSession_stopRepeating(ctx->capture_session);
 703         // Following warning is emitted, after capture session closed callback is received:
 704         // ACameraCaptureSession: Device is closed but session 0 is not notified
 705         // Seems to be a bug in Android, we can ignore this
 706         ACameraCaptureSession_close(ctx->capture_session);
 707         ctx->capture_session = NULL;
 708     }
 709
 710     if (ctx->capture_request) {
 711         ACaptureRequest_removeTarget(ctx->capture_request, ctx->camera_output_target);
 712         ACaptureRequest_free(ctx->capture_request);
 713         ctx->capture_request = NULL;
 714     }
 715
 716     if (ctx->camera_output_target) {
 717         ACameraOutputTarget_free(ctx->camera_output_target);
 718         ctx->camera_output_target = NULL;
 719     }
 720
 721     if (ctx->capture_session_output) {
 722         ACaptureSessionOutputContainer_remove(ctx->capture_session_output_container,
 723                 ctx->capture_session_output);
 724         ACaptureSessionOutput_free(ctx->capture_session_output);
 725         ctx->capture_session_output = NULL;
 726     }
 727
 728     if (ctx->image_reader_window) {
 729         ANativeWindow_release(ctx->image_reader_window);
 730         ctx->image_reader_window = NULL;
 731     }
 732
 733     if (ctx->capture_session_output_container) {
 734         ACaptureSessionOutputContainer_free(ctx->capture_session_output_container);
 735         ctx->capture_session_output_container = NULL;
 736     }
 737
 738     if (ctx->camera_dev) {
 739         ACameraDevice_close(ctx->camera_dev);
 740         ctx->camera_dev = NULL;
 741     }
 742
 743     if (ctx->image_reader) {
 744         AImageReader_delete(ctx->image_reader);
 745         ctx->image_reader = NULL;
 746     }
 747
 748     if (ctx->camera_metadata) {
 749         ACameraMetadata_free(ctx->camera_metadata);
 750         ctx->camera_metadata = NULL;
 751     }
 752
 753     av_freep(&ctx->camera_id);
 754
 755     if (ctx->camera_mgr) {
 756         ACameraManager_delete(ctx->camera_mgr);
 757         ctx->camera_mgr = NULL;
 758     }
 759
 760     if (ctx->input_queue) {
 761         AVPacket pkt;
 762         av_thread_message_queue_set_err_send(ctx->input_queue, AVERROR_EOF);
 763         while (av_thread_message_queue_recv(ctx->input_queue, &pkt, AV_THREAD_MESSAGE_NONBLOCK) >= 0) {
 764             av_packet_unref(&pkt);
 765         }
 766         av_thread_message_queue_free(&ctx->input_queue);
 767     }
 768
 769     return 0;
 770 }
 771
 772 static int android_camera_read_header(AVFormatContext *avctx)
 773 {
 774     AndroidCameraCtx *ctx = avctx->priv_data;
 775     int ret;
 776
 777     atomic_init(&ctx->got_image_format, 0);
 778     atomic_init(&ctx->exit, 0);
 779
 780     ret = av_thread_message_queue_alloc(&ctx->input_queue, ctx->input_queue_size, sizeof(AVPacket));
 781     if (ret < 0) {
 782         av_log(avctx, AV_LOG_ERROR,
 783                "Failed to allocate input queue, error: %s.\n", av_err2str(ret));
 784         goto error;
 785     }
 786
 787     ctx->camera_mgr = ACameraManager_create();
 788     if (!ctx->camera_mgr) {
 789         av_log(avctx, AV_LOG_ERROR, "Failed to create Android camera manager.\n");
 790         ret = AVERROR_EXTERNAL;
 791         goto error;
 792     }
 793
 794     ret = open_camera(avctx);
 795     if (ret < 0) {
 796         av_log(avctx, AV_LOG_ERROR, "Failed to open camera.\n");
 797         goto error;
 798     }
 799
 800     get_sensor_orientation(avctx);
 801     match_video_size(avctx);
 802     match_framerate(avctx);
 803
 804     ret = create_image_reader(avctx);
 805     if (ret < 0) {
 806         goto error;
 807     }
 808
 809     ret = create_capture_session(avctx);
 810     if (ret < 0) {
 811         goto error;
 812     }
 813
 814     ret = add_video_stream(avctx);
 815
 816 error:
 817     if (ret < 0) {
 818         android_camera_read_close(avctx);
 819         av_log(avctx, AV_LOG_ERROR, "Failed to open android_camera.\n");
 820     }
 821
 822     return ret;
 823 }
 824
 825 static int android_camera_read_packet(AVFormatContext *avctx, AVPacket *pkt)
 826 {
 827     AndroidCameraCtx *ctx = avctx->priv_data;
 828     int ret;
 829
 830     if (!atomic_load(&ctx->exit)) {
 831         ret = av_thread_message_queue_recv(ctx->input_queue, pkt,
 832                 avctx->flags & AVFMT_FLAG_NONBLOCK ? AV_THREAD_MESSAGE_NONBLOCK : 0);
 833     } else {
 834         ret = AVERROR_EOF;
 835     }
 836
 837     if (ret < 0) {
 838         return ret;
 839     } else {
 840         return pkt->size;
 841     }
 842 }
 843
 844 #define OFFSET(x) offsetof(AndroidCameraCtx, x)
 845 #define DEC AV_OPT_FLAG_DECODING_PARAM
 846 static const AVOption options[] = {
 847     { "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 },
 848     { "framerate", "set video frame rate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "30"}, 0, INT_MAX, DEC },
 849     { "camera_index", "set index of camera to use", OFFSET(camera_index), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC },
 850     { "input_queue_size", "set maximum number of frames to buffer", OFFSET(input_queue_size), AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, DEC },
 851     { NULL },
 852 };
 853
 854 static const AVClass android_camera_class = {
 855     .class_name = "android_camera indev",
 856     .item_name  = av_default_item_name,
 857     .option     = options,
 858     .version    = LIBAVUTIL_VERSION_INT,
 859     .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
 860 };
 861
 862 AVInputFormat ff_android_camera_demuxer = {
 863     .name           = "android_camera",
 864     .long_name      = NULL_IF_CONFIG_SMALL("Android camera input device"),
 865     .priv_data_size = sizeof(AndroidCameraCtx),
 866     .read_header    = android_camera_read_header,
 867     .read_packet    = android_camera_read_packet,
 868     .read_close     = android_camera_read_close,
 869     .flags          = AVFMT_NOFILE,
 870     .priv_class     = &android_camera_class,
 871 };