S5PC11X: crespo: add alsa-lib, alsa-utils, libaudio, libcamera

Change-Id: I4a6ee248b407c67682eb8884d1176f4807288c7c

1 files changed, 257 insertions, 0 deletions

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 <utils/threads.h>
+#include <camera/CameraHardwareInterface.h>
+#include <binder/MemoryBase.h>
+#include <binder/MemoryHeapBase.h>
+#include <utils/threads.h>
+
+namespace android {
+class CameraHardwareSec : public CameraHardwareInterface {
+public:
+    virtual sp<IMemoryHeap> getPreviewHeap() const;
+    virtual sp<IMemoryHeap> 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<IMemory>& 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<String16>& 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<CameraHardwareInterface> createInstance();
+
+private:
+                        CameraHardwareSec();
+    virtual             ~CameraHardwareSec();
+
+    static wp<CameraHardwareInterface> 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<MemoryHeapBase>  mPreviewHeap;
+    sp<MemoryHeapBase>  mRawHeap;
+    sp<MemoryHeapBase>  mRecordHeap;
+    sp<MemoryHeapBase>  mJpegHeap;
+    sp<MemoryBase>      mBuffers[kBufferCount];
+    sp<MemoryBase>      mRecordBuffers[kBufferCountForRecord];
+
+    SecCamera          *mSecCamera;
+    bool                mPreviewRunning;
+    int                 mPreviewFrameSize;
+    int                 mRawFrameSize;
+    int			mPreviewFrameRateMicrosec;
+
+
+    // protected by mLock
+    sp<PreviewThread>   mPreviewThread;
+#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION	
+	sp<SmartautosceneThread>   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<ObjectTrackingThread>   mObjectTrackingThread;
+	int			mObjectTrackingStatus;
+
+	bool                mSmartautosceneRunning;
+	int 		mSmartautoscene_current_status;
+	int 		mSmartautoscene_previous_status;
+	int 		af_thread_status;
+#endif
+};
+
+}; // namespace android
+
+#endif