From ec456383c58adf2d4c4818438a703e5a2ca949b5 Mon Sep 17 00:00:00 2001 From: Jeong-Seok Yang Date: Wed, 25 Aug 2010 18:32:24 -0700 Subject: S5PC11X: crespo: add alsa-lib, alsa-utils, libaudio, libcamera Change-Id: I4a6ee248b407c67682eb8884d1176f4807288c7c --- libcamera/SecCameraHWInterface.h | 257 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 257 insertions(+) create mode 100644 libcamera/SecCameraHWInterface.h (limited to 'libcamera/SecCameraHWInterface.h') diff --git a/libcamera/SecCameraHWInterface.h b/libcamera/SecCameraHWInterface.h new file mode 100644 index 0000000..9e4fb79 --- /dev/null +++ b/libcamera/SecCameraHWInterface.h @@ -0,0 +1,257 @@ +/* +** +** Copyright 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_SEC_H +#define ANDROID_HARDWARE_CAMERA_HARDWARE_SEC_H + +#include "SecCamera.h" +#include +#include +#include +#include +#include + +namespace android { +class CameraHardwareSec : public CameraHardwareInterface { +public: + virtual sp getPreviewHeap() const; + virtual sp getRawHeap() const; + +//Kamat --eclair + virtual void setCallbacks(notify_callback notify_cb, + data_callback data_cb, + data_callback_timestamp data_cb_timestamp, + void* user); + + virtual void enableMsgType(int32_t msgType); + virtual void disableMsgType(int32_t msgType); + virtual bool msgTypeEnabled(int32_t msgType); + + virtual status_t startPreview(); + virtual void stopPreview(); + virtual bool previewEnabled(); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + virtual status_t startSmartautoscene(); + virtual void stopSmartautoscene(); + virtual bool smartautosceneEnabled(); +#endif + + virtual status_t startRecording(); + virtual void stopRecording(); + virtual bool recordingEnabled(); + virtual void releaseRecordingFrame(const sp& mem); + + virtual status_t autoFocus(); + virtual status_t cancelAutoFocus(); + virtual status_t takePicture(); + virtual status_t cancelPicture(); + virtual status_t dump(int fd, const Vector& args) const; + virtual status_t setParameters(const CameraParameters& params); + virtual CameraParameters getParameters() const; + virtual status_t sendCommand(int32_t command, int32_t arg1, + int32_t arg2); + virtual void release(); + + static sp createInstance(); + +private: + CameraHardwareSec(); + virtual ~CameraHardwareSec(); + + static wp singleton; + + static const int kBufferCount = MAX_BUFFERS; + static const int kBufferCountForRecord = MAX_BUFFERS; + + class PreviewThread : public Thread { + CameraHardwareSec* mHardware; + public: + PreviewThread(CameraHardwareSec* hw): +#ifdef SINGLE_PROCESS + // In single process mode this thread needs to be a java thread, + // since we won't be calling through the binder. + Thread(true), +#else + Thread(false), +#endif + mHardware(hw) { } + virtual void onFirstRef() { + run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY); + } + virtual bool threadLoop() { + int ret = mHardware->previewThread(); + // loop until we need to quit + if(ret == NO_ERROR) + return true; + else + return false; + } + }; + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + class SmartautosceneThread : public Thread { + CameraHardwareSec* mHardware; + public: + SmartautosceneThread(CameraHardwareSec* hw): +#ifdef SINGLE_PROCESS + // In single process mode this thread needs to be a java thread, + // since we won't be calling through the binder. + Thread(true), +#else + Thread(false), +#endif + mHardware(hw) { } + virtual void onFirstRef() { + run("CameraSmartautosceneThread", PRIORITY_URGENT_DISPLAY); + } + virtual bool threadLoop() { + int ret = mHardware->smartautosceneThread(); + // loop until we need to quit + if(ret == NO_ERROR) + return true; + else + return false; + } + }; +#endif + void initDefaultParameters(); + void initHeapLocked(); + + int previewThread(); +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + int smartautosceneThread(); +#endif + + static int beginAutoFocusThread(void *cookie); + int autoFocusThread(); + + static int beginPictureThread(void *cookie); + int pictureThread(); + int save_jpeg( unsigned char * real_jpeg, int jpeg_size); + void save_postview(const char *fname, uint8_t *buf, uint32_t size); + int decodeInterleaveData(unsigned char *pInterleaveData, + int interleaveDataSize, + int yuvWidth, + int yuvHeight, + int *pJpegSize, + void *pJpegData, + void *pYuvData); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + static int beginObjectTrackingThread(void *cookie); + int objectTrackingThread(); + status_t objectTracking(int onoff); +#endif + + mutable Mutex mLock; + + CameraParameters mParameters; + + sp mPreviewHeap; + sp mRawHeap; + sp mRecordHeap; + sp mJpegHeap; + sp mBuffers[kBufferCount]; + sp mRecordBuffers[kBufferCountForRecord]; + + SecCamera *mSecCamera; + bool mPreviewRunning; + int mPreviewFrameSize; + int mRawFrameSize; + int mPreviewFrameRateMicrosec; + + + // protected by mLock + sp mPreviewThread; +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + sp mSmartautosceneThread; +#endif + notify_callback mNotifyCb; + data_callback mDataCb; + data_callback_timestamp mDataCbTimestamp; + void *mCallbackCookie; + + int32_t mMsgEnabled; + + // only used from PreviewThread + int mCurrentPreviewFrame; + int mCurrentRecordFrame; + + bool mRecordRunning; +#ifdef JPEG_FROM_SENSOR + int mPostViewWidth; + int mPostViewHeight; + int mPostViewSize; +#endif + + int mNoHwHandle; + struct timeval mTimeStart; + struct timeval mTimeStop; + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + enum COMMAND_DEFINE + { + COMMAND_AE_AWB_LOCK_UNLOCK = 1101, + COMMAND_FACE_DETECT_LOCK_UNLOCK = 1102, + COMMAND_OBJECT_POSITION = 1103, + COMMAND_OBJECT_TRACKING_STARTSTOP = 1104, + COMMAND_TOUCH_AF_STARTSTOP = 1105, + COMMAND_CHECK_DATALINE = 1106, + CONTINUOUS_SHOT_START_CAPTURE = 1023, + CONTINUOUS_SHOT_STOP_AND_ENCODING = 1024, + COMMAND_DEFAULT_IMEI = 1107, + }; + +class ObjectTrackingThread : public Thread { + CameraHardwareSec* mHardware; + public: + ObjectTrackingThread(CameraHardwareSec* hw): +#ifdef SINGLE_PROCESS + // In single process mode this thread needs to be a java thread, + // since we won't be calling through the binder. + Thread(true), +#else + Thread(false), +#endif + mHardware(hw) { } + virtual void onFirstRef() { + run("CameraObjectTrackingThread", PRIORITY_URGENT_DISPLAY); + } + virtual bool threadLoop() { + int ret = mHardware->objectTrackingThread(); + // loop until we need to quit + if(ret == NO_ERROR) + return true; + else + return false; + } + }; + bool mObjectTrackingRunning; + sp mObjectTrackingThread; + int mObjectTrackingStatus; + + bool mSmartautosceneRunning; + int mSmartautoscene_current_status; + int mSmartautoscene_previous_status; + int af_thread_status; +#endif +}; + +}; // namespace android + +#endif -- cgit v1.1