add usb camera and flashlight

9 files changed, 923 insertions, 154 deletions

diff --git a/AmlogicCameraHardware.cpp b/AmlogicCameraHardware.cpp
index 49a1104..d62fb36 100755
--- a/AmlogicCameraHardware.cpp
+++ b/AmlogicCameraHardware.cpp
@@ -18,7 +18,6 @@
 #define NDEBUG 0

 

 #define LOG_TAG "AmlogicCameraHardware"

-

 #include <utils/Log.h>

 

 #include "AmlogicCameraHardware.h"

@@ -32,13 +31,19 @@
 #include <fcntl.h>

 #include <linux/fb.h>

 

+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT

+extern "C" {

+int set_flash(bool mode);

+}

+#endif

 

 //for test

-void convert_rgb16_to_yuv420sp(uint8_t *rgb, uint8_t *yuv, int width, int height);

+static void convert_rgb16_to_yuv420sp(uint8_t *rgb, uint8_t *yuv, int width, int height);

 void convert_rgb24_to_rgb16(uint8_t *rgb888, uint8_t *rgb565, int width, int height);

+void yuyv422_to_rgb16(unsigned char *buf, unsigned char *rgb, int width, int height);

+void yuyv422_to_yuv420sp(unsigned char *bufsrc, unsigned char *bufdest, int width, int height);

 

-

-namespace android 

+namespace android

 {

 

 //for OverLay

@@ -56,30 +61,30 @@ namespace android
 

 int SYS_enable_colorkey(short key_rgb565)

 {

-	int ret = -1;    

-	int fd_fb0 = open("/dev/graphics/fb0", O_RDWR);    

-	if (fd_fb0 >= 0) 

-	{       

-		uint32_t myKeyColor = key_rgb565;        

-		uint32_t myKeyColor_en = 1;       

+	int ret = -1;

+	int fd_fb0 = open("/dev/graphics/fb0", O_RDWR);

+	if (fd_fb0 >= 0)

+	{

+		uint32_t myKeyColor = key_rgb565;

+		uint32_t myKeyColor_en = 1;

 		printf("enablecolorkey color=%#x\n", myKeyColor);

-		ret = ioctl(fd_fb0, FBIOPUT_OSD_SRCCOLORKEY, &myKeyColor);        

-		ret += ioctl(fd_fb0, FBIOPUT_OSD_SRCKEY_ENABLE, &myKeyColor_en);        

-		close(fd_fb0);    

-	}    

+		ret = ioctl(fd_fb0, FBIOPUT_OSD_SRCCOLORKEY, &myKeyColor);

+		ret += ioctl(fd_fb0, FBIOPUT_OSD_SRCKEY_ENABLE, &myKeyColor_en);

+		close(fd_fb0);

+	}

 	return ret;

 }

 

 int SYS_disable_colorkey()

 {

-	int ret = -1;    

-	int fd_fb0 = open("/dev/graphics/fb0", O_RDWR);   

+	int ret = -1;

+	int fd_fb0 = open("/dev/graphics/fb0", O_RDWR);

 	if (fd_fb0 >= 0)

-	{        

-		uint32_t myKeyColor_en = 0;     

-		ret = ioctl(fd_fb0, FBIOPUT_OSD_SRCKEY_ENABLE, &myKeyColor_en);       

-		close(fd_fb0);  

-	}   

+	{

+		uint32_t myKeyColor_en = 0;

+		ret = ioctl(fd_fb0, FBIOPUT_OSD_SRCKEY_ENABLE, &myKeyColor_en);

+		close(fd_fb0);

+	}

 	return ret;

 }

 

@@ -146,9 +151,11 @@ extern CameraInterface* HAL_GetCameraInterface(int Id);
 

 AmlogicCameraHardware::AmlogicCameraHardware(int camid)

                   : mParameters(),

+                  	mHeap(0),

                     mPreviewHeap(0),

                     mRawHeap(0),

                     mPreviewFrameSize(0),

+                    mHeapSize(0),

                     mNotifyCb(0),

                     mDataCb(0),

                     mDataCbTimestamp(0),

@@ -158,17 +165,18 @@ AmlogicCameraHardware::AmlogicCameraHardware(int camid)
                     mRecordEnable(0),

                     mState(0)

 {

-    LOGD("Current camera is %d", camid);

-    mCamera = HAL_GetCameraInterface(camid);

-    initDefaultParameters();

+	LOGD("current camera is %d",camid);

 #ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

     SYS_disable_avsync();

     SYS_disable_video_pause();

     SYS_enable_nextvideo();

 #else

-    mRecordHeap = NULL;

+	mRecordHeap = NULL;

 #endif

-    mCamera->Open();

+	mCamera = HAL_GetCameraInterface(camid);

+	mCamera->Open();

+	initDefaultParameters();

+	mCamera->Close();

 }

 

 AmlogicCameraHardware::~AmlogicCameraHardware()

@@ -198,37 +206,58 @@ void AmlogicCameraHardware::initHeapLocked()
     // Create raw heap.

     int picture_width, picture_height;

     mParameters.getPictureSize(&picture_width, &picture_height);

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+    mRawHeap = new MemoryHeapBase(picture_width * 2 * picture_height);

+#else

     mRawHeap = new MemoryHeapBase(picture_width * 3 * picture_height);

+#endif

 

     int preview_width, preview_height;

     mParameters.getPreviewSize(&preview_width, &preview_height);

    // LOGD("initHeapLocked: preview size=%dx%d", preview_width, preview_height);

 

     // Note that we enforce yuv422 in setParameters().

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+    int how_big = preview_width * preview_height * 2;

+#else

     int how_big = preview_width * preview_height * 3 / 2;

+#endif

 

     // If we are being reinitialized to the same size as before, no

     // work needs to be done.

-    if (how_big == mPreviewFrameSize)

+    if (how_big == mHeapSize)

         return;

-

+    mHeapSize = how_big;

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

     mPreviewFrameSize = how_big;

+#endif

 

     // Make a new mmap'ed heap that can be shared across processes.

     // use code below to test with pmem

+    mHeap = new MemoryHeapBase(mHeapSize * kBufferCount);

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

     mPreviewHeap = new MemoryHeapBase(mPreviewFrameSize * kBufferCount);

+#endif

     // Make an IMemory for each frame so that we can reuse them in callbacks.

     for (int i = 0; i < kBufferCount; i++) {

-        mBuffers[i] = new MemoryBase(mPreviewHeap, i * mPreviewFrameSize, mPreviewFrameSize);

+        mBuffers[i] = new MemoryBase(mHeap, i * mHeapSize, mHeapSize);

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+        mPreviewBuffers[i] = new MemoryBase(mPreviewHeap, i * mPreviewFrameSize, mPreviewFrameSize);

+#endif

     }

-    

+    #ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

     mRecordBufCount = kBufferCount;

 

-	#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT

-	mRecordHeap = new MemoryHeapBase(mPreviewFrameSize * kBufferCount);

+	#else

+	#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+	int RecordFrameSize = mHeapSize*3/4;

+	#else

+	int RecordFrameSize = mHeapSize;

+	#endif

+	mRecordHeap = new MemoryHeapBase(RecordFrameSize * kBufferCount);

     // Make an IMemory for each frame so that we can reuse them in callbacks.

     for (int i = 0; i < kBufferCount; i++) {

-        mRecordBuffers[i] = new MemoryBase(mRecordHeap, i * mPreviewFrameSize, mPreviewFrameSize);

+        mRecordBuffers[i] = new MemoryBase(mRecordHeap, i * RecordFrameSize, RecordFrameSize);

     }

 	#endif

 }

@@ -281,11 +310,11 @@ bool AmlogicCameraHardware::msgTypeEnabled(int32_t msgType)
 status_t AmlogicCameraHardware::setOverlay(const sp<Overlay> &overlay)

 {

 	LOGD("AMLOGIC CAMERA setOverlay");

-    

+

     if (overlay != NULL) {

         SYS_enable_colorkey(0);

     }

-    

+

     return NO_ERROR;

 }

 #endif

@@ -298,39 +327,45 @@ int AmlogicCameraHardware::previewThread()
 	// the attributes below can change under our feet...

 	int previewFrameRate = mParameters.getPreviewFrameRate();

 	// Find the offset within the heap of the current buffer.

-	ssize_t offset = mCurrentPreviewFrame * mPreviewFrameSize;

-	sp<MemoryHeapBase> heap = mPreviewHeap;

+	ssize_t offset = mCurrentPreviewFrame * mHeapSize;

+	sp<MemoryHeapBase> heap = mHeap;

 	sp<MemoryBase> buffer = mBuffers[mCurrentPreviewFrame];

-	

-#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT

