blob: 41df2e4b72622b59e8ff71b0bc4f744570eb3910 [file] [log] [blame]
/*
* 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.
*/
#ifndef ANDROID_SERVERS_CAMERA_CAMERA2DEVICE_H
#define ANDROID_SERVERS_CAMERA_CAMERA2DEVICE_H
#include <utils/Condition.h>
#include <utils/Errors.h>
#include <utils/List.h>
#include <utils/Mutex.h>
#include <utils/RefBase.h>
#include <utils/String8.h>
#include <utils/String16.h>
#include <utils/Vector.h>
#include "hardware/camera2.h"
#include "camera2/CameraMetadata.h"
namespace android {
class Camera2Device : public virtual RefBase {
public:
typedef camera2::CameraMetadata CameraMetadata;
Camera2Device(int id);
~Camera2Device();
status_t initialize(camera_module_t *module);
status_t disconnect();
status_t dump(int fd, const Vector<String16>& args);
/**
* The device's static characteristics metadata buffer
*/
const CameraMetadata& info() const;
/**
* Submit request for capture. The Camera2Device takes ownership of the
* passed-in buffer.
*/
status_t capture(CameraMetadata &request);
/**
* Submit request for streaming. The Camera2Device makes a copy of the
* passed-in buffer and the caller retains ownership.
*/
status_t setStreamingRequest(const CameraMetadata &request);
/**
* Clear the streaming request slot.
*/
status_t clearStreamingRequest();
/**
* Wait until a request with the given ID has been dequeued by the
* HAL. Returns TIMED_OUT if the timeout duration is reached. Returns
* immediately if the latest request received by the HAL has this id.
*/
status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout);
/**
* Create an output stream of the requested size and format.
*
* If format is CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, then the HAL device selects
* an appropriate format; it can be queried with getStreamInfo.
*
* If format is HAL_PIXEL_FORMAT_COMPRESSED, the size parameter must be
* equal to the size in bytes of the buffers to allocate for the stream. For
* other formats, the size parameter is ignored.
*/
status_t createStream(sp<ANativeWindow> consumer,
uint32_t width, uint32_t height, int format, size_t size,
int *id);
/**
* Create an input reprocess stream that uses buffers from an existing
* output stream.
*/
status_t createReprocessStreamFromStream(int outputId, int *id);
/**
* Get information about a given stream.
*/
status_t getStreamInfo(int id,
uint32_t *width, uint32_t *height, uint32_t *format);
/**
* Set stream gralloc buffer transform
*/
status_t setStreamTransform(int id, int transform);
/**
* Delete stream. Must not be called if there are requests in flight which
* reference that stream.
*/
status_t deleteStream(int id);
/**
* Delete reprocess stream. Must not be called if there are requests in
* flight which reference that stream.
*/
status_t deleteReprocessStream(int id);
/**
* Create a metadata buffer with fields that the HAL device believes are
* best for the given use case
*/
status_t createDefaultRequest(int templateId, CameraMetadata *request);
/**
* Wait until all requests have been processed. Returns INVALID_OPERATION if
* the streaming slot is not empty, or TIMED_OUT if the requests haven't
* finished processing in 10 seconds.
*/
status_t waitUntilDrained();
/**
* Abstract class for HAL notification listeners
*/
class NotificationListener {
public:
// Refer to the Camera2 HAL definition for notification definitions
virtual void notifyError(int errorCode, int arg1, int arg2) = 0;
virtual void notifyShutter(int frameNumber, nsecs_t timestamp) = 0;
virtual void notifyAutoFocus(uint8_t newState, int triggerId) = 0;
virtual void notifyAutoExposure(uint8_t newState, int triggerId) = 0;
virtual void notifyAutoWhitebalance(uint8_t newState, int triggerId) = 0;
protected:
virtual ~NotificationListener();
};
/**
* Connect HAL notifications to a listener. Overwrites previous
* listener. Set to NULL to stop receiving notifications.
*/
status_t setNotifyCallback(NotificationListener *listener);
/**
* Wait for a new frame to be produced, with timeout in nanoseconds.
* Returns TIMED_OUT when no frame produced within the specified duration
*/
status_t waitForNextFrame(nsecs_t timeout);
/**
* Get next metadata frame from the frame queue. Returns NULL if the queue
* is empty; caller takes ownership of the metadata buffer.
*/
status_t getNextFrame(CameraMetadata *frame);
/**
* Trigger auto-focus. The latest ID used in a trigger autofocus or cancel
* autofocus call will be returned by the HAL in all subsequent AF
* notifications.
*/
status_t triggerAutofocus(uint32_t id);
/**
* Cancel auto-focus. The latest ID used in a trigger autofocus/cancel
* autofocus call will be returned by the HAL in all subsequent AF
* notifications.
*/
status_t triggerCancelAutofocus(uint32_t id);
/**
* Trigger pre-capture metering. The latest ID used in a trigger pre-capture
* call will be returned by the HAL in all subsequent AE and AWB
* notifications.
*/
status_t triggerPrecaptureMetering(uint32_t id);
/**
* Abstract interface for clients that want to listen to reprocess buffer
* release events
*/
struct BufferReleasedListener: public virtual RefBase {
virtual void onBufferReleased(buffer_handle_t *handle) = 0;
};
/**
* Push a buffer to be reprocessed into a reprocessing stream, and
* provide a listener to call once the buffer is returned by the HAL
*/
status_t pushReprocessBuffer(int reprocessStreamId,
buffer_handle_t *buffer, wp<BufferReleasedListener> listener);
private:
const int mId;
camera2_device_t *mDevice;
CameraMetadata mDeviceInfo;
vendor_tag_query_ops_t *mVendorTagOps;
/**
* Queue class for both sending requests to a camera2 device, and for
* receiving frames from a camera2 device.
*/
class MetadataQueue: public camera2_request_queue_src_ops_t,
public camera2_frame_queue_dst_ops_t {
public:
MetadataQueue();
~MetadataQueue();
// Interface to camera2 HAL device, either for requests (device is
// consumer) or for frames (device is producer)
const camera2_request_queue_src_ops_t* getToConsumerInterface();
void setFromConsumerInterface(camera2_device_t *d);
// Connect queue consumer endpoint to a camera2 device
status_t setConsumerDevice(camera2_device_t *d);
// Connect queue producer endpoint to a camera2 device
status_t setProducerDevice(camera2_device_t *d);
const camera2_frame_queue_dst_ops_t* getToProducerInterface();
// Real interfaces. On enqueue, queue takes ownership of buffer pointer
// On dequeue, user takes ownership of buffer pointer.
status_t enqueue(camera_metadata_t *buf);
status_t dequeue(camera_metadata_t **buf, bool incrementCount = false);
int getBufferCount();
status_t waitForBuffer(nsecs_t timeout);
// Wait until a buffer with the given ID is dequeued. Will return
// immediately if the latest buffer dequeued has that ID.
status_t waitForDequeue(int32_t id, nsecs_t timeout);
// Set repeating buffer(s); if the queue is empty on a dequeue call, the
// queue copies the contents of the stream slot into the queue, and then
// dequeues the first new entry. The metadata buffers passed in are
// copied.
status_t setStreamSlot(camera_metadata_t *buf);
status_t setStreamSlot(const List<camera_metadata_t*> &bufs);
status_t dump(int fd, const Vector<String16>& args);
private:
status_t signalConsumerLocked();
status_t freeBuffers(List<camera_metadata_t*>::iterator start,
List<camera_metadata_t*>::iterator end);
camera2_device_t *mDevice;
Mutex mMutex;
Condition notEmpty;
int mFrameCount;
int32_t mLatestRequestId;
Condition mNewRequestId;
int mCount;
List<camera_metadata_t*> mEntries;
int mStreamSlotCount;
List<camera_metadata_t*> mStreamSlot;
bool mSignalConsumer;
static MetadataQueue* getInstance(
const camera2_frame_queue_dst_ops_t *q);
static MetadataQueue* getInstance(
const camera2_request_queue_src_ops_t *q);
static int consumer_buffer_count(
const camera2_request_queue_src_ops_t *q);
static int consumer_dequeue(const camera2_request_queue_src_ops_t *q,
camera_metadata_t **buffer);
static int consumer_free(const camera2_request_queue_src_ops_t *q,
camera_metadata_t *old_buffer);
static int producer_dequeue(const camera2_frame_queue_dst_ops_t *q,
size_t entries, size_t bytes,
camera_metadata_t **buffer);
static int producer_cancel(const camera2_frame_queue_dst_ops_t *q,
camera_metadata_t *old_buffer);
static int producer_enqueue(const camera2_frame_queue_dst_ops_t *q,
camera_metadata_t *filled_buffer);
}; // class MetadataQueue
MetadataQueue mRequestQueue;
MetadataQueue mFrameQueue;
/**
* Adapter from an ANativeWindow interface to camera2 device stream ops.
* Also takes care of allocating/deallocating stream in device interface
*/
class StreamAdapter: public camera2_stream_ops, public virtual RefBase {
public:
StreamAdapter(camera2_device_t *d);
~StreamAdapter();
/**
* Create a HAL device stream of the requested size and format.
*
* If format is CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, then the HAL device
* selects an appropriate format; it can be queried with getFormat.
*
* If format is HAL_PIXEL_FORMAT_COMPRESSED, the size parameter must
* be equal to the size in bytes of the buffers to allocate for the
* stream. For other formats, the size parameter is ignored.
*/
status_t connectToDevice(sp<ANativeWindow> consumer,
uint32_t width, uint32_t height, int format, size_t size);
status_t release();
status_t setTransform(int transform);
// Get stream parameters.
// Only valid after a successful connectToDevice call.
int getId() const { return mId; }
uint32_t getWidth() const { return mWidth; }
uint32_t getHeight() const { return mHeight; }
uint32_t getFormat() const { return mFormat; }
// Dump stream information
status_t dump(int fd, const Vector<String16>& args);
private:
enum {
ERROR = -1,
RELEASED = 0,
ALLOCATED,
CONNECTED,
ACTIVE
} mState;
sp<ANativeWindow> mConsumerInterface;
camera2_device_t *mDevice;
uint32_t mId;
uint32_t mWidth;
uint32_t mHeight;
uint32_t mFormat;
size_t mSize;
uint32_t mUsage;
uint32_t mMaxProducerBuffers;
uint32_t mMaxConsumerBuffers;
uint32_t mTotalBuffers;
int mFormatRequested;
/** Debugging information */
uint32_t mActiveBuffers;
uint32_t mFrameCount;
int64_t mLastTimestamp;
const camera2_stream_ops *getStreamOps();
static ANativeWindow* toANW(const camera2_stream_ops_t *w);
static int dequeue_buffer(const camera2_stream_ops_t *w,
buffer_handle_t** buffer);
static int enqueue_buffer(const camera2_stream_ops_t* w,
int64_t timestamp,
buffer_handle_t* buffer);
static int cancel_buffer(const camera2_stream_ops_t* w,
buffer_handle_t* buffer);
static int set_crop(const camera2_stream_ops_t* w,
int left, int top, int right, int bottom);
}; // class StreamAdapter
typedef List<sp<StreamAdapter> > StreamList;
StreamList mStreams;
/**
* Adapter from an ANativeWindow interface to camera2 device stream ops.
* Also takes care of allocating/deallocating stream in device interface
*/
class ReprocessStreamAdapter: public camera2_stream_in_ops, public virtual RefBase {
public:
ReprocessStreamAdapter(camera2_device_t *d);
~ReprocessStreamAdapter();
/**
* Create a HAL device reprocess stream based on an existing output stream.
*/
status_t connectToDevice(const sp<StreamAdapter> &outputStream);
status_t release();
/**
* Push buffer into stream for reprocessing. Takes ownership until it notifies
* that the buffer has been released
*/
status_t pushIntoStream(buffer_handle_t *handle,
const wp<BufferReleasedListener> &releaseListener);
/**
* Get stream parameters.
* Only valid after a successful connectToDevice call.
*/
int getId() const { return mId; }
uint32_t getWidth() const { return mWidth; }
uint32_t getHeight() const { return mHeight; }
uint32_t getFormat() const { return mFormat; }
// Dump stream information
status_t dump(int fd, const Vector<String16>& args);
private:
enum {
ERROR = -1,
RELEASED = 0,
ACTIVE
} mState;
sp<ANativeWindow> mConsumerInterface;
wp<StreamAdapter> mBaseStream;
struct QueueEntry {
buffer_handle_t *handle;
wp<BufferReleasedListener> releaseListener;
};
List<QueueEntry> mQueue;
List<QueueEntry> mInFlightQueue;
camera2_device_t *mDevice;
uint32_t mId;
uint32_t mWidth;
uint32_t mHeight;
uint32_t mFormat;
/** Debugging information */
uint32_t mActiveBuffers;
uint32_t mFrameCount;
int64_t mLastTimestamp;
const camera2_stream_in_ops *getStreamOps();
static int acquire_buffer(const camera2_stream_in_ops_t *w,
buffer_handle_t** buffer);
static int release_buffer(const camera2_stream_in_ops_t* w,
buffer_handle_t* buffer);
}; // class ReprocessStreamAdapter
typedef List<sp<ReprocessStreamAdapter> > ReprocessStreamList;
ReprocessStreamList mReprocessStreams;
// Receives HAL notifications and routes them to the NotificationListener
static void notificationCallback(int32_t msg_type,
int32_t ext1,
int32_t ext2,
int32_t ext3,
void *user);
}; // class Camera2Device
}; // namespace android
#endif