683 lines
24 KiB
C++
683 lines
24 KiB
C++
/*
|
|
* Copyright (C) 2008 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_HARDWARE_CAMERA_HARDWARE_INTERFACE_H
|
|
#define ANDROID_HARDWARE_CAMERA_HARDWARE_INTERFACE_H
|
|
|
|
#include <binder/IMemory.h>
|
|
#include <binder/MemoryBase.h>
|
|
#include <binder/MemoryHeapBase.h>
|
|
#include <utils/RefBase.h>
|
|
#include <surfaceflinger/ISurface.h>
|
|
#include <ui/android_native_buffer.h>
|
|
#include <ui/GraphicBuffer.h>
|
|
#include <camera/Camera.h>
|
|
#include <camera/CameraParameters.h>
|
|
#include <system/window.h>
|
|
#include <hardware/camera.h>
|
|
|
|
namespace android {
|
|
|
|
typedef void (*notify_callback)(int32_t msgType,
|
|
int32_t ext1,
|
|
int32_t ext2,
|
|
void* user);
|
|
|
|
typedef void (*data_callback)(int32_t msgType,
|
|
const sp<IMemory> &dataPtr,
|
|
camera_frame_metadata_t *metadata,
|
|
void* user);
|
|
|
|
typedef void (*data_callback_timestamp)(nsecs_t timestamp,
|
|
int32_t msgType,
|
|
const sp<IMemory> &dataPtr,
|
|
void *user);
|
|
|
|
/**
|
|
* CameraHardwareInterface.h defines the interface to the
|
|
* camera hardware abstraction layer, used for setting and getting
|
|
* parameters, live previewing, and taking pictures.
|
|
*
|
|
* It is a referenced counted interface with RefBase as its base class.
|
|
* CameraService calls openCameraHardware() to retrieve a strong pointer to the
|
|
* instance of this interface and may be called multiple times. The
|
|
* following steps describe a typical sequence:
|
|
*
|
|
* -# After CameraService calls openCameraHardware(), getParameters() and
|
|
* setParameters() are used to initialize the camera instance.
|
|
* CameraService calls getPreviewHeap() to establish access to the
|
|
* preview heap so it can be registered with SurfaceFlinger for
|
|
* efficient display updating while in preview mode.
|
|
* -# startPreview() is called. The camera instance then periodically
|
|
* sends the message CAMERA_MSG_PREVIEW_FRAME (if enabled) each time
|
|
* a new preview frame is available. If data callback code needs to use
|
|
* this memory after returning, it must copy the data.
|
|
*
|
|
* Prior to taking a picture, CameraService calls autofocus(). When auto
|
|
* focusing has completed, the camera instance sends a CAMERA_MSG_FOCUS notification,
|
|
* which informs the application whether focusing was successful. The camera instance
|
|
* only sends this message once and it is up to the application to call autoFocus()
|
|
* again if refocusing is desired.
|
|
*
|
|
* CameraService calls takePicture() to request the camera instance take a
|
|
* picture. At this point, if a shutter, postview, raw, and/or compressed callback
|
|
* is desired, the corresponding message must be enabled. As with CAMERA_MSG_PREVIEW_FRAME,
|
|
* any memory provided in a data callback must be copied if it's needed after returning.
|
|
*/
|
|
|
|
class CameraHardwareInterface : public virtual RefBase {
|
|
public:
|
|
CameraHardwareInterface(hw_module_t *module, const char *name)
|
|
{
|
|
mDevice = 0;
|
|
mName = name;
|
|
LOGI("Opening camera %s, this %p", name, this);
|
|
int rc = module->methods->open(module, name,
|
|
(hw_device_t **)&mDevice);
|
|
if (rc != OK)
|
|
LOGE("Could not open camera %s: %d", name, rc);
|
|
initHalPreviewWindow();
|
|
}
|
|
|
|
~CameraHardwareInterface()
|
|
{
|
|
LOGI("Destroying camera %s", mName.string());
|
|
int rc = mDevice->common.close(&mDevice->common);
|
|
if (rc != OK)
|
|
LOGE("Could not close camera %s: %d", mName.string(), rc);
|
|
}
|
|
|
|
/** Set the ANativeWindow to which preview frames are sent */
|
|
status_t setPreviewWindow(const sp<ANativeWindow>& buf)
|
|
{
|
|
LOGV("%s(%s) buf %p", __FUNCTION__, mName.string(), buf.get());
|
|
|
|
if (mDevice->ops->set_preview_window) {
|
|
mPreviewWindow = buf;
|
|
mHalPreviewWindow.user = this;
|
|
LOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p", __FUNCTION__,
|
|
&mHalPreviewWindow, mHalPreviewWindow.user);
|
|
return mDevice->ops->set_preview_window(mDevice,
|
|
buf.get() ? &mHalPreviewWindow.nw : 0);
|
|
}
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/** Set the notification and data callbacks */
|
|
void setCallbacks(notify_callback notify_cb,
|
|
data_callback data_cb,
|
|
data_callback_timestamp data_cb_timestamp,
|
|
void* user)
|
|
{
|
|
mNotifyCb = notify_cb;
|
|
mDataCb = data_cb;
|
|
mDataCbTimestamp = data_cb_timestamp;
|
|
mCbUser = user;
|
|
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
|
|
if (mDevice->ops->set_callbacks) {
|
|
mDevice->ops->set_callbacks(mDevice,
|
|
__notify_cb,
|
|
__data_cb,
|
|
__data_cb_timestamp,
|
|
__get_memory,
|
|
this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The following three functions all take a msgtype,
|
|
* which is a bitmask of the messages defined in
|
|
* include/ui/Camera.h
|
|
*/
|
|
|
|
/**
|
|
* Enable a message, or set of messages.
|
|
*/
|
|
void enableMsgType(int32_t msgType)
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->enable_msg_type)
|
|
mDevice->ops->enable_msg_type(mDevice, msgType);
|
|
}
|
|
|
|
/**
|
|
* Disable a message, or a set of messages.
|
|
*
|
|
* Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera hal
|
|
* should not rely on its client to call releaseRecordingFrame() to release
|
|
* video recording frames sent out by the cameral hal before and after the
|
|
* disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera hal clients must not
|
|
* modify/access any video recording frame after calling
|
|
* disableMsgType(CAMERA_MSG_VIDEO_FRAME).
|
|
*/
|
|
void disableMsgType(int32_t msgType)
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->disable_msg_type)
|
|
mDevice->ops->disable_msg_type(mDevice, msgType);
|
|
}
|
|
|
|
/**
|
|
* Query whether a message, or a set of messages, is enabled.
|
|
* Note that this is operates as an AND, if any of the messages
|
|
* queried are off, this will return false.
|
|
*/
|
|
int msgTypeEnabled(int32_t msgType)
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->msg_type_enabled)
|
|
return mDevice->ops->msg_type_enabled(mDevice, msgType);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Start preview mode.
|
|
*/
|
|
status_t startPreview()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->start_preview)
|
|
return mDevice->ops->start_preview(mDevice);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/**
|
|
* Stop a previously started preview.
|
|
*/
|
|
void stopPreview()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->stop_preview)
|
|
mDevice->ops->stop_preview(mDevice);
|
|
}
|
|
|
|
/**
|
|
* Returns true if preview is enabled.
|
|
*/
|
|
int previewEnabled()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->preview_enabled)
|
|
return mDevice->ops->preview_enabled(mDevice);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Request the camera hal to store meta data or real YUV data in
|
|
* the video buffers send out via CAMERA_MSG_VIDEO_FRRAME for a
|
|
* recording session. If it is not called, the default camera
|
|
* hal behavior is to store real YUV data in the video buffers.
|
|
*
|
|
* This method should be called before startRecording() in order
|
|
* to be effective.
|
|
*
|
|
* If meta data is stored in the video buffers, it is up to the
|
|
* receiver of the video buffers to interpret the contents and
|
|
* to find the actual frame data with the help of the meta data
|
|
* in the buffer. How this is done is outside of the scope of
|
|
* this method.
|
|
*
|
|
* Some camera hal may not support storing meta data in the video
|
|
* buffers, but all camera hal should support storing real YUV data
|
|
* in the video buffers. If the camera hal does not support storing
|
|
* the meta data in the video buffers when it is requested to do
|
|
* do, INVALID_OPERATION must be returned. It is very useful for
|
|
* the camera hal to pass meta data rather than the actual frame
|
|
* data directly to the video encoder, since the amount of the
|
|
* uncompressed frame data can be very large if video size is large.
|
|
*
|
|
* @param enable if true to instruct the camera hal to store
|
|
* meta data in the video buffers; false to instruct
|
|
* the camera hal to store real YUV data in the video
|
|
* buffers.
|
|
*
|
|
* @return OK on success.
|
|
*/
|
|
|
|
status_t storeMetaDataInBuffers(int enable)
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->store_meta_data_in_buffers)
|
|
return mDevice->ops->store_meta_data_in_buffers(mDevice, enable);
|
|
return enable ? INVALID_OPERATION: OK;
|
|
}
|
|
|
|
/**
|
|
* Start record mode. When a record image is available a CAMERA_MSG_VIDEO_FRAME
|
|
* message is sent with the corresponding frame. Every record frame must be released
|
|
* by a cameral hal client via releaseRecordingFrame() before the client calls
|
|
* disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
|
|
* disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is camera hal's responsibility
|
|
* to manage the life-cycle of the video recording frames, and the client must
|
|
* not modify/access any video recording frames.
|
|
*/
|
|
status_t startRecording()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->start_recording)
|
|
return mDevice->ops->start_recording(mDevice);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/**
|
|
* Stop a previously started recording.
|
|
*/
|
|
void stopRecording()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->stop_recording)
|
|
mDevice->ops->stop_recording(mDevice);
|
|
}
|
|
|
|
/**
|
|
* Returns true if recording is enabled.
|
|
*/
|
|
int recordingEnabled()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->recording_enabled)
|
|
return mDevice->ops->recording_enabled(mDevice);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
|
|
*
|
|
* It is camera hal client's responsibility to release video recording
|
|
* frames sent out by the camera hal before the camera hal receives
|
|
* a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives
|
|
* the call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is camera hal's
|
|
* responsibility of managing the life-cycle of the video recording
|
|
* frames.
|
|
*/
|
|
void releaseRecordingFrame(const sp<IMemory>& mem)
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->release_recording_frame) {
|
|
ssize_t offset;
|
|
size_t size;
|
|
sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
|
|
void *data = ((uint8_t *)heap->base()) + offset;
|
|
return mDevice->ops->release_recording_frame(mDevice, data);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start auto focus, the notification callback routine is called
|
|
* with CAMERA_MSG_FOCUS once when focusing is complete. autoFocus()
|
|
* will be called again if another auto focus is needed.
|
|
*/
|
|
status_t autoFocus()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->auto_focus)
|
|
return mDevice->ops->auto_focus(mDevice);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/**
|
|
* Cancels auto-focus function. If the auto-focus is still in progress,
|
|
* this function will cancel it. Whether the auto-focus is in progress
|
|
* or not, this function will return the focus position to the default.
|
|
* If the camera does not support auto-focus, this is a no-op.
|
|
*/
|
|
status_t cancelAutoFocus()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->cancel_auto_focus)
|
|
return mDevice->ops->cancel_auto_focus(mDevice);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/**
|
|
* Take a picture.
|
|
*/
|
|
status_t takePicture()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->take_picture)
|
|
return mDevice->ops->take_picture(mDevice);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/**
|
|
* Cancel a picture that was started with takePicture. Calling this
|
|
* method when no picture is being taken is a no-op.
|
|
*/
|
|
status_t cancelPicture()
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->cancel_picture)
|
|
return mDevice->ops->cancel_picture(mDevice);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/**
|
|
* Set the camera parameters. This returns BAD_VALUE if any parameter is
|
|
* invalid or not supported. */
|
|
status_t setParameters(const CameraParameters ¶ms)
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->set_parameters)
|
|
return mDevice->ops->set_parameters(mDevice,
|
|
params.flatten().string());
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/** Return the camera parameters. */
|
|
CameraParameters getParameters() const
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
CameraParameters parms;
|
|
if (mDevice->ops->get_parameters) {
|
|
char *temp = mDevice->ops->get_parameters(mDevice);
|
|
String8 str_parms(temp);
|
|
if (mDevice->ops->put_parameters)
|
|
mDevice->ops->put_parameters(mDevice, temp);
|
|
else
|
|
free(temp);
|
|
parms.unflatten(str_parms);
|
|
}
|
|
return parms;
|
|
}
|
|
|
|
/**
|
|
* Send command to camera driver.
|
|
*/
|
|
status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->send_command)
|
|
return mDevice->ops->send_command(mDevice, cmd, arg1, arg2);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
/**
|
|
* Release the hardware resources owned by this object. Note that this is
|
|
* *not* done in the destructor.
|
|
*/
|
|
void release() {
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->release)
|
|
mDevice->ops->release(mDevice);
|
|
}
|
|
|
|
/**
|
|
* Dump state of the camera hardware
|
|
*/
|
|
status_t dump(int fd, const Vector<String16>& args) const
|
|
{
|
|
LOGV("%s(%s)", __FUNCTION__, mName.string());
|
|
if (mDevice->ops->dump)
|
|
return mDevice->ops->dump(mDevice, fd);
|
|
return OK; // It's fine if the HAL doesn't implement dump()
|
|
}
|
|
|
|
private:
|
|
camera_device_t *mDevice;
|
|
String8 mName;
|
|
|
|
static void __notify_cb(int32_t msg_type, int32_t ext1,
|
|
int32_t ext2, void *user)
|
|
{
|
|
LOGV("%s", __FUNCTION__);
|
|
CameraHardwareInterface *__this =
|
|
static_cast<CameraHardwareInterface *>(user);
|
|
__this->mNotifyCb(msg_type, ext1, ext2, __this->mCbUser);
|
|
}
|
|
|
|
static void __data_cb(int32_t msg_type,
|
|
const camera_memory_t *data, unsigned int index,
|
|
camera_frame_metadata_t *metadata,
|
|
void *user)
|
|
{
|
|
LOGV("%s", __FUNCTION__);
|
|
CameraHardwareInterface *__this =
|
|
static_cast<CameraHardwareInterface *>(user);
|
|
sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
|
|
if (index >= mem->mNumBufs) {
|
|
LOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
|
|
index, mem->mNumBufs);
|
|
return;
|
|
}
|
|
__this->mDataCb(msg_type, mem->mBuffers[index], metadata, __this->mCbUser);
|
|
}
|
|
|
|
static void __data_cb_timestamp(nsecs_t timestamp, int32_t msg_type,
|
|
const camera_memory_t *data, unsigned index,
|
|
void *user)
|
|
{
|
|
LOGV("%s", __FUNCTION__);
|
|
CameraHardwareInterface *__this =
|
|
static_cast<CameraHardwareInterface *>(user);
|
|
// Start refcounting the heap object from here on. When the clients
|
|
// drop all references, it will be destroyed (as well as the enclosed
|
|
// MemoryHeapBase.
|
|
sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
|
|
if (index >= mem->mNumBufs) {
|
|
LOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
|
|
index, mem->mNumBufs);
|
|
return;
|
|
}
|
|
__this->mDataCbTimestamp(timestamp, msg_type, mem->mBuffers[index], __this->mCbUser);
|
|
}
|
|
|
|
// This is a utility class that combines a MemoryHeapBase and a MemoryBase
|
|
// in one. Since we tend to use them in a one-to-one relationship, this is
|
|
// handy.
|
|
|
|
class CameraHeapMemory : public RefBase {
|
|
public:
|
|
CameraHeapMemory(int fd, size_t buf_size, uint_t num_buffers = 1) :
|
|
mBufSize(buf_size),
|
|
mNumBufs(num_buffers)
|
|
{
|
|
mHeap = new MemoryHeapBase(fd, buf_size * num_buffers);
|
|
commonInitialization();
|
|
}
|
|
|
|
CameraHeapMemory(size_t buf_size, uint_t num_buffers = 1) :
|
|
mBufSize(buf_size),
|
|
mNumBufs(num_buffers)
|
|
{
|
|
mHeap = new MemoryHeapBase(buf_size * num_buffers);
|
|
commonInitialization();
|
|
}
|
|
|
|
void commonInitialization()
|
|
{
|
|
handle.data = mHeap->base();
|
|
handle.size = mBufSize * mNumBufs;
|
|
handle.handle = this;
|
|
|
|
mBuffers = new sp<MemoryBase>[mNumBufs];
|
|
for (uint_t i = 0; i < mNumBufs; i++)
|
|
mBuffers[i] = new MemoryBase(mHeap,
|
|
i * mBufSize,
|
|
mBufSize);
|
|
|
|
handle.release = __put_memory;
|
|
}
|
|
|
|
virtual ~CameraHeapMemory()
|
|
{
|
|
delete [] mBuffers;
|
|
}
|
|
|
|
size_t mBufSize;
|
|
uint_t mNumBufs;
|
|
sp<MemoryHeapBase> mHeap;
|
|
sp<MemoryBase> *mBuffers;
|
|
|
|
camera_memory_t handle;
|
|
};
|
|
|
|
static camera_memory_t* __get_memory(int fd, size_t buf_size, uint_t num_bufs,
|
|
void *user __attribute__((unused)))
|
|
{
|
|
CameraHeapMemory *mem;
|
|
if (fd < 0)
|
|
mem = new CameraHeapMemory(buf_size, num_bufs);
|
|
else
|
|
mem = new CameraHeapMemory(fd, buf_size, num_bufs);
|
|
mem->incStrong(mem);
|
|
return &mem->handle;
|
|
}
|
|
|
|
static void __put_memory(camera_memory_t *data)
|
|
{
|
|
if (!data)
|
|
return;
|
|
|
|
CameraHeapMemory *mem = static_cast<CameraHeapMemory *>(data->handle);
|
|
mem->decStrong(mem);
|
|
}
|
|
|
|
static ANativeWindow *__to_anw(void *user)
|
|
{
|
|
CameraHardwareInterface *__this =
|
|
reinterpret_cast<CameraHardwareInterface *>(user);
|
|
return __this->mPreviewWindow.get();
|
|
}
|
|
#define anw(n) __to_anw(((struct camera_preview_window *)n)->user)
|
|
|
|
static int __dequeue_buffer(struct preview_stream_ops* w,
|
|
buffer_handle_t** buffer, int *stride)
|
|
{
|
|
int rc;
|
|
ANativeWindow *a = anw(w);
|
|
ANativeWindowBuffer* anb;
|
|
rc = a->dequeueBuffer(a, &anb);
|
|
if (!rc) {
|
|
*buffer = &anb->handle;
|
|
*stride = anb->stride;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
#ifndef container_of
|
|
#define container_of(ptr, type, member) ({ \
|
|
const typeof(((type *) 0)->member) *__mptr = (ptr); \
|
|
(type *) ((char *) __mptr - (char *)(&((type *)0)->member)); })
|
|
#endif
|
|
|
|
static int __lock_buffer(struct preview_stream_ops* w,
|
|
buffer_handle_t* buffer)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
return a->lockBuffer(a,
|
|
container_of(buffer, ANativeWindowBuffer, handle));
|
|
}
|
|
|
|
static int __enqueue_buffer(struct preview_stream_ops* w,
|
|
buffer_handle_t* buffer)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
return a->queueBuffer(a,
|
|
container_of(buffer, ANativeWindowBuffer, handle));
|
|
}
|
|
|
|
static int __cancel_buffer(struct preview_stream_ops* w,
|
|
buffer_handle_t* buffer)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
return a->cancelBuffer(a,
|
|
container_of(buffer, ANativeWindowBuffer, handle));
|
|
}
|
|
|
|
static int __set_buffer_count(struct preview_stream_ops* w, int count)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
return native_window_set_buffer_count(a, count);
|
|
}
|
|
|
|
static int __set_buffers_geometry(struct preview_stream_ops* w,
|
|
int width, int height, int format)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
return native_window_set_buffers_geometry(a,
|
|
width, height, format);
|
|
}
|
|
|
|
static int __set_crop(struct preview_stream_ops *w,
|
|
int left, int top, int right, int bottom)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
android_native_rect_t crop;
|
|
crop.left = left;
|
|
crop.top = top;
|
|
crop.right = right;
|
|
crop.bottom = bottom;
|
|
return native_window_set_crop(a, &crop);
|
|
}
|
|
|
|
static int __set_usage(struct preview_stream_ops* w, int usage)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
return native_window_set_usage(a, usage);
|
|
}
|
|
|
|
static int __set_swap_interval(struct preview_stream_ops *w, int interval)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
return a->setSwapInterval(a, interval);
|
|
}
|
|
|
|
static int __get_min_undequeued_buffer_count(
|
|
const struct preview_stream_ops *w,
|
|
int *count)
|
|
{
|
|
ANativeWindow *a = anw(w);
|
|
return a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, count);
|
|
}
|
|
|
|
void initHalPreviewWindow()
|
|
{
|
|
mHalPreviewWindow.nw.cancel_buffer = __cancel_buffer;
|
|
mHalPreviewWindow.nw.lock_buffer = __lock_buffer;
|
|
mHalPreviewWindow.nw.dequeue_buffer = __dequeue_buffer;
|
|
mHalPreviewWindow.nw.enqueue_buffer = __enqueue_buffer;
|
|
mHalPreviewWindow.nw.set_buffer_count = __set_buffer_count;
|
|
mHalPreviewWindow.nw.set_buffers_geometry = __set_buffers_geometry;
|
|
mHalPreviewWindow.nw.set_crop = __set_crop;
|
|
mHalPreviewWindow.nw.set_usage = __set_usage;
|
|
mHalPreviewWindow.nw.set_swap_interval = __set_swap_interval;
|
|
|
|
mHalPreviewWindow.nw.get_min_undequeued_buffer_count =
|
|
__get_min_undequeued_buffer_count;
|
|
}
|
|
|
|
sp<ANativeWindow> mPreviewWindow;
|
|
|
|
struct camera_preview_window {
|
|
struct preview_stream_ops nw;
|
|
void *user;
|
|
};
|
|
|
|
struct camera_preview_window mHalPreviewWindow;
|
|
|
|
notify_callback mNotifyCb;
|
|
data_callback mDataCb;
|
|
data_callback_timestamp mDataCbTimestamp;
|
|
void *mCbUser;
|
|
};
|
|
|
|
}; // namespace android
|
|
|
|
#endif
|