-	sp<MemoryBase> recordBuffer = mRecordBuffers[mCurrentPreviewFrame];

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+	sp<MemoryHeapBase> previewheap = mPreviewHeap;

+	sp<MemoryBase> previewbuffer = mPreviewBuffers[mCurrentPreviewFrame];

 #endif

 	mLock.unlock();

-

 	if (buffer != 0) {

 		int width,height;

 		mParameters.getPreviewSize(&width, &height);

+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

 		int delay = (int)(1000000.0f / float(previewFrameRate)) >> 1;

-

 		if (mRecordBufCount <= 0) {

 			LOGD("Recording buffer underflow");

 			usleep(delay);

 			return NO_ERROR;

 		}

-

+#endif

 		//get preview frames data

-		void *base = heap->base();

+		void *base = heap->getBase();

 		uint8_t *frame = ((uint8_t *)base) + offset;

-

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+		uint8_t *previewframe = ((uint8_t *)previewheap->getBase()) + offset;

+#endif

 		//get preview frame

 		{

 			if(mCamera->GetPreviewFrame(frame) != NO_ERROR)//special case for first preview frame

 				    return NO_ERROR;

-		

 			if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)

 			{

 				//LOGD("Return preview frame");

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+				yuyv422_to_rgb16((unsigned char *)frame,(unsigned char *)previewframe,

+                                width, height);

+				mDataCb(CAMERA_MSG_PREVIEW_FRAME, previewbuffer, mCallbackCookie);

+#else

 				mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);

+#endif

 			}

 		}

 

@@ -338,17 +373,24 @@ int AmlogicCameraHardware::previewThread()
 		if(mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)

 		{

 			//LOGD("return video frame");

-		#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT

+#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT

 			sp<MemoryHeapBase> reocrdheap = mRecordHeap;

 			sp<MemoryBase> recordbuffer = mRecordBuffers[mCurrentPreviewFrame];

-			uint8_t *recordframe = ((uint8_t *)reocrdheap->base()) + offset;

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+			ssize_t recordoffset = offset*3/4;

+			uint8_t *recordframe = ((uint8_t *)reocrdheap->getBase()) + recordoffset;

+			yuyv422_to_yuv420sp((unsigned char *)frame,(unsigned char *)recordframe,width,height);

+#else

+			ssize_t recordoffset = offset;

+			uint8_t *recordframe = ((uint8_t *)reocrdheap->getBase()) + recordoffset;

 			convert_rgb16_to_yuv420sp(frame,recordframe,width,height);

+#endif

 			mDataCbTimestamp(systemTime(),CAMERA_MSG_VIDEO_FRAME, recordbuffer, mCallbackCookie);

-		#else

+#else

 			android_atomic_dec(&mRecordBufCount);

 			//when use overlay, the preview format is the same as record

 			mDataCbTimestamp(systemTime(),CAMERA_MSG_VIDEO_FRAME, buffer, mCallbackCookie);

-		#endif

+#endif

 		}

 

 		mCurrentPreviewFrame = (mCurrentPreviewFrame + 1) % kBufferCount;

@@ -404,7 +446,7 @@ status_t AmlogicCameraHardware::startRecording()
 

 void AmlogicCameraHardware::stopRecording()

 {

-    mCamera->StopRecord();	

+    mCamera->StopRecord();

 	mRecordEnable = false;

 }

 

@@ -415,7 +457,9 @@ bool AmlogicCameraHardware::recordingEnabled()
 

 void AmlogicCameraHardware::releaseRecordingFrame(const sp<IMemory>& mem)

 {

+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

     android_atomic_inc(&mRecordBufCount);

+#endif

 //	LOGD("AmlogicCameraHardware::releaseRecordingFrame, %d", mRecordBufCount);

 }

 

@@ -477,32 +521,41 @@ status_t AmlogicCameraHardware::cancelAutoFocus()
 

 int AmlogicCameraHardware::pictureThread()

 {

+	int w, h,jpegsize = 0;

+	mParameters.getPictureSize(&w, &h);

     if (mMsgEnabled & CAMERA_MSG_SHUTTER)

         mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);

-

-    mCamera->TakePicture();

-    int w, h;

+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT

+	if(w > 640 && h > 480)

+		set_flash(true);

+#endif

+	mCamera->TakePicture();

+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT

+	if(w > 640 && h > 480)

+		set_flash(false);

+#endif

     sp<MemoryBase> mem = NULL;

     sp<MemoryHeapBase> jpgheap = NULL;

     sp<MemoryBase> jpgmem  = NULL;

-    mParameters.getPictureSize(&w, &h);

-    //Capture picture is RGB 24 BIT

+	//Capture picture is RGB 24 BIT

     if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {

-        mem = new MemoryBase(mRawHeap, 0, w * 3 * h);

-        mCamera->GetRawFrame((uint8_t*)mRawHeap->base());

-        //mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT

+		sp<MemoryBase> mem = new MemoryBase(mRawHeap, 0, w * 2 * h);//yuyv422

+#else

+		sp<MemoryBase> mem = new MemoryBase(mRawHeap, 0, w * 3 * h);//rgb888

+#endif

+		mCamera->GetRawFrame((uint8_t*)mRawHeap->getBase());

+		//mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);

     }

 

     if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {

         jpgheap = new MemoryHeapBase( w * 3 * h);

-        int jpegsize = 0;

-        mCamera->GetJpegFrame((uint8_t*)jpgheap->base(), &jpegsize);

-        jpgmem = new MemoryBase(jpgheap, 0, jpegsize);  

+  		mCamera->GetJpegFrame((uint8_t*)jpgheap->getBase(), &jpegsize);

+        jpgmem = new MemoryBase(jpgheap, 0, jpegsize);

         //mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, jpgmem, mCallbackCookie);

     }

-

     mCamera->TakePictureEnd();  // must uninit v4l2 buff first before callback, because the "start preview" may be called .

-    if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {

+	if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {

         mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);

     }

     if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {

@@ -549,7 +602,6 @@ status_t AmlogicCameraHardware::setParameters(const CameraParameters& params)
 {

     Mutex::Autolock lock(mLock);

     // to verify parameter

-

     if (strcmp(params.getPictureFormat(), "jpeg") != 0) {

         LOGE("Only jpeg still pictures are supported");

         return -1;

@@ -557,7 +609,7 @@ status_t AmlogicCameraHardware::setParameters(const CameraParameters& params)
 

     mParameters = params;

     initHeapLocked();

-

+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

     int zoom_level = mParameters.getInt(CameraParameters::KEY_ZOOM);

     char *p = (char *)mParameters.get(CameraParameters::KEY_ZOOM_RATIOS);

 

@@ -572,7 +624,7 @@ status_t AmlogicCameraHardware::setParameters(const CameraParameters& params)
 

         SYS_set_zoom(z);

     }

-

+#endif

     return mCamera->SetParameters(mParameters);//set to the real hardware

 }

 

@@ -629,7 +681,7 @@ void convert_rgb24_to_rgb16(uint8_t *src, uint8_t *dst, int width, int height)
 	int src_len = width*height*3;

     int i = 0;

 	int j = 0;

-    

+

     for (i = 0; i < src_len; i += 3)

     {

 		dst[j] = (src[i]&0x1f) | (src[i+1]>>5);

@@ -638,8 +690,8 @@ void convert_rgb24_to_rgb16(uint8_t *src, uint8_t *dst, int width, int height)
     }

 }

 

-

-void convert_rgb16_to_yuv420sp(uint8_t *rgb, uint8_t *yuv, int width, int height)

+#define swap_cbcr

+static void convert_rgb16_to_yuv420sp(uint8_t *rgb, uint8_t *yuv, int width, int height)

 {

 	int iy =0, iuv = 0;

     uint8_t* buf_y = yuv;

@@ -667,18 +719,184 @@ void convert_rgb16_to_yuv420sp(uint8_t *rgb, uint8_t *yuv, int width, int height
                 } else if (u < 0) {

                     u = 0;

                 }

-                buf_uv[iuv++] = u; 

                 v = 0.51179 * val_r - 0.429688 * val_g - 0.08203 * val_b  + 128;

                 if (v > 255) {

                     v = 255;

                 } else if (v < 0) {

                     v = 0;

                 }

-                buf_uv[iuv++] = v; 

+#ifdef swap_cbcr

+                buf_uv[iuv++] = v;

+                buf_uv[iuv++] = u;

+#else

+                buf_uv[iuv++] = u;

+                buf_uv[iuv++] = v;

+#endif

             }

         }

 }

 }

 

+static inline void yuv_to_rgb16(unsigned char y,unsigned char u,unsigned char v,unsigned char *rgb)

