FFmpeg
android_camera.c
Go to the documentation of this file.
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 #include <unistd.h>
29 
30 #include <camera/NdkCameraDevice.h>
31 #include <camera/NdkCameraManager.h>
32 #include <media/NdkImage.h>
33 #include <media/NdkImageReader.h>
34 
35 #include "libavformat/avformat.h"
36 #include "libavformat/internal.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/display.h"
39 #include "libavutil/imgutils.h"
40 #include "libavutil/log.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/pixfmt.h"
45 #include "libavutil/time.h"
46 
47 /* This image format is available on all Android devices
48  * supporting the Camera2 API */
49 #define IMAGE_FORMAT_ANDROID AIMAGE_FORMAT_YUV_420_888
50 
51 #define MAX_BUF_COUNT 2
52 #define VIDEO_STREAM_INDEX 0
53 #define VIDEO_TIMEBASE_ANDROID 1000000000
54 
55 #define RETURN_CASE(x) case x: return AV_STRINGIFY(x);
56 #define RETURN_DEFAULT(x) default: return AV_STRINGIFY(x);
57 
58 typedef struct AndroidCameraCtx {
59  const AVClass *class;
60 
66 
67  uint8_t lens_facing;
69  int width;
70  int height;
73 
74  ACameraManager *camera_mgr;
75  char *camera_id;
76  ACameraMetadata *camera_metadata;
77  ACameraDevice *camera_dev;
78  ACameraDevice_StateCallbacks camera_state_callbacks;
79  AImageReader *image_reader;
80  AImageReader_ImageListener image_listener;
81  ANativeWindow *image_reader_window;
82  ACaptureSessionOutputContainer *capture_session_output_container;
83  ACaptureSessionOutput *capture_session_output;
84  ACameraOutputTarget *camera_output_target;
85  ACaptureRequest *capture_request;
86  ACameraCaptureSession_stateCallbacks capture_session_state_callbacks;
87  ACameraCaptureSession *capture_session;
88 
93 
94 static const char *camera_status_string(camera_status_t val)
95 {
96  switch(val) {
97  RETURN_CASE(ACAMERA_OK)
98  RETURN_CASE(ACAMERA_ERROR_UNKNOWN)
99  RETURN_CASE(ACAMERA_ERROR_INVALID_PARAMETER)
100  RETURN_CASE(ACAMERA_ERROR_CAMERA_DISCONNECTED)
101  RETURN_CASE(ACAMERA_ERROR_NOT_ENOUGH_MEMORY)
102  RETURN_CASE(ACAMERA_ERROR_METADATA_NOT_FOUND)
103  RETURN_CASE(ACAMERA_ERROR_CAMERA_DEVICE)
104  RETURN_CASE(ACAMERA_ERROR_CAMERA_SERVICE)
105  RETURN_CASE(ACAMERA_ERROR_SESSION_CLOSED)
106  RETURN_CASE(ACAMERA_ERROR_INVALID_OPERATION)
107  RETURN_CASE(ACAMERA_ERROR_STREAM_CONFIGURE_FAIL)
108  RETURN_CASE(ACAMERA_ERROR_CAMERA_IN_USE)
109  RETURN_CASE(ACAMERA_ERROR_MAX_CAMERA_IN_USE)
110  RETURN_CASE(ACAMERA_ERROR_CAMERA_DISABLED)
111  RETURN_CASE(ACAMERA_ERROR_PERMISSION_DENIED)
112  RETURN_DEFAULT(ACAMERA_ERROR_UNKNOWN)
113  }
114 }
115 
116 static const char *media_status_string(media_status_t val)
117 {
118  switch(val) {
119  RETURN_CASE(AMEDIA_OK)
120  RETURN_CASE(AMEDIA_ERROR_UNKNOWN)
121  RETURN_CASE(AMEDIA_ERROR_MALFORMED)
122  RETURN_CASE(AMEDIA_ERROR_UNSUPPORTED)
123  RETURN_CASE(AMEDIA_ERROR_INVALID_OBJECT)
124  RETURN_CASE(AMEDIA_ERROR_INVALID_PARAMETER)
125  RETURN_CASE(AMEDIA_ERROR_INVALID_OPERATION)
126  RETURN_CASE(AMEDIA_DRM_NOT_PROVISIONED)
127  RETURN_CASE(AMEDIA_DRM_RESOURCE_BUSY)
128  RETURN_CASE(AMEDIA_DRM_DEVICE_REVOKED)
129  RETURN_CASE(AMEDIA_DRM_SHORT_BUFFER)
130  RETURN_CASE(AMEDIA_DRM_SESSION_NOT_OPENED)
131  RETURN_CASE(AMEDIA_DRM_TAMPER_DETECTED)
132  RETURN_CASE(AMEDIA_DRM_VERIFY_FAILED)
133  RETURN_CASE(AMEDIA_DRM_NEED_KEY)
134  RETURN_CASE(AMEDIA_DRM_LICENSE_EXPIRED)
135  RETURN_CASE(AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE)
136  RETURN_CASE(AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED)
137  RETURN_CASE(AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE)
138  RETURN_CASE(AMEDIA_IMGREADER_CANNOT_UNLOCK_IMAGE)
139  RETURN_CASE(AMEDIA_IMGREADER_IMAGE_NOT_LOCKED)
140  RETURN_DEFAULT(AMEDIA_ERROR_UNKNOWN)
141  }
142 }
143 
144 static const char *error_state_callback_string(int val)
145 {
146  switch(val) {
147  RETURN_CASE(ERROR_CAMERA_IN_USE)
148  RETURN_CASE(ERROR_MAX_CAMERAS_IN_USE)
149  RETURN_CASE(ERROR_CAMERA_DISABLED)
150  RETURN_CASE(ERROR_CAMERA_DEVICE)
151  RETURN_CASE(ERROR_CAMERA_SERVICE)
152  default:
153  return "ERROR_CAMERA_UNKNOWN";
154  }
155 }
156 
157 static void camera_dev_disconnected(void *context, ACameraDevice *device)
158 {
159  AVFormatContext *avctx = context;
160  AndroidCameraCtx *ctx = avctx->priv_data;
161  atomic_store(&ctx->exit, 1);
162  av_log(avctx, AV_LOG_ERROR, "Camera with id %s disconnected.\n",
163  ACameraDevice_getId(device));
164 }
165 
166 static void camera_dev_error(void *context, ACameraDevice *device, int error)
167 {
168  AVFormatContext *avctx = context;
169  AndroidCameraCtx *ctx = avctx->priv_data;
170  atomic_store(&ctx->exit, 1);
171  av_log(avctx, AV_LOG_ERROR, "Error %s on camera with id %s.\n",
172  error_state_callback_string(error), ACameraDevice_getId(device));
173 }
174 
175 static int open_camera(AVFormatContext *avctx)
176 {
177  AndroidCameraCtx *ctx = avctx->priv_data;
178  camera_status_t ret;
179  ACameraIdList *camera_ids;
180 
181  ret = ACameraManager_getCameraIdList(ctx->camera_mgr, &camera_ids);
182  if (ret != ACAMERA_OK) {
183  av_log(avctx, AV_LOG_ERROR, "Failed to get camera id list, error: %s.\n",
185  return AVERROR_EXTERNAL;
186  }
187 
188  if (ctx->camera_index < camera_ids->numCameras) {
189  ctx->camera_id = av_strdup(camera_ids->cameraIds[ctx->camera_index]);
190  if (!ctx->camera_id) {
191  av_log(avctx, AV_LOG_ERROR, "Failed to allocate memory for camera_id.\n");
192  return AVERROR(ENOMEM);
193  }
194  } else {
195  av_log(avctx, AV_LOG_ERROR, "No camera with index %d available.\n",
196  ctx->camera_index);
197  return AVERROR(ENXIO);
198  }
199 
200  ACameraManager_deleteCameraIdList(camera_ids);
201 
202  ret = ACameraManager_getCameraCharacteristics(ctx->camera_mgr,
203  ctx->camera_id, &ctx->camera_metadata);
204  if (ret != ACAMERA_OK) {
205  av_log(avctx, AV_LOG_ERROR, "Failed to get metadata for camera with id %s, error: %s.\n",
206  ctx->camera_id, camera_status_string(ret));
207  return AVERROR_EXTERNAL;
208  }
209 
210  ctx->camera_state_callbacks.context = avctx;
211  ctx->camera_state_callbacks.onDisconnected = camera_dev_disconnected;
212  ctx->camera_state_callbacks.onError = camera_dev_error;
213 
214  ret = ACameraManager_openCamera(ctx->camera_mgr, ctx->camera_id,
215  &ctx->camera_state_callbacks, &ctx->camera_dev);
216  if (ret != ACAMERA_OK) {
217  av_log(avctx, AV_LOG_ERROR, "Failed to open camera with id %s, error: %s.\n",
218  ctx->camera_id, camera_status_string(ret));
219  return AVERROR_EXTERNAL;
220  }
221 
222  return 0;
223 }
224 
226 {
227  AndroidCameraCtx *ctx = avctx->priv_data;
228  ACameraMetadata_const_entry lens_facing;
229  ACameraMetadata_const_entry sensor_orientation;
230 
231  ACameraMetadata_getConstEntry(ctx->camera_metadata,
232  ACAMERA_LENS_FACING, &lens_facing);
233  ACameraMetadata_getConstEntry(ctx->camera_metadata,
234  ACAMERA_SENSOR_ORIENTATION, &sensor_orientation);
235 
236  ctx->lens_facing = lens_facing.data.u8[0];
237  ctx->sensor_orientation = sensor_orientation.data.i32[0];
238 }
239 
241 {
242  AndroidCameraCtx *ctx = avctx->priv_data;
243  ACameraMetadata_const_entry available_configs;
244  int found = 0;
245 
246  ACameraMetadata_getConstEntry(ctx->camera_metadata,
247  ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
248  &available_configs);
249 
250  for (int i = 0; i < available_configs.count; i++) {
251  int32_t input = available_configs.data.i32[i * 4 + 3];
252  int32_t format = available_configs.data.i32[i * 4 + 0];
253 
254  if (input) {
255  continue;
256  }
257 
258  if (format == IMAGE_FORMAT_ANDROID) {
259  int32_t width = available_configs.data.i32[i * 4 + 1];
260  int32_t height = available_configs.data.i32[i * 4 + 2];
261 
262  //Same ratio
263  if ((ctx->requested_width == width && ctx->requested_height == height) ||
264  (ctx->requested_width == height && ctx->requested_height == width)) {
265  ctx->width = width;
266  ctx->height = height;
267  found = 1;
268  break;
269  }
270  }
271  }
272 
273  if (!found || ctx->width == 0 || ctx->height == 0) {
274  ctx->width = available_configs.data.i32[1];
275  ctx->height = available_configs.data.i32[2];
276 
277  av_log(avctx, AV_LOG_WARNING,
278  "Requested video_size %dx%d not available, falling back to %dx%d\n",
279  ctx->requested_width, ctx->requested_height, ctx->width, ctx->height);
280  }
281 
282  return;
283 }
284 
285 static void match_framerate(AVFormatContext *avctx)
286 {
287  AndroidCameraCtx *ctx = avctx->priv_data;
288  ACameraMetadata_const_entry available_framerates;
289  int found = 0;
290  int current_best_match = -1;
291  int requested_framerate = av_q2d(ctx->framerate);
292 
293  ACameraMetadata_getConstEntry(ctx->camera_metadata,
294  ACAMERA_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
295  &available_framerates);
296 
297  for (int i = 0; i < available_framerates.count; i++) {
298  int32_t min = available_framerates.data.i32[i * 2 + 0];
299  int32_t max = available_framerates.data.i32[i * 2 + 1];
300 
301  if (requested_framerate == max) {
302  if (min == max) {
303  ctx->framerate_range[0] = min;
304  ctx->framerate_range[1] = max;
305  found = 1;
306  break;
307  } else if (current_best_match >= 0) {
308  int32_t current_best_match_min = available_framerates.data.i32[current_best_match * 2 + 0];
309  if (min > current_best_match_min) {
310  current_best_match = i;
311  }
312  } else {
313  current_best_match = i;
314  }
315  }
316  }
317 
318  if (!found) {
319  if (current_best_match >= 0) {
320  ctx->framerate_range[0] = available_framerates.data.i32[current_best_match * 2 + 0];
321  ctx->framerate_range[1] = available_framerates.data.i32[current_best_match * 2 + 1];
322 
323  } else {
324  ctx->framerate_range[0] = available_framerates.data.i32[0];
325  ctx->framerate_range[1] = available_framerates.data.i32[1];
326  }
327 
328  av_log(avctx, AV_LOG_WARNING,
329  "Requested framerate %d not available, falling back to min: %d and max: %d fps\n",
330  requested_framerate, ctx->framerate_range[0], ctx->framerate_range[1]);
331  }
332 
333  return;
334 }
335 
336 static int get_image_format(AVFormatContext *avctx, AImage *image)
337 {
338  AndroidCameraCtx *ctx = avctx->priv_data;
339  int32_t image_pixelstrides[2];
340  uint8_t *image_plane_data[2];
341  int plane_data_length[2];
342 
343  for (int i = 0; i < 2; i++) {
344  AImage_getPlanePixelStride(image, i + 1, &image_pixelstrides[i]);
345  AImage_getPlaneData(image, i + 1, &image_plane_data[i], &plane_data_length[i]);
346  }
347 
348  if (image_pixelstrides[0] != image_pixelstrides[1]) {
349  av_log(avctx, AV_LOG_ERROR,
350  "Pixel strides of U and V plane should have been the same.\n");
351  return AVERROR_EXTERNAL;
352  }
353 
354  switch (image_pixelstrides[0]) {
355  case 1:
356  ctx->image_format = AV_PIX_FMT_YUV420P;
357  break;
358  case 2:
359  if (image_plane_data[0] < image_plane_data[1]) {
360  ctx->image_format = AV_PIX_FMT_NV12;
361  } else {
362  ctx->image_format = AV_PIX_FMT_NV21;
363  }
364  break;
365  default:
366  av_log(avctx, AV_LOG_ERROR,
367  "Unknown pixel stride %d of U and V plane, cannot determine camera image format.\n",
368  image_pixelstrides[0]);
369  return AVERROR(ENOSYS);
370  }
371 
372  return 0;
373 }
374 
375 static void image_available(void *context, AImageReader *reader)
376 {
377  AVFormatContext *avctx = context;
378  AndroidCameraCtx *ctx = avctx->priv_data;
379  media_status_t media_status;
380  int ret = 0;
381 
382  AImage *image;
383  int64_t image_timestamp;
384  int32_t image_linestrides[4];
385  uint8_t *image_plane_data[4];
386  int plane_data_length[4];
387 
388  AVPacket pkt;
389  int pkt_buffer_size = 0;
390 
391  media_status = AImageReader_acquireLatestImage(reader, &image);
392  if (media_status != AMEDIA_OK) {
393  if (media_status == AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE) {
394  av_log(avctx, AV_LOG_WARNING,
395  "An image reader frame was discarded");
396  } else {
397  av_log(avctx, AV_LOG_ERROR,
398  "Failed to acquire latest image from image reader, error: %s.\n",
399  media_status_string(media_status));
401  }
402  goto error;
403  }
404 
405  // Silently drop frames when exit is set
406  if (atomic_load(&ctx->exit)) {
407  goto error;
408  }
409 
410  // Determine actual image format
411  if (!atomic_load(&ctx->got_image_format)) {
412  ret = get_image_format(avctx, image);
413  if (ret < 0) {
414  av_log(avctx, AV_LOG_ERROR,
415  "Could not get image format of camera.\n");
416  goto error;
417  } else {
418  atomic_store(&ctx->got_image_format, 1);
419  }
420  }
421 
422  pkt_buffer_size = av_image_get_buffer_size(ctx->image_format, ctx->width, ctx->height, 32);
423  AImage_getTimestamp(image, &image_timestamp);
424 
425  AImage_getPlaneRowStride(image, 0, &image_linestrides[0]);
426  AImage_getPlaneData(image, 0, &image_plane_data[0], &plane_data_length[0]);
427 
428  switch (ctx->image_format) {
429  case AV_PIX_FMT_YUV420P:
430  AImage_getPlaneRowStride(image, 1, &image_linestrides[1]);
431  AImage_getPlaneData(image, 1, &image_plane_data[1], &plane_data_length[1]);
432  AImage_getPlaneRowStride(image, 2, &image_linestrides[2]);
433  AImage_getPlaneData(image, 2, &image_plane_data[2], &plane_data_length[2]);
434  break;
435  case AV_PIX_FMT_NV12:
436  AImage_getPlaneRowStride(image, 1, &image_linestrides[1]);
437  AImage_getPlaneData(image, 1, &image_plane_data[1], &plane_data_length[1]);
438  break;
439  case AV_PIX_FMT_NV21:
440  AImage_getPlaneRowStride(image, 2, &image_linestrides[1]);
441  AImage_getPlaneData(image, 2, &image_plane_data[1], &plane_data_length[1]);
442  break;
443  default:
444  av_log(avctx, AV_LOG_ERROR, "Unsupported camera image format.\n");
445  ret = AVERROR(ENOSYS);
446  goto error;
447  }
448 
449  ret = av_new_packet(&pkt, pkt_buffer_size);
450  if (ret < 0) {
451  av_log(avctx, AV_LOG_ERROR,
452  "Failed to create new av packet, error: %s.\n", av_err2str(ret));
453  goto error;
454  }
455 
457  pkt.pts = image_timestamp;
458  av_image_copy_to_buffer(pkt.data, pkt_buffer_size,
459  (const uint8_t * const *) image_plane_data,
460  image_linestrides, ctx->image_format,
461  ctx->width, ctx->height, 32);
462 
464 
465 error:
466  if (ret < 0) {
467  if (ret != AVERROR(EAGAIN)) {
468  av_log(avctx, AV_LOG_ERROR,
469  "Error while processing new image, error: %s.\n", av_err2str(ret));
471  atomic_store(&ctx->exit, 1);
472  } else {
473  av_log(avctx, AV_LOG_WARNING,
474  "Input queue was full, dropping frame, consider raising the input_queue_size option (current value: %d)\n",
475  ctx->input_queue_size);
476  }
477  if (pkt_buffer_size) {
479  }
480  }
481 
482  AImage_delete(image);
483 
484  return;
485 }
486 
488 {
489  AndroidCameraCtx *ctx = avctx->priv_data;
490  media_status_t ret;
491 
492  ret = AImageReader_new(ctx->width, ctx->height, IMAGE_FORMAT_ANDROID,
493  MAX_BUF_COUNT, &ctx->image_reader);
494  if (ret != AMEDIA_OK) {
495  av_log(avctx, AV_LOG_ERROR,
496  "Failed to create image reader, error: %s.\n", media_status_string(ret));
497  return AVERROR_EXTERNAL;
498  }
499 
500  ctx->image_listener.context = avctx;
501  ctx->image_listener.onImageAvailable = image_available;
502 
503  ret = AImageReader_setImageListener(ctx->image_reader, &ctx->image_listener);
504  if (ret != AMEDIA_OK) {
505  av_log(avctx, AV_LOG_ERROR,
506  "Failed to set image listener on image reader, error: %s.\n",
508  return AVERROR_EXTERNAL;
509  }
510 
511  ret = AImageReader_getWindow(ctx->image_reader, &ctx->image_reader_window);
512  if (ret != AMEDIA_OK) {
513  av_log(avctx, AV_LOG_ERROR,
514  "Could not get image reader window, error: %s.\n",
516  return AVERROR_EXTERNAL;
517  }
518 
519  return 0;
520 }
521 
522 static void capture_session_closed(void *context, ACameraCaptureSession *session)
523 {
524  av_log(context, AV_LOG_INFO, "Android camera capture session was closed.\n");
525 }
526 
527 static void capture_session_ready(void *context, ACameraCaptureSession *session)
528 {
529  av_log(context, AV_LOG_INFO, "Android camera capture session is ready.\n");
530 }
531 
532 static void capture_session_active(void *context, ACameraCaptureSession *session)
533 {
534  av_log(context, AV_LOG_INFO, "Android camera capture session is active.\n");
535 }
536 
538 {
539  AndroidCameraCtx *ctx = avctx->priv_data;
540  camera_status_t ret;
541 
542  ret = ACaptureSessionOutputContainer_create(&ctx->capture_session_output_container);
543  if (ret != ACAMERA_OK) {
544  av_log(avctx, AV_LOG_ERROR,
545  "Failed to create capture session output container, error: %s.\n",
547  return AVERROR_EXTERNAL;
548  }
549 
550  ANativeWindow_acquire(ctx->image_reader_window);
551 
552  ret = ACaptureSessionOutput_create(ctx->image_reader_window, &ctx->capture_session_output);
553  if (ret != ACAMERA_OK) {
554  av_log(avctx, AV_LOG_ERROR,
555  "Failed to create capture session container, error: %s.\n",
557  return AVERROR_EXTERNAL;
558  }
559 
560  ret = ACaptureSessionOutputContainer_add(ctx->capture_session_output_container,
561  ctx->capture_session_output);
562  if (ret != ACAMERA_OK) {
563  av_log(avctx, AV_LOG_ERROR,
564  "Failed to add output to output container, error: %s.\n",
566  return AVERROR_EXTERNAL;
567  }
568 
569  ret = ACameraOutputTarget_create(ctx->image_reader_window, &ctx->camera_output_target);
570  if (ret != ACAMERA_OK) {
571  av_log(avctx, AV_LOG_ERROR,
572  "Failed to create camera output target, error: %s.\n",
574  return AVERROR_EXTERNAL;
575  }
576 
577  ret = ACameraDevice_createCaptureRequest(ctx->camera_dev, TEMPLATE_RECORD, &ctx->capture_request);
578  if (ret != ACAMERA_OK) {
579  av_log(avctx, AV_LOG_ERROR,
580  "Failed to create capture request, error: %s.\n",
582  return AVERROR_EXTERNAL;
583  }
584 
585  ret = ACaptureRequest_setEntry_i32(ctx->capture_request, ACAMERA_CONTROL_AE_TARGET_FPS_RANGE,
586  2, ctx->framerate_range);
587  if (ret != ACAMERA_OK) {
588  av_log(avctx, AV_LOG_ERROR,
589  "Failed to set target fps range in capture request, error: %s.\n",
591  return AVERROR_EXTERNAL;
592  }
593 
594  ret = ACaptureRequest_addTarget(ctx->capture_request, ctx->camera_output_target);
595  if (ret != ACAMERA_OK) {
596  av_log(avctx, AV_LOG_ERROR,
597  "Failed to add capture request capture request, error: %s.\n",
599  return AVERROR_EXTERNAL;
600  }
601 
602  ctx->capture_session_state_callbacks.context = avctx;
603  ctx->capture_session_state_callbacks.onClosed = capture_session_closed;
604  ctx->capture_session_state_callbacks.onReady = capture_session_ready;
605  ctx->capture_session_state_callbacks.onActive = capture_session_active;
606 
607  ret = ACameraDevice_createCaptureSession(ctx->camera_dev, ctx->capture_session_output_container,
608  &ctx->capture_session_state_callbacks, &ctx->capture_session);
609  if (ret != ACAMERA_OK) {
610  av_log(avctx, AV_LOG_ERROR,
611  "Failed to create capture session, error: %s.\n",
613  return AVERROR_EXTERNAL;
614  }
615 
616  ret = ACameraCaptureSession_setRepeatingRequest(ctx->capture_session, NULL, 1, &ctx->capture_request, NULL);
617  if (ret != ACAMERA_OK) {
618  av_log(avctx, AV_LOG_ERROR,
619  "Failed to set repeating request on capture session, error: %s.\n",
621  return AVERROR_EXTERNAL;
622  }
623 
624  return 0;
625 }
626 
628 {
629  AndroidCameraCtx *ctx = avctx->priv_data;
630 
631  while (!atomic_load(&ctx->got_image_format) && !atomic_load(&ctx->exit)) {
632  //Wait until first frame arrived and actual image format was determined
633  usleep(1000);
634  }
635 
636  return atomic_load(&ctx->got_image_format);
637 }
638 
640 {
641  AndroidCameraCtx *ctx = avctx->priv_data;
642  AVPacketSideData *side_data;
643  int32_t display_matrix[9];
644 
645  av_display_rotation_set(display_matrix, ctx->sensor_orientation);
646 
647  if (ctx->lens_facing == ACAMERA_LENS_FACING_FRONT) {
648  av_display_matrix_flip(display_matrix, 1, 0);
649  }
650 
654  sizeof(display_matrix), 0);
655 
656  if (!side_data) {
657  return AVERROR(ENOMEM);
658  }
659 
660  memcpy(side_data->data, display_matrix, sizeof(display_matrix));
661 
662  return 0;
663 }
664 
666 {
667  AndroidCameraCtx *ctx = avctx->priv_data;
668  AVStream *st;
669  AVCodecParameters *codecpar;
670 
671  st = avformat_new_stream(avctx, NULL);
672  if (!st) {
673  return AVERROR(ENOMEM);
674  }
675 
676  st->id = VIDEO_STREAM_INDEX;
677  st->avg_frame_rate = (AVRational) { ctx->framerate_range[1], 1 };
678  st->r_frame_rate = (AVRational) { ctx->framerate_range[1], 1 };
679 
680  if (!wait_for_image_format(avctx)) {
681  return AVERROR_EXTERNAL;
682  }
683 
684  codecpar = st->codecpar;
685  codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
686  codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
687  codecpar->format = ctx->image_format;
688  codecpar->width = ctx->width;
689  codecpar->height = ctx->height;
690 
692 
693  return add_display_matrix(avctx, st);
694 }
695 
697 {
698  AndroidCameraCtx *ctx = avctx->priv_data;
699 
700  atomic_store(&ctx->exit, 1);
701 
702  if (ctx->capture_session) {
703  ACameraCaptureSession_stopRepeating(ctx->capture_session);
704  // Following warning is emitted, after capture session closed callback is received:
705  // ACameraCaptureSession: Device is closed but session 0 is not notified
706  // Seems to be a bug in Android, we can ignore this
707  ACameraCaptureSession_close(ctx->capture_session);
708  ctx->capture_session = NULL;
709  }
710 
711  if (ctx->capture_request) {
712  ACaptureRequest_removeTarget(ctx->capture_request, ctx->camera_output_target);
713  ACaptureRequest_free(ctx->capture_request);
714  ctx->capture_request = NULL;
715  }
716 
717  if (ctx->camera_output_target) {
718  ACameraOutputTarget_free(ctx->camera_output_target);
719  ctx->camera_output_target = NULL;
720  }
721 
722  if (ctx->capture_session_output) {
723  ACaptureSessionOutputContainer_remove(ctx->capture_session_output_container,
724  ctx->capture_session_output);
725  ACaptureSessionOutput_free(ctx->capture_session_output);
726  ctx->capture_session_output = NULL;
727  }
728 
729  if (ctx->image_reader_window) {
730  ANativeWindow_release(ctx->image_reader_window);
731  ctx->image_reader_window = NULL;
732  }
733 
734  if (ctx->capture_session_output_container) {
735  ACaptureSessionOutputContainer_free(ctx->capture_session_output_container);
736  ctx->capture_session_output_container = NULL;
737  }
738 
739  if (ctx->camera_dev) {
740  ACameraDevice_close(ctx->camera_dev);
741  ctx->camera_dev = NULL;
742  }
743 
744  if (ctx->image_reader) {
745  AImageReader_delete(ctx->image_reader);
746  ctx->image_reader = NULL;
747  }
748 
749  if (ctx->camera_metadata) {
750  ACameraMetadata_free(ctx->camera_metadata);
751  ctx->camera_metadata = NULL;
752  }
753 
754  av_freep(&ctx->camera_id);
755 
756  if (ctx->camera_mgr) {
757  ACameraManager_delete(ctx->camera_mgr);
758  ctx->camera_mgr = NULL;
759  }
760 
761  if (ctx->input_queue) {
762  AVPacket pkt;
764  while (av_thread_message_queue_recv(ctx->input_queue, &pkt, AV_THREAD_MESSAGE_NONBLOCK) >= 0) {
766  }
767  av_thread_message_queue_free(&ctx->input_queue);
768  }
769 
770  return 0;
771 }
772 
774 {
775  AndroidCameraCtx *ctx = avctx->priv_data;
776  int ret;
777 
778  atomic_init(&ctx->got_image_format, 0);
779  atomic_init(&ctx->exit, 0);
780 
781  ret = av_thread_message_queue_alloc(&ctx->input_queue, ctx->input_queue_size, sizeof(AVPacket));
782  if (ret < 0) {
783  av_log(avctx, AV_LOG_ERROR,
784  "Failed to allocate input queue, error: %s.\n", av_err2str(ret));
785  goto error;
786  }
787 
788  ctx->camera_mgr = ACameraManager_create();
789  if (!ctx->camera_mgr) {
790  av_log(avctx, AV_LOG_ERROR, "Failed to create Android camera manager.\n");
792  goto error;
793  }
794 
795  ret = open_camera(avctx);
796  if (ret < 0) {
797  av_log(avctx, AV_LOG_ERROR, "Failed to open camera.\n");
798  goto error;
799  }
800 
801  get_sensor_orientation(avctx);
802  match_video_size(avctx);
803  match_framerate(avctx);
804 
805  ret = create_image_reader(avctx);
806  if (ret < 0) {
807  goto error;
808  }
809 
810  ret = create_capture_session(avctx);
811  if (ret < 0) {
812  goto error;
813  }
814 
815  ret = add_video_stream(avctx);
816 
817 error:
818  if (ret < 0) {
820  av_log(avctx, AV_LOG_ERROR, "Failed to open android_camera.\n");
821  }
822 
823  return ret;
824 }
825 
827 {
828  AndroidCameraCtx *ctx = avctx->priv_data;
829  int ret;
830 
831  if (!atomic_load(&ctx->exit)) {
832  ret = av_thread_message_queue_recv(ctx->input_queue, pkt,
834  } else {
835  ret = AVERROR_EOF;
836  }
837 
838  if (ret < 0) {
839  return ret;
840  } else {
841  return pkt->size;
842  }
843 }
844 
845 #define OFFSET(x) offsetof(AndroidCameraCtx, x)
846 #define DEC AV_OPT_FLAG_DECODING_PARAM
847 static const AVOption options[] = {
848  { "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 },
849  { "framerate", "set video frame rate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "30"}, 0, INT_MAX, DEC },
850  { "camera_index", "set index of camera to use", OFFSET(camera_index), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC },
851  { "input_queue_size", "set maximum number of frames to buffer", OFFSET(input_queue_size), AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, DEC },
852  { NULL },
853 };
854 
856  .class_name = "android_camera indev",
857  .item_name = av_default_item_name,
858  .option = options,
859  .version = LIBAVUTIL_VERSION_INT,
861 };
862 
864  .name = "android_camera",
865  .long_name = NULL_IF_CONFIG_SMALL("Android camera input device"),
866  .priv_data_size = sizeof(AndroidCameraCtx),
870  .flags = AVFMT_NOFILE,
871  .priv_class = &android_camera_class,
872 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:109
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AndroidCameraCtx::capture_session_output
ACaptureSessionOutput * capture_session_output
Definition: android_camera.c:83
atomic_store
#define atomic_store(object, desired)
Definition: stdatomic.h:85
options
static const AVOption options[]
Definition: android_camera.c:847
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AndroidCameraCtx::lens_facing
uint8_t lens_facing
Definition: android_camera.c:67
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:238
DEC
#define DEC
Definition: android_camera.c:846
error_state_callback_string
static const char * error_state_callback_string(int val)
Definition: android_camera.c:144
capture_session_closed
static void capture_session_closed(void *context, ACameraCaptureSession *session)
Definition: android_camera.c:522
image_available
static void image_available(void *context, AImageReader *reader)
Definition: android_camera.c:375
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
AV_THREAD_MESSAGE_NONBLOCK
@ AV_THREAD_MESSAGE_NONBLOCK
Perform non-blocking operation.
Definition: threadmessage.h:31
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:373
av_display_matrix_flip
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition: display.c:66
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:251
capture_session_ready
static void capture_session_ready(void *context, ACameraCaptureSession *session)
Definition: android_camera.c:527
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:930
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...
Definition: display.c:51
max
#define max(a, b)
Definition: cuda_runtime.h:33
AndroidCameraCtx::camera_id
char * camera_id
Definition: android_camera.c:75
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
AndroidCameraCtx::capture_session_output_container
ACaptureSessionOutputContainer * capture_session_output_container
Definition: android_camera.c:82
android_camera_read_close
static int android_camera_read_close(AVFormatContext *avctx)
Definition: android_camera.c:696
AndroidCameraCtx::image_reader_window
ANativeWindow * image_reader_window
Definition: android_camera.c:81
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:830
AndroidCameraCtx::capture_request
ACaptureRequest * capture_request
Definition: android_camera.c:85
ff_android_camera_demuxer
const AVInputFormat ff_android_camera_demuxer
Definition: android_camera.c:863
camera_dev_disconnected
static void camera_dev_disconnected(void *context, ACameraDevice *device)
Definition: android_camera.c:157
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
val
static double val(void *priv, double ch)
Definition: aeval.c:78
av_thread_message_queue_recv
int av_thread_message_queue_recv(AVThreadMessageQueue *mq, void *msg, unsigned flags)
Receive a message from the queue.
Definition: threadmessage.c:177
VIDEO_STREAM_INDEX
#define VIDEO_STREAM_INDEX
Definition: android_camera.c:52
AndroidCameraCtx::input_queue
AVThreadMessageQueue * input_queue
Definition: android_camera.c:89
AndroidCameraCtx
Definition: android_camera.c:58
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:549
av_thread_message_queue_send
int av_thread_message_queue_send(AVThreadMessageQueue *mq, void *msg, unsigned flags)
Send a message on the queue.
Definition: threadmessage.c:161
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
AndroidCameraCtx::framerate_range
int32_t framerate_range[2]
Definition: android_camera.c:71
width
#define width
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:98
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1320
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:554
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:121
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
add_video_stream
static int add_video_stream(AVFormatContext *avctx)
Definition: android_camera.c:665
AndroidCameraCtx::input_queue_size
int input_queue_size
Definition: android_camera.c:65
AVPacketSideData::data
uint8_t * data
Definition: packet.h:374
ctx
AVFormatContext * ctx
Definition: movenc.c:48
android_camera_read_header
static int android_camera_read_header(AVFormatContext *avctx)
Definition: android_camera.c:773
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVThreadMessageQueue
Definition: threadmessage.c:30
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:231
atomic_load
#define atomic_load(object)
Definition: stdatomic.h:93
AndroidCameraCtx::sensor_orientation
int32_t sensor_orientation
Definition: android_camera.c:68
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AVFormatContext
Format I/O context.
Definition: avformat.h:1202
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
framerate
float framerate
Definition: av1_levels.c:29
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
MAX_BUF_COUNT
#define MAX_BUF_COUNT
Definition: android_camera.c:51
NULL
#define NULL
Definition: coverity.c:32
android_camera_read_packet
static int android_camera_read_packet(AVFormatContext *avctx, AVPacket *pkt)
Definition: android_camera.c:826
match_framerate
static void match_framerate(AVFormatContext *avctx)
Definition: android_camera.c:285
RETURN_CASE
#define RETURN_CASE(x)
Definition: android_camera.c:55
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
get_image_format
static int get_image_format(AVFormatContext *avctx, AImage *image)
Definition: android_camera.c:336
get_sensor_orientation
static void get_sensor_orientation(AVFormatContext *avctx)
Definition: android_camera.c:225
AndroidCameraCtx::framerate
AVRational framerate
Definition: android_camera.c:63
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:235
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AndroidCameraCtx::requested_height
int requested_height
Definition: android_camera.c:62
parseutils.h
AndroidCameraCtx::camera_index
int camera_index
Definition: android_camera.c:64
open_camera
static int open_camera(AVFormatContext *avctx)
Definition: android_camera.c:175
time.h
AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
Definition: log.h:41
AndroidCameraCtx::width
int width
Definition: android_camera.c:69
camera_status_string
static const char * camera_status_string(camera_status_t val)
Definition: android_camera.c:94
AndroidCameraCtx::camera_metadata
ACameraMetadata * camera_metadata
Definition: android_camera.c:76
AVPacket::size
int size
Definition: packet.h:523
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
threadmessage.h
AndroidCameraCtx::image_format
int image_format
Definition: android_camera.c:72
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
AndroidCameraCtx::requested_width
int requested_width
Definition: android_camera.c:61
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:469
AndroidCameraCtx::capture_session_state_callbacks
ACameraCaptureSession_stateCallbacks capture_session_state_callbacks
Definition: android_camera.c:86
VIDEO_TIMEBASE_ANDROID
#define VIDEO_TIMEBASE_ANDROID
Definition: android_camera.c:53
media_status_string
static const char * media_status_string(media_status_t val)
Definition: android_camera.c:116
height
#define height
av_image_get_buffer_size
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
Definition: imgutils.c:466
camera_dev_error
static void camera_dev_error(void *context, ACameraDevice *device, int error)
Definition: android_camera.c:166
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
OFFSET
#define OFFSET(x)
Definition: android_camera.c:845
AndroidCameraCtx::capture_session
ACameraCaptureSession * capture_session
Definition: android_camera.c:87
AndroidCameraCtx::camera_state_callbacks
ACameraDevice_StateCallbacks camera_state_callbacks
Definition: android_camera.c:78
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
av_thread_message_queue_alloc
int av_thread_message_queue_alloc(AVThreadMessageQueue **mq, unsigned nelem, unsigned elsize)
Allocate a new message queue.
Definition: threadmessage.c:45
IMAGE_FORMAT_ANDROID
#define IMAGE_FORMAT_ANDROID
Definition: android_camera.c:49
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
AVCodecParameters::height
int height
Definition: codec_par.h:122
AndroidCameraCtx::camera_mgr
ACameraManager * camera_mgr
Definition: android_camera.c:74
display.h
av_thread_message_queue_set_err_send
void av_thread_message_queue_set_err_send(AVThreadMessageQueue *mq, int err)
Set the sending error code.
Definition: threadmessage.c:193
android_camera_class
static const AVClass android_camera_class
Definition: android_camera.c:855
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:97
add_display_matrix
static int add_display_matrix(AVFormatContext *avctx, AVStream *st)
Definition: android_camera.c:639
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:226
AVFMT_FLAG_NONBLOCK
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1323
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:853
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
pixfmt.h
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
avformat.h
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: avpacket.c:704
match_video_size
static void match_video_size(AVFormatContext *avctx)
Definition: android_camera.c:240
AndroidCameraCtx::height
int height
Definition: android_camera.c:70
capture_session_active
static void capture_session_active(void *context, ACameraCaptureSession *session)
Definition: android_camera.c:532
AndroidCameraCtx::image_reader
AImageReader * image_reader
Definition: android_camera.c:79
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
wait_for_image_format
static int wait_for_image_format(AVFormatContext *avctx)
Definition: android_camera.c:627
RETURN_DEFAULT
#define RETURN_DEFAULT(x)
Definition: android_camera.c:56
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1007
AndroidCameraCtx::camera_dev
ACameraDevice * camera_dev
Definition: android_camera.c:77
AVPacket::stream_index
int stream_index
Definition: packet.h:524
create_capture_session
static int create_capture_session(AVFormatContext *avctx)
Definition: android_camera.c:537
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::format
int format
Definition: codec_par.h:79
AndroidCameraCtx::image_listener
AImageReader_ImageListener image_listener
Definition: android_camera.c:80
av_image_copy_to_buffer
int av_image_copy_to_buffer(uint8_t *dst, int dst_size, const uint8_t *const src_data[4], const int src_linesize[4], enum AVPixelFormat pix_fmt, int width, int height, int align)
Copy image data from an image into a buffer.
Definition: imgutils.c:501
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AndroidCameraCtx::camera_output_target
ACameraOutputTarget * camera_output_target
Definition: android_camera.c:84
av_thread_message_queue_free
void av_thread_message_queue_free(AVThreadMessageQueue **mq)
Free a message queue.
Definition: threadmessage.c:96
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_thread_message_queue_set_err_recv
void av_thread_message_queue_set_err_recv(AVThreadMessageQueue *mq, int err)
Set the receiving error code.
Definition: threadmessage.c:204
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AndroidCameraCtx::exit
atomic_int exit
Definition: android_camera.c:90
avstring.h
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
create_image_reader
static int create_image_reader(AVFormatContext *avctx)
Definition: android_camera.c:487
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1230
AndroidCameraCtx::got_image_format
atomic_int got_image_format
Definition: android_camera.c:91
min
float min
Definition: vorbis_enc_data.h:429