__BEGIN_DECLS
+struct camera2_device;
+
/**
* Output image stream queue management
*/
int (*cancel_buffer)(struct camera2_stream_ops* w,
buffer_handle_t* buffer);
int (*set_buffer_count)(struct camera2_stream_ops* w, int count);
+ int (*set_buffers_geometry)(struct camera2_stream_ops* pw,
+ int w, int h, int format);
int (*set_crop)(struct camera2_stream_ops *w,
int left, int top, int right, int bottom);
// Timestamps are measured in nanoseconds, and must be comparable
// The timestamp must be the time at the start of image exposure.
int (*set_timestamp)(struct camera2_stream_ops *w, int64_t timestamp);
int (*set_usage)(struct camera2_stream_ops* w, int usage);
- int (*set_swap_interval)(struct camera2_stream_ops *w, int interval);
int (*get_min_undequeued_buffer_count)(const struct camera2_stream_ops *w,
int *count);
int (*lock_buffer)(struct camera2_stream_ops* w,
/**
* Metadata queue management, used for requests sent to HAL module, and for
* frames produced by the HAL.
+ *
+ * Queue protocol:
+ *
+ * The source holds the queue and its contents. At start, the queue is empty.
+ *
+ * 1. When the first metadata buffer is placed into the queue, the source must
+ * signal the destination by calling notify_queue_not_empty().
+ *
+ * 2. After receiving notify_queue_not_empty, the destination must call
+ * dequeue() once it's ready to handle the next buffer.
+ *
+ * 3. Once the destination has processed a buffer, it should try to dequeue
+ * another buffer. If there are no more buffers available, dequeue() will
+ * return NULL. In this case, when a buffer becomes available, the source
+ * must call notify_queue_not_empty() again. If the destination receives a
+ * NULL return from dequeue, it does not need to query the queue again until
+ * a notify_queue_not_empty() call is received from the source.
+ *
+ * 4. If the destination calls buffer_count() and receives 0, this does not mean
+ * that the source will provide a notify_queue_not_empty() call. The source
+ * must only provide such a call after the destination has received a NULL
+ * from dequeue, or on initial startup.
+ *
+ * 5. The dequeue() call in response to notify_queue_not_empty() may be on the
+ * same thread as the notify_queue_not_empty() call. The source must not
+ * deadlock in that case.
*/
typedef struct camera2_metadata_queue_src_ops {
* Notify destination that the queue is no longer empty
*/
int (*notify_queue_not_empty)(struct camera2_metadata_queue_dst_ops *);
+
} camera2_metadata_queue_dst_ops_t;
/* Defined in camera_metadata.h */
CAMERA2_MSG_ERROR_SERVER_FAULT = 0x0003
};
-
-struct camera2_device;
typedef struct camera2_device_ops {
/**
* Input request queue methods
*/
- int (*set_request_queue_ops)(struct camera2_device *,
- camera2_metadata_queue_src_ops *request_queue_src_ops);
+ int (*set_request_queue_src_ops)(struct camera2_device *,
+ camera2_metadata_queue_src_ops *queue_src_ops);
- camera2_metadata_queue_dst_ops_t *request_queue_dst_ops;
+ int (*get_request_queue_dst_ops)(struct camera2_device *,
+ camera2_metadata_queue_dst_ops **queue_dst_ops);
/**
* Input reprocessing queue methods
*/
int (*set_reprocess_queue_ops)(struct camera2_device *,
- camera2_metadata_queue_src_ops *reprocess_queue_src_ops);
+ camera2_metadata_queue_src_ops *queue_src_ops);
- camera2_metadata_queue_dst_ops_t *reprocess_queue_dst_ops;
+ int (*get_reprocess_queue_dst_ops)(struct camera2_device *,
+ camera2_metadata_queue_dst_ops **queue_dst_ops);
/**
* Output frame queue methods
*/
- int (*set_frame_queue_ops)(struct camera2_device *,
- camera2_metadata_queue_dst_ops *frame_queue_dst_ops);
+ int (*set_frame_queue_dst_ops)(struct camera2_device *,
+ camera2_metadata_queue_dst_ops *queue_dst_ops);
- camera2_metadata_queue_src_ops_t *frame_queue_src_ops;
+ int (*get_frame_queue_src_ops)(struct camera2_device *,
+ camera2_metadata_queue_src_ops **queue_dst_ops);
/**
* Pass in notification methods
/**
* Operations on the input reprocessing stream
*/
- camera2_stream_ops_t *reprocess_stream_ops;
+ int (*get_reprocess_stream_ops)(struct camera2_device *,
+ camera2_stream_ops_t **stream_ops);
/**
* Get the number of streams that can be simultaneously allocated.
uint32_t stream_slot,
uint32_t width,
uint32_t height,
- int format,
+ uint32_t format,
camera2_stream_ops_t *camera2_stream_ops);
/**
uint32_t stream_slot);
/**
+ * Get methods to query for vendor extension metadata tag infomation. May
+ * set ops to NULL if no vendor extension tags are defined.
+ */
+ int (*get_metadata_vendor_tag_ops)(struct camera2_device*,
+ vendor_tag_query_ops_t **ops);
+
+ /**
* Release the camera hardware. Requests that are in flight will be
* canceled. No further buffers will be pushed into any allocated pipelines
* once this call returns.
void (*release)(struct camera2_device *);
/**
- * Methods to query for vendor extension metadata tag infomation. May be NULL
- * if no vendor extension tags are defined.
- */
- vendor_tag_query_ops *camera_metadata_vendor_tag_ops;
-
- /**
* Dump state of the camera hardware
*/
int (*dump)(struct camera2_device *, int fd);
--- /dev/null
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <system/camera_metadata.h>
+#include <hardware/camera2.h>
+#include <gtest/gtest.h>
+#include <iostream>
+
+class Camera2Test: public testing::Test {
+ public:
+ static void SetUpTestCase() {
+ int res;
+
+ hw_module_t *module = NULL;
+ res = hw_get_module(CAMERA_HARDWARE_MODULE_ID,
+ (const hw_module_t **)&module);
+
+ ASSERT_EQ(0, res)
+ << "Failure opening camera hardware module: " << res;
+ ASSERT_TRUE(NULL != module)
+ << "No camera module was set by hw_get_module";
+
+ std::cout << " Camera module name: " << module->name << std::endl;
+ std::cout << " Camera module author: " << module->author << std::endl;
+ std::cout << " Camera module API version: 0x" << std::hex
+ << module->module_api_version << std::endl;
+ std::cout << " Camera module HAL API version: 0x" << std::hex
+ << module->hal_api_version << std::endl;
+
+ int16_t version2_0 = CAMERA_MODULE_API_VERSION_2_0;
+ ASSERT_EQ(version2_0, module->module_api_version)
+ << "Camera module version is 0x"
+ << std::hex << module->module_api_version
+ << ", not 2.0. (0x"
+ << std::hex << CAMERA_MODULE_API_VERSION_2_0 << ")";
+
+ sCameraModule = reinterpret_cast<camera_module_t*>(module);
+
+ sNumCameras = sCameraModule->get_number_of_cameras();
+ ASSERT_LT(0, sNumCameras) << "No camera devices available!";
+
+ std::cout << " Camera device count: " << sNumCameras << std::endl;
+ sCameraSupportsHal2 = new bool[sNumCameras];
+
+ for (int i = 0; i < sNumCameras; i++) {
+ camera_info info;
+ res = sCameraModule->get_camera_info(i, &info);
+ ASSERT_EQ(0, res)
+ << "Failure getting camera info for camera " << i;
+ std::cout << " Camera device: " << std::dec
+ << i << std::endl;;
+ std::cout << " Facing: " << std::dec
+ << info.facing << std::endl;
+ std::cout << " Orientation: " << std::dec
+ << info.orientation << std::endl;
+ std::cout << " Version: 0x" << std::hex <<
+ info.device_version << std::endl;
+ if (info.device_version >= CAMERA_DEVICE_API_VERSION_2_0) {
+ sCameraSupportsHal2[i] = true;
+ ASSERT_TRUE(NULL != info.static_camera_characteristics);
+ std::cout << " Static camera metadata:" << std::endl;
+ dump_camera_metadata(info.static_camera_characteristics, 0, 1);
+ } else {
+ sCameraSupportsHal2[i] = false;
+ }
+ }
+ }
+
+ static const camera_module_t *getCameraModule() {
+ return sCameraModule;
+ }
+
+ static const camera2_device_t *openCameraDevice(int id) {
+ if (NULL == sCameraSupportsHal2) return NULL;
+ if (id >= sNumCameras) return NULL;
+ if (!sCameraSupportsHal2[id]) return NULL;
+
+ hw_device_t *device = NULL;
+ const camera_module_t *cam_module = getCameraModule();
+ char camId[10];
+ int res;
+
+ snprintf(camId, 10, "%d", id);
+ res = cam_module->common.methods->open(
+ (const hw_module_t*)cam_module,
+ camId,
+ &device);
+ if (res < 0 || cam_module == NULL) {
+ return NULL;
+ }
+ camera2_device_t *cam_device =
+ reinterpret_cast<camera2_device_t*>(device);
+ return cam_device;
+ }
+
+ private:
+
+ static camera_module_t *sCameraModule;
+ static int sNumCameras;
+ static bool *sCameraSupportsHal2;
+};
+
+camera_module_t *Camera2Test::sCameraModule = NULL;
+int Camera2Test::sNumCameras = 0;
+bool *Camera2Test::sCameraSupportsHal2 = NULL;
+
+
+TEST_F(Camera2Test, Basic) {
+ ASSERT_TRUE(NULL != getCameraModule());
+}
OSDN Git Service