+{

+    register int r,g,b;

+    int rgb16;

+

+    r = (1192 * (y - 16) + 1634 * (v - 128) ) >> 10;

+    g = (1192 * (y - 16) - 833 * (v - 128) - 400 * (u -128) ) >> 10;

+    b = (1192 * (y - 16) + 2066 * (u - 128) ) >> 10;

+

+    r = r > 255 ? 255 : r < 0 ? 0 : r;

+    g = g > 255 ? 255 : g < 0 ? 0 : g;

+    b = b > 255 ? 255 : b < 0 ? 0 : b;

+

+    rgb16 = (int)(((r >> 3)<<11) | ((g >> 2) << 5)| ((b >> 3) << 0));

+

+    *rgb = (unsigned char)(rgb16 & 0xFF);

+    rgb++;

+    *rgb = (unsigned char)((rgb16 & 0xFF00) >> 8);

+

+}

+

+void yuyv422_to_rgb16(unsigned char *buf, unsigned char *rgb, int width, int height)

+{

+    int x,y,z=0;

+    int blocks;

+

+    blocks = (width * height) * 2;

+

+    for (y = 0; y < blocks; y+=4) {

+        unsigned char Y1, Y2, U, V;

+

+        Y1 = buf[y + 0];

+        U = buf[y + 1];

+        Y2 = buf[y + 2];

+        V = buf[y + 3];

+

+        yuv_to_rgb16(Y1, U, V, &rgb[y]);

+        yuv_to_rgb16(Y2, U, V, &rgb[y + 2]);

+    }

+}

+

+void yuyv422_to_yuv420sp(unsigned char *bufsrc, unsigned char *bufdest, int width, int height)

+{

+    unsigned char *ptrsrcy1, *ptrsrcy2;

+    unsigned char *ptrsrcy3, *ptrsrcy4;

+    unsigned char *ptrsrccb1, *ptrsrccb2;

+    unsigned char *ptrsrccb3, *ptrsrccb4;

+    unsigned char *ptrsrccr1, *ptrsrccr2;

+    unsigned char *ptrsrccr3, *ptrsrccr4;

+    int srcystride, srcccstride;

+

+    ptrsrcy1  = bufsrc ;

+    ptrsrcy2  = bufsrc + (width<<1) ;

+    ptrsrcy3  = bufsrc + (width<<1)*2 ;

+    ptrsrcy4  = bufsrc + (width<<1)*3 ;

+

+    ptrsrccb1 = bufsrc + 1;

+    ptrsrccb2 = bufsrc + (width<<1) + 1;

+    ptrsrccb3 = bufsrc + (width<<1)*2 + 1;

+    ptrsrccb4 = bufsrc + (width<<1)*3 + 1;

+

+    ptrsrccr1 = bufsrc + 3;

+    ptrsrccr2 = bufsrc + (width<<1) + 3;

+    ptrsrccr3 = bufsrc + (width<<1)*2 + 3;

+    ptrsrccr4 = bufsrc + (width<<1)*3 + 3;

+

+    srcystride  = (width<<1)*3;

+    srcccstride = (width<<1)*3;

+

+    unsigned char *ptrdesty1, *ptrdesty2;

+    unsigned char *ptrdesty3, *ptrdesty4;

+    unsigned char *ptrdestcb1, *ptrdestcb2;

+    unsigned char *ptrdestcr1, *ptrdestcr2;

+    int destystride, destccstride;

+

+    ptrdesty1 = bufdest;

+    ptrdesty2 = bufdest + width;

+    ptrdesty3 = bufdest + width*2;

+    ptrdesty4 = bufdest + width*3;

+

+    ptrdestcb1 = bufdest + width*height;

+    ptrdestcb2 = bufdest + width*height + width;

+

+    ptrdestcr1 = bufdest + width*height + 1;

+    ptrdestcr2 = bufdest + width*height + width + 1;

+

+    destystride  = (width)*3;

+    destccstride = width;

+

+    int i, j;

+

+    for(j=0; j<(height/4); j++)

+    {

+        for(i=0;i<(width/2);i++)

+        {

+            (*ptrdesty1++) = (*ptrsrcy1);

+            (*ptrdesty2++) = (*ptrsrcy2);

+            (*ptrdesty3++) = (*ptrsrcy3);

+            (*ptrdesty4++) = (*ptrsrcy4);

+

+            ptrsrcy1 += 2;

+            ptrsrcy2 += 2;

+            ptrsrcy3 += 2;

+            ptrsrcy4 += 2;

+

+            (*ptrdesty1++) = (*ptrsrcy1);

+            (*ptrdesty2++) = (*ptrsrcy2);

+            (*ptrdesty3++) = (*ptrsrcy3);

+            (*ptrdesty4++) = (*ptrsrcy4);

+

+            ptrsrcy1 += 2;

+            ptrsrcy2 += 2;

+            ptrsrcy3 += 2;

+            ptrsrcy4 += 2;

+

+            (*ptrdestcb1) = (*ptrsrccb1);

+            (*ptrdestcb2) = (*ptrsrccb3);

+            ptrdestcb1 += 2;

+            ptrdestcb2 += 2;

+

+            ptrsrccb1 += 4;

+            ptrsrccb3 += 4;

+

+            (*ptrdestcr1) = (*ptrsrccr1);

+            (*ptrdestcr2) = (*ptrsrccr3);

+            ptrdestcr1 += 2;

+            ptrdestcr2 += 2;

+

+            ptrsrccr1 += 4;

+            ptrsrccr3 += 4;

+

+        }

+

+

+        /* Update src pointers */

+        ptrsrcy1  += srcystride;

+        ptrsrcy2  += srcystride;

+        ptrsrcy3  += srcystride;

+        ptrsrcy4  += srcystride;

+

+        ptrsrccb1 += srcccstride;

+        ptrsrccb3 += srcccstride;

+

+        ptrsrccr1 += srcccstride;

+        ptrsrccr3 += srcccstride;

+

+

+        /* Update dest pointers */

+        ptrdesty1 += destystride;

+        ptrdesty2 += destystride;

+        ptrdesty3 += destystride;

+        ptrdesty4 += destystride;

+

+        ptrdestcb1 += destccstride;

+        ptrdestcb2 += destccstride;

+

+        ptrdestcr1 += destccstride;

+        ptrdestcr2 += destccstride;

+

+    }

+}

 

 

diff --git a/AmlogicCameraHardware.h b/AmlogicCameraHardware.h
index 2765722..ede6fd8 100755
--- a/AmlogicCameraHardware.h
+++ b/AmlogicCameraHardware.h
@@ -7,7 +7,9 @@
 #include <binder/MemoryBase.h>

 #include <binder/MemoryHeapBase.h>

 

+#ifndef AMLOGIC_USB_CAMERA_SUPPORT

 #define AMLOGIC_CAMERA_OVERLAY_SUPPORT 1

+#endif

 

 namespace android {

 

@@ -73,8 +75,11 @@ public:
     static sp<CameraHardwareInterface> createInstance(int CamId);

 

 #ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

-    virtual bool	useOverlay() {return true;}

-    virtual status_t	setOverlay(const sp<Overlay> &overlay);

+	virtual bool		useOverlay() {return true;}

+    virtual status_t     setOverlay(const sp<Overlay> &overlay);

+#else

+	virtual bool		useOverlay() {return false;}

+

 #endif

 

 private:

@@ -133,12 +138,14 @@ private:
     CameraParameters    mParameters;

 

     sp<MemoryHeapBase>  mPreviewHeap;

+    sp<MemoryHeapBase>  mHeap;

     sp<MemoryHeapBase>  mRawHeap;

     sp<MemoryBase>      mBuffers[kBufferCount];

-

+    sp<MemoryBase>      mPreviewBuffers[kBufferCount];

     //FakeCamera          *mFakeCamera;

     bool                mPreviewRunning;

     int                 mPreviewFrameSize;

+    int                  mHeapSize;	

 

     // protected by mLock

     sp<PreviewThread>   mPreviewThread;

diff --git a/Android.mk b/Android.mk
index 6d26c0e..77fb41b 100755
--- a/Android.mk
+++ b/Android.mk
@@ -16,18 +16,21 @@ LOCAL_SHARED_LIBRARIES := \
 ifeq ($(BOARD_HAVE_MULTI_CAMERAS),true)
 	LOCAL_CFLAGS += -DAMLOGIC_MULTI_CAMERA_SUPPORT
 endif
-    
-LOCAL_C_INCLUDES += $ANDROID_BUILD_TOP/kernel/include/
 
-#USE V4L2 Camera 
-LOCAL_SRC_FILES += jpegenc/amljpeg_enc.c
-LOCAL_SRC_FILES += AmlogicCameraHardware.cpp V4L2/V4L2Camera.cpp V4L2/CameraSetting.cpp
+ifeq ($(BOARD_USE_USB_CAMERA),true)
+	LOCAL_CFLAGS += -DAMLOGIC_USB_CAMERA_SUPPORT
+endif
 
-ifeq ($(BUILD_CUSTOMIZE_CAMERA_SETTING),true)
-LOCAL_CFLAGS += -DUSE_CUSTOMIZE_CAMERA_SETTING
-LOCAL_STATIC_LIBRARIES := libcamera_customize
+ifeq ($(BOARD_HAVE_FLASHLIGHT),true)
+	LOCAL_CFLAGS += -DAMLOGIC_FLASHLIGHT_SUPPORT
 endif
 
+#LOCAL_C_INCLUDES += $ANDROID_BUILD_TOP/kernel/include/
+
+#USE V4L2 Camera 
+LOCAL_SRC_FILES += jpegenc/amljpeg_enc.c
+LOCAL_SRC_FILES += AmlogicCameraHardware.cpp V4L2/V4L2Camera.cpp V4L2/CameraSetting.cpp V4L2/OpCameraHardware.c
+
 #USE FAKECAMERA
 #LOCAL_SRC_FILES += AmlogicCameraHardware.cpp FakeCamera/FakeCamera.cpp
 
diff --git a/V4L2/CameraSetting.cpp b/V4L2/CameraSetting.cpp
index f687702..90010ba 100755
--- a/V4L2/CameraSetting.cpp
+++ b/V4L2/CameraSetting.cpp
@@ -1,9 +1,19 @@
 

 #include <camera/CameraHardwareInterface.h>

 #include "CameraSetting.h"

-

+#include "amlogic_camera_para.h"

+

+extern "C" {

+int set_white_balance(int camera_fd,const char *swb);

+int SetExposure(int camera_fd,const char *sbn);

+int set_effect(int camera_fd,const char *sef);

+int set_banding(int camera_fd,const char *snm);

+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT

+int set_flash_mode(const char *sfm);

+#endif

+}

 namespace android {

-status_t	CameraSetting::InitParameters(CameraParameters& pParameters)

+status_t	CameraSetting::InitParameters(CameraParameters& pParameters,String8 PrevFrameSize,String8 PicFrameSize)

 {

 	LOGE("use default InitParameters");

 	//set the limited & the default parameter

@@ -17,20 +27,17 @@ status_t	CameraSetting::InitParameters(CameraParameters& pParameters)
 	pParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,"15,20");

 	pParameters.setPreviewFrameRate(15);

 

-	pParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,"640x480");

-	pParameters.setPreviewSize(640, 480);

-

-	pParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, "800x600");

-	pParameters.setPictureSize(800,600);

-

 	//must have >2 sizes and contain "0x0"

 	pParameters.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, "180x160,0x0");

 	pParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 180);

 	pParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 160);

 

-	pParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,CameraParameters::FOCUS_MODE_AUTO);		

+	pParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,CameraParameters::FOCUS_MODE_AUTO);

 	pParameters.set(CameraParameters::KEY_FOCUS_MODE,CameraParameters::FOCUS_MODE_AUTO);

 

+	pParameters.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,"50hz,60hz");

+	pParameters.set(CameraParameters::KEY_ANTIBANDING,"50hz");

+

 	pParameters.set(CameraParameters::KEY_FOCAL_LENGTH,"4.31");

 

 	pParameters.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE,"54.8");

@@ -40,30 +47,39 @@ status_t	CameraSetting::InitParameters(CameraParameters& pParameters)
 

 	pParameters.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,"auto,daylight,incandescent,fluorescent");

 	pParameters.set(CameraParameters::KEY_WHITE_BALANCE,"auto");

-	

-	pParameters.set(CameraParameters::KEY_SUPPORTED_EFFECTS,"none,negative,sepia");        

-	pParameters.set(CameraParameters::KEY_EFFECT,"none");

-

-	//pParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,"auto,on,off,torch");		

-	//pParameters.set(CameraParameters::KEY_FLASH_MODE,"auto");

 

-	//pParameters.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,"auto,night,snow");		

+	pParameters.set(CameraParameters::KEY_SUPPORTED_EFFECTS,"none,negative,sepia");

+	pParameters.set(CameraParameters::KEY_EFFECT,"none");

+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT

+	pParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,"on,off,torch");

+	pParameters.set(CameraParameters::KEY_FLASH_MODE,"on");

+#endif

+	//pParameters.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,"auto,night,snow");

 	//pParameters.set(CameraParameters::KEY_SCENE_MODE,"auto");

 

-	pParameters.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,4);		

+	pParameters.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,4);

 	pParameters.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,-4);

-	pParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,1);		

+	pParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,1);

 	pParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,0);

 

 #if 1

 	pParameters.set(CameraParameters::KEY_ZOOM_SUPPORTED,CameraParameters::TRUE);

 	pParameters.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,1);

-	

+

 	pParameters.set(CameraParameters::KEY_ZOOM_RATIOS,"100,120,140,160,180,200,220,280,300");

-	pParameters.set(CameraParameters::KEY_MAX_ZOOM,8);	//think the zoom ratios as a array, the max zoom is the max index	

+	pParameters.set(CameraParameters::KEY_MAX_ZOOM,8);	//think the zoom ratios as a array, the max zoom is the max index

 	pParameters.set(CameraParameters::KEY_ZOOM,0);//default should be 0

 #endif

-

+	pParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,PrevFrameSize);

+	if(PrevFrameSize.find("800x600") != -1)

+		pParameters.setPreviewSize(800, 600);

+	else

+		pParameters.setPreviewSize(640, 480);

+	pParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, PicFrameSize);

+	if(PrevFrameSize.find("1600x1200") != -1)

+		pParameters.setPictureSize(1600, 1200);

+	else

+		pParameters.setPictureSize(640, 480);

 	return NO_ERROR;

 }

 

@@ -84,7 +100,32 @@ status_t	CameraSetting::SetParameters(CameraParameters& pParameters)
 	}

 

 	m_hParameter = pParameters;

-

+	const char *white_balance=NULL;

+	const char *exposure=NULL;

+	const char *effect=NULL;

+	//const char *night_mode=NULL;

+	const char *qulity=NULL;

+	const char *banding=NULL;

+	const char *flashmode=NULL;

+

+	white_balance=pParameters.get(CameraParameters::KEY_WHITE_BALANCE);

+	exposure=pParameters.get(CameraParameters::KEY_EXPOSURE_COMPENSATION);

+	effect=pParameters.get(CameraParameters::KEY_EFFECT);

+	banding=pParameters.get(CameraParameters::KEY_ANTIBANDING);

+	qulity=pParameters.get(CameraParameters::KEY_JPEG_QUALITY);

+	flashmode = pParameters.get(CameraParameters::KEY_FLASH_MODE);

+	if(exposure)

+		SetExposure(m_iDevFd,exposure);

+	if(white_balance)

+		set_white_balance(m_iDevFd,white_balance);

+	if(effect)

+		set_effect(m_iDevFd,effect);

+	if(banding)

+		set_banding(m_iDevFd,banding);

+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT

+	if(flashmode)

+		set_flash_mode(flashmode);

+#endif

 	return rtn;

 }

 

@@ -95,7 +136,7 @@ static char* sCameraMirrorMode[] = {
 };

 

 

-const char* CameraSetting::GetInfo(int InfoId)

+/*const char* CameraSetting::GetInfo(int InfoId)

 {

 	LOGE("use default GetInfo");

 	switch(InfoId)

@@ -104,8 +145,6 @@ const char* CameraSetting::GetInfo(int InfoId)
 			return "Amlogic";

 		case CAMERA_EXIF_MODEL:

 			return "DEFUALT";

-        case CAMERA_MIRROR_MODE:

-            return (const char*)sCameraMirrorMode[m_iCamId];

 		default:

 			return NULL;

 	}

@@ -117,15 +156,12 @@ int	CameraSetting::GetDelay(int Processid)
 		return 1000;

 	else

 		return 0;

-}

-

-

+}*/

 

-#ifndef USE_CUSTOMIZE_CAMERA_SETTING

 CameraSetting* getCameraSetting()

 {

 	LOGE("return default CameraSetting");

 	return new CameraSetting();

 }

-#endif

+

 }

diff --git a/V4L2/CameraSetting.h b/V4L2/CameraSetting.h
index cc063d9..2db4a86 100755
--- a/V4L2/CameraSetting.h
+++ b/V4L2/CameraSetting.h
@@ -7,8 +7,8 @@
 namespace android {

 

 //used as getinfo parameters

-#define CAMERA_EXIF_MAKE (0)

-#define CAMERA_EXIF_MODEL (1)

+//#define CAMERA_EXIF_MAKE (0)

+//#define CAMERA_EXIF_MODEL (1)

 #define CAMERA_MIRROR_MODE (2)

 

 //used as  GetDelay parameters

@@ -24,14 +24,14 @@ class CameraSetting
 		int		m_iCamId;

 		char*	m_pDevName;

 		CameraParameters m_hParameter;

-		

-		virtual status_t	InitParameters(CameraParameters& pParameters);

+

+		virtual status_t	InitParameters(CameraParameters& pParameters,String8 PrevFrameSize,String8 PicFrameSize);

 		virtual status_t	SetParameters(CameraParameters& pParameters);

-		virtual const char* GetInfo(int InfoId);

+		//virtual const char* GetInfo(int InfoId);

 

 		//return the time (in us) cost for process,this is used by preview thread to decide how many times to sleep between get frames

 		//most time it is the cost time of function get previewframe.

-		virtual int  		GetDelay(int Processid);

+		//virtual int  		GetDelay(int Processid);

 };

 

 CameraSetting* getCameraSetting();

diff --git a/V4L2/OpCameraHardware.c b/V4L2/OpCameraHardware.c
new file mode 100755
index 0000000..d54fb22
--- a/dev/null
+++ b/V4L2/OpCameraHardware.c
@@ -0,0 +1,223 @@
+#define LOG_NDEBUG 0
+//#define NDEBUG 0
+#define LOG_TAG "OpCameraHardware"
+#include <utils/Log.h>
+#include "amlogic_camera_para.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#include <cutils/properties.h>
+#include <linux/videodev2.h>
+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT
+#include <media/amlogic/flashlight.h>
+#include <stdbool.h>
+int get_flash_mode(void);
+#endif
+
+int set_white_balance(int camera_fd,const char *swb)
+{
+ 	int ret = 0;
+	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	ctl.id = V4L2_CID_DO_WHITE_BALANCE;
+
+	if(strcasecmp(swb,"auto")==0)
+		ctl.value=CAM_WB_AUTO;
+	else if(strcasecmp(swb,"daylight")==0)
+		ctl.value=CAM_WB_DAYLIGHT;
+	else if(strcasecmp(swb,"incandescent")==0)
+		ctl.value=CAM_WB_INCANDESCENCE;
+	else if(strcasecmp(swb,"fluorescent")==0)
+		ctl.value=CAM_WB_FLUORESCENT;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+	return ret ;
+}
+
+int SetExposure(int camera_fd,const char *sbn)
+{
+ 	int ret = 0;
+	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	ctl.id = V4L2_CID_EXPOSURE;
+
+	if(strcasecmp(sbn,"4")==0)
+		ctl.value=EXPOSURE_P4_STEP;
+	else if(strcasecmp(sbn,"3")==0)
+		ctl.value=EXPOSURE_P3_STEP;
+	else if(strcasecmp(sbn,"2")==0)
+		ctl.value=EXPOSURE_P2_STEP;
+	else if(strcasecmp(sbn,"1")==0)
+		ctl.value=EXPOSURE_P1_STEP;
+	else if(strcasecmp(sbn,"0")==0)
+		ctl.value=EXPOSURE_0_STEP;
+	else if(strcasecmp(sbn,"-1")==0)
+		ctl.value=EXPOSURE_N1_STEP;
+	else if(strcasecmp(sbn,"-2")==0)
+		ctl.value=EXPOSURE_N2_STEP;
+	else if(strcasecmp(sbn,"-3")==0)
+		ctl.value=EXPOSURE_N3_STEP;
+	else if(strcasecmp(sbn,"-4")==0)
+		ctl.value=EXPOSURE_N4_STEP;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+
+	return ret ;
+}
+
+
+int set_effect(int camera_fd,const char *sef)
+{
+ 	int ret = 0;
+	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	ctl.id = V4L2_CID_COLORFX;
+
+	if(strcasecmp(sef,"none")==0)
+		ctl.value=CAM_EFFECT_ENC_NORMAL;
+	else if(strcasecmp(sef,"negative")==0)
+		ctl.value=CAM_EFFECT_ENC_COLORINV;
+	else if(strcasecmp(sef,"sepia")==0)
+		ctl.value=CAM_EFFECT_ENC_SEPIA;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+
+	return ret ;
+}
+
+int set_night_mode(int camera_fd,const char *snm)
+{
+ 	int ret = 0;
+ 	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	if(strcasecmp(snm,"auto")==0)
+		ctl.value=CAM_NM_AUTO;
+	else if(strcasecmp(snm,"night")==0)
+		ctl.value=CAM_NM_ENABLE;
+
+	ctl.id = V4L2_CID_DO_WHITE_BALANCE;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+	return ret ;
+}
+
+int set_banding(int camera_fd,const char *snm)
+{
+ 	int ret = 0;
+ 	struct v4l2_control ctl;
+	if(camera_fd<0)
+		return -1;
+
+	if(strcasecmp(snm,"50hz")==0)
+		ctl.value=CAM_NM_AUTO;
+	else if(strcasecmp(snm,"60hz")==0)
+		ctl.value=CAM_NM_ENABLE;
+
+	ctl.id = V4L2_CID_WHITENESS;
+
+	if(ioctl(camera_fd, VIDIOC_S_CTRL, &ctl)<0)
+	{
+		ret = -1;
+		LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
+	}
+	return ret ;
+}
+
+#ifdef AMLOGIC_FLASHLIGHT_SUPPORT
+int set_flash(bool mode)
+{
+ 	int flag = 0;
+	FILE* fp = NULL;
+	if(mode){
+		flag = get_flash_mode();
+		if(flag == FLASHLIGHT_OFF ||flag == FLASHLIGHT_AUTO)//handle AUTO case on camera driver
+			return 0;
+		else if(flag == -1)
+			return -1;
+	}
+	fp = fopen("/sys/class/flashlight/flashlightctrl","w");
+	if(fp == NULL){
+		LOGE("open file fail\n");
+		return -1;
+	}
+	fputc((int)(mode+'0'),fp);
+	fclose(fp);
+	return 0;
+}
+
+int set_flash_mode(const char *sfm)
+{
+ 	int value = 0;
+	FILE* fp = NULL;
+	if(strcasecmp(sfm,"auto")==0)
+		value=FLASHLIGHT_AUTO;
+	else if(strcasecmp(sfm,"on")==0)
+		value=FLASHLIGHT_ON;
+	else if(strcasecmp(sfm,"off")==0)
+		value=FLASHLIGHT_OFF;
+	else if(strcasecmp(sfm,"off")==0)
+		value=FLASHLIGHT_TORCH;
+	else
+		value=FLASHLIGHT_OFF;
+
+	fp = fopen("/sys/class/flashlight/flashlightflag","w");
+	if(fp == NULL){
+		LOGE("open file fail\n");
+		return -1;
+	}
+	fputc((int)(value+'0'),fp);
+	fclose(fp);
+	if(value == FLASHLIGHT_TORCH)//open flashlight immediately
+		set_flash(true);
+	else if(value == FLASHLIGHT_OFF)
+		set_flash(false);
+	return 0 ;
+}
+
+int get_flash_mode(void)
+{
+	int value = 0;
+	FILE* fp = NULL;
+
+	fp = fopen("/sys/class/flashlight/flashlightflag","r");
+	if(fp == NULL){
+		LOGE("open file fail\n");
+		return -1;
+	}
+	value=fgetc(fp);
+	fclose(fp);
+	return value-'0';
+}
+#endif
+
diff --git a/V4L2/V4L2Camera.cpp b/V4L2/V4L2Camera.cpp
index f053662..5ae2505 100755
--- a/V4L2/V4L2Camera.cpp
+++ b/V4L2/V4L2Camera.cpp
@@ -21,11 +21,12 @@
 #include <unistd.h>

 
 extern "C" unsigned char* getExifBuf(char** attrlist, int attrCount, int* exifLen,int thumbnailLen,char* thumbnaildata);

+extern void yuyv422_to_rgb16(unsigned char *buf, unsigned char *rgb, int width, int height);
 namespace android {

 

-#define V4L2_PREVIEW_BUFF_NUM (1)

+#define V4L2_PREVIEW_BUFF_NUM (6)

 #define V4L2_TAKEPIC_BUFF_NUM (1)

-

+extern void yuyv422_to_rgb24(unsigned char *buf, unsigned char *rgb, int width, int height);

 

 V4L2Camera::V4L2Camera(char* devname,int camid)

 {

@@ -117,7 +118,23 @@ status_t	V4L2Camera::Close()
 

 status_t	V4L2Camera::InitParameters(CameraParameters& pParameters)

 {

-	return m_pSetting->InitParameters(pParameters);

+	String8 prevFrameSize(""),picFrameSize("");
+	int ret = NO_ERROR,prevPixelFmt,picPixelFmt;
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+	prevPixelFmt = V4L2_PIX_FMT_YUYV;
+	picPixelFmt = V4L2_PIX_FMT_YUYV;
+#else
+	prevPixelFmt = V4L2_PIX_FMT_NV21;
+	picPixelFmt = V4L2_PIX_FMT_RGB24;
+#endif
+	ret = V4L2_GetValidFrameSize(prevPixelFmt,prevFrameSize);
+	if(ret != NO_ERROR)
+		return ret;
+	ret = V4L2_GetValidFrameSize(picPixelFmt,picFrameSize);
+	if(ret != NO_ERROR)
+		return ret;
+	ret = m_pSetting->InitParameters(pParameters,prevFrameSize,picFrameSize);

+	return ret;
 }

 

 //write parameter to v4l2 driver,

@@ -129,10 +146,20 @@ status_t	V4L2Camera::SetParameters(CameraParameters& pParameters)
 

 status_t	V4L2Camera::StartPreview()

 {

-	int w,h;

+	int w,h,pixelFormat;

 	m_bFirstFrame = true;

-	m_pSetting->m_hParameter.getPreviewSize(&w,&h);

-	if( (NO_ERROR == V4L2_BufferInit(w,h,V4L2_PREVIEW_BUFF_NUM,V4L2_PIX_FMT_NV21))

+	if(NO_ERROR != Open())
+		return UNKNOWN_ERROR;
+	if(m_pSetting != NULL )
+		m_pSetting->m_hParameter.getPreviewSize(&w,&h);

+	else
+		LOGE("%s,%d m_pSetting=NULL",__FILE__, __LINE__);
+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+	pixelFormat = V4L2_PIX_FMT_YUYV;
+#else
+	pixelFormat = V4L2_PIX_FMT_NV21;
+#endif
+	if( (NO_ERROR == V4L2_BufferInit(w,h,V4L2_PREVIEW_BUFF_NUM,pixelFormat))

 		&& (V4L2_StreamOn() == NO_ERROR))

 		return NO_ERROR;

 	else

@@ -142,16 +169,26 @@ status_t	V4L2Camera::StopPreview()
 {

 	if( (NO_ERROR == V4L2_StreamOff())

 		&& (V4L2_BufferUnInit() == NO_ERROR))

+	{
+		Close();
 		return NO_ERROR;

+	}
 	else

 		return UNKNOWN_ERROR;

 }

 

 status_t	V4L2Camera::TakePicture()

 {

-	int w,h;

+	int w,h,pixelFormat;

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+	pixelFormat = V4L2_PIX_FMT_YUYV;
+#else
+	pixelFormat = V4L2_PIX_FMT_RGB24;
+#endif
+	if(NO_ERROR != Open())
+		return UNKNOWN_ERROR;
 	m_pSetting->m_hParameter.getPictureSize(&w,&h);

-	V4L2_BufferInit(w,h,V4L2_TAKEPIC_BUFF_NUM,V4L2_PIX_FMT_RGB24);

+	V4L2_BufferInit(w,h,V4L2_TAKEPIC_BUFF_NUM,pixelFormat);

 	V4L2_BufferEnQue(0);

 	V4L2_StreamOn();

 	m_iPicIdx = V4L2_BufferDeQue();

@@ -162,14 +199,17 @@ status_t	V4L2Camera::TakePicture()
 status_t	V4L2Camera::TakePictureEnd()

 {

 	m_iPicIdx = -1;

-	return 	V4L2_BufferUnInit();

+	V4L2_BufferUnInit();

+	return Close();
 }

 
 status_t	V4L2Camera::GetPreviewFrame(uint8_t* framebuf)
 {
+	int i=0;
 	if(m_bFirstFrame)
 	{
-		V4L2_BufferEnQue(0);
+		for(i=0;i<V4L2_PREVIEW_BUFF_NUM;i++)
+			V4L2_BufferEnQue(i);
 		m_bFirstFrame = false;
 		return NO_INIT;
 	}
@@ -188,15 +228,21 @@ status_t	V4L2Camera::GetPreviewFrame(uint8_t* framebuf)
 	}
 }
 
-status_t	V4L2Camera::GetRawFrame(uint8_t* framebuf) 

+status_t	V4L2Camera::GetRawFrame(uint8_t* framebuf)

 {

 	if(m_iPicIdx!=-1)

 	{

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+		int w,h;
+		m_pSetting->m_hParameter.getPictureSize(&w,&h);
+		yuyv422_to_rgb16((unsigned char*)pV4L2Frames[m_iPicIdx],framebuf,w,h);
+#else
 		memcpy(framebuf,pV4L2Frames[m_iPicIdx],pV4L2FrameSize[m_iPicIdx]);

+#endif
 	}

 	else

 		LOGD("GetRawFraem index -1");

-	return NO_ERROR;	

+	return NO_ERROR;

 }

 

 

@@ -241,20 +287,20 @@ int extraSmallImg(unsigned char* SrcImg,int SrcW,int SrcH,unsigned char* DstImg,
 }

 

 int V4L2Camera::GenExif(unsigned char** pExif,int* exifLen,uint8_t* framebuf)

-{	

+{

 	#define MAX_EXIF_COUNT (20)

-	char* exiflist[MAX_EXIF_COUNT]={0};

+	char* exiflist[MAX_EXIF_COUNT]={0},CameraMake[20],CameraModel[20];

 	int i = 0,curend = 0;

 

 	//Make

 	exiflist[i] = new char[64];

-	const char* CameraMake = m_pSetting->GetInfo(CAMERA_EXIF_MAKE);

+	property_get("ro.camera.exif.make",CameraMake,"Amlogic");

 	sprintf(exiflist[i],"Make=%d %s",strlen(CameraMake),CameraMake);

 	i++;

 

 	//Model

 	exiflist[i] = new char[64];

-	const char* CameraModel = m_pSetting->GetInfo(CAMERA_EXIF_MODEL);

+	property_get("ro.camera.exif.model",CameraModel,"DEFUALT");

 	sprintf(exiflist[i],"Model=%d %s",strlen(CameraModel),CameraModel);

 	i++;

 

@@ -315,7 +361,7 @@ int V4L2Camera::GenExif(unsigned char** pExif,int* exifLen,uint8_t* framebuf)
 		exiflist[i] = new char[256];

 		sprintf(exiflist[i],"GPSLatitude=%d %d/%d,%d/%d,%d/%d",CalIntLen(latitudedegree)+CalIntLen(latitudeminuts_int)+CalIntLen(latituseconds_int)+8,latitudedegree,1,latitudeminuts_int,1,latituseconds_int,1);

 		i++;

-		

+

 		exiflist[i] = new char[64];

 		if(offset == 1)

 			sprintf(exiflist[i],"GPSLatitudeRef=1 S");

@@ -416,7 +462,7 @@ int V4L2Camera::GenExif(unsigned char** pExif,int* exifLen,uint8_t* framebuf)
 	if(processmethod!=NULL)

 	{

 		char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };//asicii

-		

+

 		exiflist[i] = new char[128];

 		int len = sizeof(ExifAsciiPrefix)+strlen(processmethod);

 		sprintf(exiflist[i],"GPSProcessingMethod=%d ",len);

@@ -438,7 +484,7 @@ int V4L2Camera::GenExif(unsigned char** pExif,int* exifLen,uint8_t* framebuf)
 	int thumbnailsize = 0;

 	char* thumbnaildata = NULL;

 	int thumbnailwidth = m_pSetting->m_hParameter.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);

-	int thumbnailheight = m_pSetting->m_hParameter.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);	

+	int thumbnailheight = m_pSetting->m_hParameter.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);

 	if(thumbnailwidth > 0 )

 	{

 	//	LOGE("creat thumbnail data");

@@ -452,7 +498,7 @@ int V4L2Camera::GenExif(unsigned char** pExif,int* exifLen,uint8_t* framebuf)
 		enc.width = thumbnailwidth;

 		enc.height = thumbnailheight;

 		enc.quality = 90;

-		enc.idata = (unsigned char*)rgbdata;	

+		enc.idata = (unsigned char*)rgbdata;

 		enc.odata = (unsigned char*)thumbnaildata;

 		enc.ibuff_size =  thumbnailwidth*thumbnailheight*3;

 		enc.obuff_size =  thumbnailwidth*thumbnailheight*3;

@@ -480,7 +526,7 @@ int V4L2Camera::GenExif(unsigned char** pExif,int* exifLen,uint8_t* framebuf)
 	return 1;

 }

 

-status_t	V4L2Camera::GetJpegFrame(uint8_t* framebuf, int* jpegsize)

+status_t	V4L2Camera::GetJpegFrame(uint8_t* framebuf,int* jpegsize)

 {

 	*jpegsize = 0;

 	if(m_iPicIdx!=-1)

@@ -488,12 +534,24 @@ status_t	V4L2Camera::GetJpegFrame(uint8_t* framebuf, int* jpegsize)
 		unsigned char* exifcontent = NULL;

 		jpeg_enc_t enc;

 		m_pSetting->m_hParameter.getPictureSize(&enc.width,&enc.height);

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+		sp<MemoryHeapBase> rgbheap = new MemoryHeapBase( enc.width * 3 * enc.height);
+		yuyv422_to_rgb24((unsigned char*)pV4L2Frames[m_iPicIdx],(unsigned char *)rgbheap->getBase(),enc.width,enc.height);
+#endif
 		enc.quality= m_pSetting->m_hParameter.getInt(CameraParameters::KEY_JPEG_QUALITY);

-		enc.idata = (unsigned char*)pV4L2Frames[m_iPicIdx];	

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+		enc.idata = (unsigned char *)rgbheap->getBase();
+#else
+		enc.idata = (unsigned char*)pV4L2Frames[m_iPicIdx];

+#endif
 		enc.odata = (unsigned char*)framebuf;

 		enc.ibuff_size =  pV4L2FrameSize[m_iPicIdx];

 		enc.obuff_size =  pV4L2FrameSize[m_iPicIdx];

+#ifdef AMLOGIC_USB_CAMERA_SUPPORT
+		GenExif(&(exifcontent),&(enc.app1_data_size),(unsigned char*)rgbheap->getBase());
+#else
 		GenExif(&(exifcontent),&(enc.app1_data_size),(unsigned char*)pV4L2Frames[m_iPicIdx]);

+#endif
 		enc.data_in_app1=exifcontent+2;

 		*jpegsize = encode_jpeg(&enc);

 		if(exifcontent!=0)

@@ -504,12 +562,43 @@ status_t	V4L2Camera::GetJpegFrame(uint8_t* framebuf, int* jpegsize)
 		LOGE("GetRawFraem index -1");

 		return UNKNOWN_ERROR;

 	}

-	return NO_ERROR;		

+	return NO_ERROR;

 }

 

 

 //=======================================================================================

 //functions for set V4L2

+
+status_t	V4L2Camera::V4L2_GetValidFrameSize(unsigned int pixel_format,String8 &framesize)
+{
+	struct v4l2_frmsizeenum frmsize;
+	int i=0;
+	char tempwidth[5],tempheight[5];
+	memset(&frmsize,0,sizeof(v4l2_frmsizeenum));
+	for(i=0;;i++){
+		frmsize.index = i;
+		frmsize.pixel_format = pixel_format;
+		if(ioctl(m_pSetting->m_iDevFd, VIDIOC_ENUM_FRAMESIZES, &frmsize) == 0){
+			if(frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE){	//only support this type
+				sprintf(tempwidth,"%d",frmsize.discrete.width);
+				sprintf(tempheight,"%d",frmsize.discrete.height);
+				framesize.append(tempwidth);
+				framesize.append("x");
+				framesize.append(tempheight);
+				framesize.append(",");
+			}
+			else
+				break;
+		}
+		else
+			break;
+	}
+	if(framesize.length() == 0)
+		return UNKNOWN_ERROR;
+	else
+		return NO_ERROR;
+}
+
 status_t V4L2Camera::V4L2_BufferInit(int Buf_W,int Buf_H,int Buf_Num,int colorfmt)

 {

 	struct v4l2_format hformat;

@@ -518,9 +607,9 @@ status_t V4L2Camera::V4L2_BufferInit(int Buf_W,int Buf_H,int Buf_Num,int colorfm
 	hformat.fmt.pix.width = Buf_W;

 	hformat.fmt.pix.height = Buf_H;

 	hformat.fmt.pix.pixelformat = colorfmt;

-	if (ioctl(m_pSetting->m_iDevFd, VIDIOC_S_FMT, &hformat) == -1) 

+	if (ioctl(m_pSetting->m_iDevFd, VIDIOC_S_FMT, &hformat) == -1)

 	{

-		LOGE("V4L2_BufferInit VIDIOC_S_FMT fail");

+		LOGE("V4L2_BufferInit VIDIOC_S_FMT fail m_pSetting->m_iDevFd=%d width=%d height=%d pixelformat=(%c%c%c%c)",m_pSetting->m_iDevFd,hformat.fmt.pix.width,hformat.fmt.pix.height,colorfmt&0xff, (colorfmt>>8)&0xff, (colorfmt>>16)&0xff, (colorfmt>>24)&0xff);

 		return UNKNOWN_ERROR;

 	}

 

@@ -530,14 +619,14 @@ status_t V4L2Camera::V4L2_BufferInit(int Buf_W,int Buf_H,int Buf_Num,int colorfm
 	hbuf_req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

 	hbuf_req.memory = V4L2_MEMORY_MMAP;

 	hbuf_req.count = Buf_Num; //just set two frames for hal have cache buffer

-	if (ioctl(m_pSetting->m_iDevFd, VIDIOC_REQBUFS, &hbuf_req) == -1) 

+	if (ioctl(m_pSetting->m_iDevFd, VIDIOC_REQBUFS, &hbuf_req) == -1)

 	{

 		LOGE("V4L2_BufferInit VIDIOC_REQBUFS fail");

 		return UNKNOWN_ERROR;

 	}

 	else

 	{

-		if (hbuf_req.count < Buf_Num) 

+		if (hbuf_req.count < Buf_Num)

 		{

 		    LOGE("V4L2_BufferInit hbuf_req.count < Buf_Num");

 			return UNKNOWN_ERROR;

@@ -555,7 +644,7 @@ status_t V4L2Camera::V4L2_BufferInit(int Buf_W,int Buf_H,int Buf_Num,int colorfm
 			for(;i<Buf_Num;i++)

 			{

 				hbuf_query.index = i;

-				if (ioctl(m_pSetting->m_iDevFd, VIDIOC_QUERYBUF, &hbuf_query) == -1) 

+				if (ioctl(m_pSetting->m_iDevFd, VIDIOC_QUERYBUF, &hbuf_query) == -1)

 				{

 					LOGE("Memap V4L2 buffer Fail");

 					return UNKNOWN_ERROR;

@@ -571,7 +660,7 @@ status_t V4L2Camera::V4L2_BufferInit(int Buf_W,int Buf_H,int Buf_Num,int colorfm
 				}

 				/*

 				//enqueue buffer

-				if (ioctl(m_pSetting->m_iDevFd, VIDIOC_QBUF, &hbuf_query) == -1) 

+				if (ioctl(m_pSetting->m_iDevFd, VIDIOC_QBUF, &hbuf_query) == -1)

 				{

 					LOGE("GetPreviewFrame nque buffer fail");

 					return UNKNOWN_ERROR;

@@ -590,7 +679,7 @@ status_t V4L2Camera::V4L2_BufferUnInit()
 	{

 		//un-memmap

 		int i = 0;

-		for (; i < m_V4L2BufNum; i++) 

+		for (; i < m_V4L2BufNum; i++)

 		{

 			munmap(pV4L2Frames[i], pV4L2FrameSize[i]);

 			pV4L2Frames[i] = NULL;

@@ -612,7 +701,7 @@ status_t V4L2Camera::V4L2_BufferEnQue(int idx)
 	hbuf_query.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

 	hbuf_query.memory = V4L2_MEMORY_MMAP;//加和不加index有什么区别?

 	hbuf_query.index = idx;

-    if (ioctl(m_pSetting->m_iDevFd, VIDIOC_QBUF, &hbuf_query) == -1) 

+    if (ioctl(m_pSetting->m_iDevFd, VIDIOC_QBUF, &hbuf_query) == -1)

 	{

 		LOGE("V4L2_BufferEnQue fail");

 		return UNKNOWN_ERROR;

@@ -626,14 +715,15 @@ int  V4L2Camera::V4L2_BufferDeQue()
 	memset(&hbuf_query,0,sizeof(v4l2_buffer));

 	hbuf_query.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

 	hbuf_query.memory = V4L2_MEMORY_MMAP;//加和不加index有什么区别?

-    if (ioctl(m_pSetting->m_iDevFd, VIDIOC_DQBUF, &hbuf_query) == -1) 

+    if (ioctl(m_pSetting->m_iDevFd, VIDIOC_DQBUF, &hbuf_query) == -1)

 	{

 		LOGE("V4L2_StreamGet Deque buffer fail");

 		return -1;

     }

 

 	assert (hbuf_query.index < m_V4L2BufNum);

-	return hbuf_query.index;	

+	pV4L2FrameSize[hbuf_query.index] = hbuf_query.bytesused;
+	return hbuf_query.index;

 }

 

 status_t	V4L2Camera::V4L2_StreamOn()

@@ -663,4 +753,47 @@ extern CameraInterface* HAL_GetCameraInterface(int Id)
 		return new V4L2Camera("/dev/video1",1);

 }

 

+static inline void yuv_to_rgb24(unsigned char y,unsigned char u,unsigned char v,unsigned char *rgb)
+{
+    register int r,g,b;
+    int rgb24;
+
+    r = (1192 * (y - 16) + 1634 * (v - 128) ) >> 10;
+    g = (1192 * (y - 16) - 833 * (v - 128) - 400 * (u -128) ) >> 10;
+    b = (1192 * (y - 16) + 2066 * (u - 128) ) >> 10;
+
+    r = r > 255 ? 255 : r < 0 ? 0 : r;
+    g = g > 255 ? 255 : g < 0 ? 0 : g;
+    b = b > 255 ? 255 : b < 0 ? 0 : b;
+
+    rgb24 = (int)((r <<16) | (g  << 8)| b);
+
+    *rgb = (unsigned char)r;
+    rgb++;
+    *rgb = (unsigned char)g;
+    rgb++;
+    *rgb = (unsigned char)b;
+}
+
+void yuyv422_to_rgb24(unsigned char *buf, unsigned char *rgb, int width, int height)
+{
+    int x,y,z=0;
+    int blocks;
+
+    blocks = (width * height) * 2;
+
+    for (y = 0,z=0; y < blocks; y+=4,z+=6) {
+        unsigned char Y1, Y2, U, V;
+
+        Y1 = buf[y + 0];
+        U = buf[y + 1];
+        Y2 = buf[y + 2];
+        V = buf[y + 3];
+
+        yuv_to_rgb24(Y1, U, V, &rgb[z]);
+        yuv_to_rgb24(Y2, U, V, &rgb[z + 3]);
+
+    }
+}
+
 };

diff --git a/V4L2/V4L2Camera.h b/V4L2/V4L2Camera.h
index 9db70e2..0c81302 100755
--- a/V4L2/V4L2Camera.h
+++ b/V4L2/V4L2Camera.h
@@ -24,12 +24,13 @@ public:
 	status_t	SetParameters(CameraParameters& pParameters) ;

 	status_t	GetPreviewFrame(uint8_t* framebuf) ;

 	status_t	GetRawFrame(uint8_t* framebuf) ;

-	status_t	GetJpegFrame(uint8_t* framebuf, int* jpegsize) ;

+	status_t	GetJpegFrame(uint8_t* framebuf,int* jpegsize) ;

 	int			GetCamId() {return m_pSetting->m_iCamId;}

 

 protected:

 	//internal used for controling V4L2

-	status_t    V4L2_BufferInit(int Buf_W,int Buf_H,int Buf_Num,int colorfmt);

+	status_t	V4L2_GetValidFrameSize(unsigned int pixel_format,String8 &framesize);

+	status_t	V4L2_BufferInit(int Buf_W,int Buf_H,int Buf_Num,int colorfmt);

 	status_t 	V4L2_BufferUnInit();

 	status_t	V4L2_BufferEnQue(int idx);

 	int  		V4L2_BufferDeQue();//return the buffer index

diff --git a/V4L2/amlogic_camera_para.h b/V4L2/amlogic_camera_para.h
new file mode 100755
index 0000000..07ed2b9
--- a/dev/null
+++ b/V4L2/amlogic_camera_para.h
@@ -0,0 +1,148 @@
+/*

+ * TVIN Modules Exported Header File

+ *

+ * Author: Lin Xu <lin.xu@amlogic.com>

+ *         Bobby Yang <bo.yang@amlogic.com>

+ *

+ * Copyright (C) 2010 Amlogic Inc.

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License version 2 as

+ * published by the Free Software Foundation.

+ */

+

+

+#ifndef _AMLOGIC_CAMERA_PARA_H

+#define _AMLOGIC_CAMERA_PARA_H

+

+/*

+    below macro defined applied to camera driver

+*/

+typedef enum camera_light_mode_e {

+    ADVANCED_AWB = 0,

+    SIMPLE_AWB,

+    MANUAL_DAY,

+    MANUAL_A,

+    MANUAL_CWF,

+    MANUAL_CLOUDY,

+}camera_light_mode_t;

+

+typedef enum camera_saturation_e {

+    SATURATION_N4_STEP = 0,

+    SATURATION_N3_STEP,

+    SATURATION_N2_STEP,

+    SATURATION_N1_STEP,

+    SATURATION_0_STEP,

+    SATURATION_P1_STEP,

+    SATURATION_P2_STEP,

+    SATURATION_P3_STEP,

+    SATURATION_P4_STEP,

+}camera_saturation_t;

+

+

+typedef enum camera_brightness_e {

+    BRIGHTNESS_N4_STEP = 0,

+    BRIGHTNESS_N3_STEP,

+    BRIGHTNESS_N2_STEP,

+    BRIGHTNESS_N1_STEP,

+    BRIGHTNESS_0_STEP,

+    BRIGHTNESS_P1_STEP,

+    BRIGHTNESS_P2_STEP,

+    BRIGHTNESS_P3_STEP,

+    BRIGHTNESS_P4_STEP,

+}camera_brightness_t;

+

+typedef enum camera_contrast_e {

+    CONTRAST_N4_STEP = 0,

+    CONTRAST_N3_STEP,

+    CONTRAST_N2_STEP,

+    CONTRAST_N1_STEP,

+    CONTRAST_0_STEP,

+    CONTRAST_P1_STEP,

+    CONTRAST_P2_STEP,

+    CONTRAST_P3_STEP,

+    CONTRAST_P4_STEP,

+}camera_contrast_t;

+

+typedef enum camera_hue_e {

+    HUE_N180_DEGREE = 0,

+    HUE_N150_DEGREE,

+    HUE_N120_DEGREE,

+    HUE_N90_DEGREE,

+    HUE_N60_DEGREE,

+    HUE_N30_DEGREE,

+    HUE_0_DEGREE,

+    HUE_P30_DEGREE,

+    HUE_P60_DEGREE,

+    HUE_P90_DEGREE,

+    HUE_P120_DEGREE,

+    HUE_P150_DEGREE,

+}camera_hue_t;

+

+typedef enum camera_special_effect_e {

+    SPECIAL_EFFECT_NORMAL = 0,

+    SPECIAL_EFFECT_BW,

+    SPECIAL_EFFECT_BLUISH,

+    SPECIAL_EFFECT_SEPIA,

+    SPECIAL_EFFECT_REDDISH,

+    SPECIAL_EFFECT_GREENISH,

+    SPECIAL_EFFECT_NEGATIVE,

+}camera_special_effect_t;

+

+typedef enum camera_exposure_e {

+    EXPOSURE_N4_STEP = 0,

+    EXPOSURE_N3_STEP,

+    EXPOSURE_N2_STEP,

+    EXPOSURE_N1_STEP,

+    EXPOSURE_0_STEP,

+    EXPOSURE_P1_STEP,

+    EXPOSURE_P2_STEP,

+    EXPOSURE_P3_STEP,

+    EXPOSURE_P4_STEP,

+}camera_exposure_t;

+

+

+typedef enum camera_sharpness_e {

+    SHARPNESS_1_STEP = 0,

+    SHARPNESS_2_STEP,

+    SHARPNESS_3_STEP,

+    SHARPNESS_4_STEP,

+    SHARPNESS_5_STEP,

+    SHARPNESS_6_STEP,

+    SHARPNESS_7_STEP,

+    SHARPNESS_8_STEP,

+    SHARPNESS_AUTO_STEP,

+}camera_sharpness_t;

+

+typedef enum camera_mirror_flip_e {

+    MF_NORMAL = 0,

+    MF_MIRROR,

+    MF_FLIP,

+    MF_MIRROR_FLIP,

+}camera_mirror_flip_t;

+

+

+typedef enum camera_wb_flip_e {

+    CAM_WB_AUTO = 0,

+    CAM_WB_CLOUD,

+    CAM_WB_DAYLIGHT,

+    CAM_WB_INCANDESCENCE,

+    CAM_WB_TUNGSTEN,

+    CAM_WB_FLUORESCENT,

+    CAM_WB_MANUAL,

+}camera_wb_flip_t;

+typedef enum camera_night_mode_flip_e {

+    CAM_NM_AUTO = 0,

+	CAM_NM_ENABLE,

+}camera_night_mode_flip_t;

+typedef enum camera_effect_flip_e {

+    CAM_EFFECT_ENC_NORMAL = 0,

+	CAM_EFFECT_ENC_GRAYSCALE,

+	CAM_EFFECT_ENC_SEPIA,

+	CAM_EFFECT_ENC_SEPIAGREEN,

+	CAM_EFFECT_ENC_SEPIABLUE,

+	CAM_EFFECT_ENC_COLORINV,

+}camera_effect_flip_t;

+#endif

+

+