add V4L2 hal

19 files changed, 1572 insertions, 3953 deletions

diff --git a/AmlogicCameraHardware.cpp b/AmlogicCameraHardware.cpp
index e652199..76c435e 100755
--- a/AmlogicCameraHardware.cpp
+++ b/AmlogicCameraHardware.cpp
@@ -22,206 +22,28 @@
 

 #include "AmlogicCameraHardware.h"

 #include <utils/threads.h>

-#include <fcntl.h>

-#include <sys/mman.h>

 #include <cutils/properties.h>

+#include <camera/CameraHardwareInterface.h>

 

+#include <stdio.h>

+#include <unistd.h>

+#include <stdlib.h>

+#include <fcntl.h>

+#include <linux/fb.h>

 

-extern "C" {	

-	

-#include "tvin.h"

-#include "amljpeg_enc.h"

-#include "ge2d.h"

-

-

-int OpenCamera(void);

-int Openvdin(void);

-//int GetFrameData(char *buf);

-int SetOsdOnOff(char* buf);

-int StopCamera(void);

-int Stopvdin(void);

-char * getCameraName(void);

-tvin_sig_fmt_t getCameraResolution(int *width,int *height);

-camera_mirror_flip_e  getCameraMirrorFlip(void);

-tvin_sig_fmt_t ConvertResToDriver(int preview_width,int preview_height,int preview_FrameRate);

-extern struct camera_info_s camera_info;

-extern int global_w,global_h;

-int GetCameraOutputData(char *buf,int dst_format);

-int SetParametersToDriver(void);

-int start_Capture(void);

-int stop_Capture(void);

-int SetExposure(const char *sbn);

-int set_white_balance(const char *swb);

-int set_effect(const char *sef);

-int set_night_mode(const char *snm);

-int set_qulity(const char *squ);

-

-

-

-jpeg_enc_t enc;

-int encode_jpeg(jpeg_enc_t* enc);

-

-}

 

-namespace android {

+//for test

+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);

 

-//====================================================

 

-class AmlogicCamera : public CameraInterface

+namespace android 

 {

-public:

-	AmlogicCamera()

-	{

-		camera_info.camera_name = getCameraName();

-		camera_info.resolution = getCameraResolution(&global_w,&global_h);

-		camera_info.mirro_flip = getCameraMirrorFlip();

-	}

-	

-	int  Open()

-	{

-		OpenCamera();

-		sleep(2); 

-		OpenCamera();  	

-    	Openvdin(); 

-    	//SetOsdOnOff("wc0x1d26 0x44c0");

-		return 1;

-	}

- 	int  Close()

-	{

-		Stopvdin();	

-		StopCamera();

-		//SetOsdOnOff("wc0x1d26 0x3090");		

-		return 1;

-	}

-	int  StartPreview()

-	{

-		return 1;

-	}

-	int  StopPreview()

-	{

-		return 1;

-	}

-	void InitParameters(CameraParameters& pParameters)

-	{

-		//set the limited & the default parameter

-		char resolution[PROPERTY_VALUE_MAX];

-		int width,height;

-		property_get("camera.resolution", resolution, "640x480");

-		getCameraResolution(&width,&height);

-		pParameters.set("preview-size-values",resolution);

-		pParameters.setPreviewSize(width, height);

-		pParameters.setPreviewFrameRate(30);

-		pParameters.setPreviewFormat("rgb565");

-		

-		pParameters.set("picture-size-values", resolution);

-		pParameters.setPictureSize(width, height);

-	    pParameters.setPictureFormat("jpeg");

-		//pParameters.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);

-		

-	    

-	    //pParameters.set("picture-size-values", "320x240,1024x768");

-        //pParameters.setPictureSize(320,240);

-        //pParameters.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);

-

-        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");        

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

-

-        //pParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,"auto,infinity,macro");        

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

-

-        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,0);

-

-        pParameters.set(CameraParameters::KEY_MAX_ZOOM,3);        

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

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

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

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

-

-		//set the default

-		SetParameters(pParameters);

-	}

-

-	void SetParameters(CameraParameters& pParameters)

-	{		

-		

-		int preview_width, preview_height,preview_FrameRate;

-		const char *white_balance=NULL;

-		const char *exposure=NULL;

-		const char *effect=NULL;

-		const char *night_mode=NULL;

-		const char *qulity=NULL;

-		//stop_Capture();

-			

-    	pParameters.getPreviewSize(&preview_width, &preview_height); 

-    	LOGV("getPreviewSize %dx%d ",preview_width,preview_height); 

-    	  

-    	preview_FrameRate= pParameters.getPreviewFrameRate();

-    	LOGV("getPreviewFrameRate %d ",preview_FrameRate); 

-    	

-    	//tvin_sig_fmt_t resolution_index = ConvertResToDriver(preview_width,preview_height,preview_FrameRate);

-    	

-    	//camera_info.resolution = resolution_index;//only change resolution

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

-    	LOGV("white_balance=%s ",white_balance); 

-

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

-    	LOGV("exposure=%s ",exposure); 

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

-    	LOGV("effect=%s ",effect); 

-		night_mode=pParameters.get(CameraParameters::KEY_SCENE_MODE);

-    	LOGV("night_mode=%s ",night_mode); 

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

-    	LOGV("qulity=%s ",qulity); 

-		if(exposure)

-			SetExposure(exposure);

-		if(white_balance)

-			set_white_balance(white_balance);

-		if(effect)

-			set_effect(effect);

-		if(night_mode)

-			set_night_mode(night_mode);

-		if(qulity)

-			set_qulity(qulity);

-    	

-    	//SetParametersToDriver();

-    	

-		LOGV("SetParameters ");

-	}

-

-	void GetPreviewFrame(uint8_t* framebuf)

-	{

-		 //GetFrameData((char*)framebuf);

-		 GetCameraOutputData((char*)framebuf,GE2D_FORMAT_S16_RGB_565);

-	}

-

-	void GetRawFrame(uint8_t* framebuf)

-	{

-		LOGV("GetRawFrame ");

-		GetCameraOutputData((char*)framebuf,GE2D_FORMAT_S16_RGB_565);

-	}

+int SYS_enable_colorkey(short key_rgb565);

+int SYS_disable_colorkey();

+extern CameraInterface* HAL_GetCameraInterface(int Id);

 

-	void GetJpegFrame(uint8_t* framebuf)

-	{

-		LOGV("GetJpegFrame ");

-		encode_jpeg(&enc);

-		

-	}	

-};

-

-//=========================================================

-AmlogicCameraHardware::AmlogicCameraHardware()

+AmlogicCameraHardware::AmlogicCameraHardware(int camid)

                   : mParameters(),

                     mPreviewHeap(0),

                     mRawHeap(0),

@@ -231,11 +53,19 @@ AmlogicCameraHardware::AmlogicCameraHardware()
                     mDataCbTimestamp(0),

                     mCallbackCookie(0),

                     mMsgEnabled(0),

-                    mCurrentPreviewFrame(0)

+                    mCurrentPreviewFrame(0),

+                    mRecordEnable(0),

+                    mState(0)

 {

-	mCamera = new AmlogicCamera();

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

+	mCamera = HAL_GetCameraInterface(camid);

 	mCamera->Open();

-    initDefaultParameters();        

+	initDefaultParameters();

+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

+	SYS_enable_colorkey(0);

+#else

+	mRecordHeap = NULL;

+#endif

 }

 

 AmlogicCameraHardware::~AmlogicCameraHardware()

@@ -250,17 +80,17 @@ AmlogicCameraHardware::~AmlogicCameraHardware()
 void AmlogicCameraHardware::initDefaultParameters()

 {	//call the camera to return the parameter

 	CameraParameters pParameters;

-	LOGV("initDefaultParameters ");

 	mCamera->InitParameters(pParameters);

 	setParameters(pParameters);

 }

 

+

 void AmlogicCameraHardware::initHeapLocked()

 {

     // Create raw heap.

     int picture_width, picture_height;

     mParameters.getPictureSize(&picture_width, &picture_height);

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

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

 

     int preview_width, preview_height;

     mParameters.getPreviewSize(&preview_width, &preview_height);

@@ -283,6 +113,14 @@ void AmlogicCameraHardware::initHeapLocked()
     for (int i = 0; i < kBufferCount; i++) {

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

     }

+

+	#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT

+	mRecordHeap = new MemoryHeapBase(mPreviewFrameSize * 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);

+    }

+	#endif

 }

 

 

@@ -332,48 +170,49 @@ bool AmlogicCameraHardware::msgTypeEnabled(int32_t msgType)
 

 int AmlogicCameraHardware::previewThread()

 {

-    	mLock.lock();

-        // 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;

-

-        // this assumes the internal state of fake camera doesn't change

-        // (or is thread safe)

-

-        sp<MemoryBase> buffer = mBuffers[mCurrentPreviewFrame];

-

-    	mLock.unlock();

+	mLock.lock();

+	// 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;

+	sp<MemoryBase> buffer = mBuffers[mCurrentPreviewFrame];

+	

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

+	mLock.unlock();

 

     // TODO: here check all the conditions that could go wrong

     if (buffer != 0) {

-        // Calculate how long to wait between frames.

-        int delay = (int)(1000000.0f / float(previewFrameRate));

+		int width,height;

+		mParameters.getPreviewSize(&width, &height);

+		int delay = (int)(1000000.0f / float(previewFrameRate));

 

-        // This is always valid, even if the client died -- the memory

-        // is still mapped in our process.

+		//get preview frames data

         void *base = heap->base();

-

-        // Fill the current frame with the fake camera.

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

- 

-		mParameters.getPreviewSize(&global_w, &global_h);//important

-    	mCamera->GetPreviewFrame(frame);

-

-        //LOGV("previewThread: generated frame to buffer %d", mCurrentPreviewFrame);

 

-        // Notify the client of a new frame.

-        if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)

-            mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);

+		//when use overlay, we did't have this message???

+		//if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)

+		{

+			mCamera->GetPreviewFrame(frame);

+			mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);

+		}

+

+		//get Record frames data

+		if(mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)

+		{

+		#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT

+			sp<MemoryHeapBase> reocrdheap = mRecordHeap;

+			sp<MemoryBase> recordbuffer = mRecordBuffers[mCurrentPreviewFrame];

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

+			convert_rgb16_to_yuv420sp(frame,recordframe,width,height);

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

+		#else

+			NO IMPLEMENTS!!

+		#endif

+		}

 

-        // Advance the buffer pointer.

         mCurrentPreviewFrame = (mCurrentPreviewFrame + 1) % kBufferCount;

-

-        // Wait for it...

         usleep(delay);

     }

 

@@ -382,21 +221,19 @@ int AmlogicCameraHardware::previewThread()
 

 status_t AmlogicCameraHardware::startPreview()

 {

-	LOGV("AMLOGIC CAMERA startPreview");

+	LOGD("AMLOGIC CAMERA startPreview");

     Mutex::Autolock lock(mLock);

     if (mPreviewThread != 0) {

         // already running

         return INVALID_OPERATION;

     }

 	mCamera->StartPreview();

-	//useOverlay();

     mPreviewThread = new PreviewThread(this);

     return NO_ERROR;

 }

 

 void AmlogicCameraHardware::stopPreview()

 {

-	mCamera->StopPreview();

 	LOGV("AMLOGIC CAMERA stopPreview");

     sp<PreviewThread> previewThread;

 

@@ -409,6 +246,7 @@ void AmlogicCameraHardware::stopPreview()
     if (previewThread != 0) {

         previewThread->requestExitAndWait();

     }

+	mCamera->StopPreview();

 

     Mutex::Autolock lock(mLock);

     mPreviewThread.clear();

@@ -420,20 +258,26 @@ bool AmlogicCameraHardware::previewEnabled() {
 

 status_t AmlogicCameraHardware::startRecording()

 {

-    return UNKNOWN_ERROR;

+	LOGE("AmlogicCameraHardware::startRecording()");

+	mCamera->StartRecord();

+	mRecordEnable = true;

+    return NO_ERROR;

 }

 

 void AmlogicCameraHardware::stopRecording()

 {

+    mCamera->StopRecord();	

+	mRecordEnable = false;

 }

 

 bool AmlogicCameraHardware::recordingEnabled()

 {

-    return false;

+    return mRecordEnable;

 }

 

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

 {

+	LOGD("AmlogicCameraHardware::releaseRecordingFrame");

 }

 

 // ---------------------------------------------------------------------------

@@ -441,38 +285,51 @@ void AmlogicCameraHardware::releaseRecordingFrame(const sp<IMemory>& mem)
 int AmlogicCameraHardware::beginAutoFocusThread(void *cookie)

 {

     AmlogicCameraHardware *c = (AmlogicCameraHardware *)cookie;

-    LOGV("AMLOGIC CAMERA beginAutoFocusThread");

+	//should add wait focus end

     return c->autoFocusThread();

 }

 

 int AmlogicCameraHardware::autoFocusThread()

 {

+	mCamera->StartFocus();

     if (mMsgEnabled & CAMERA_MSG_FOCUS)

         mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);

-    LOGV("AMLOGIC CAMERA autoFocusThread");

+	mStateLock.lock();

+	mState &= ~PROCESS_FOCUS;

+	mStateLock.unlock();

     return NO_ERROR;

 }

 

 status_t AmlogicCameraHardware::autoFocus()

 {

+	status_t ret = NO_ERROR;

     Mutex::Autolock lock(mLock);

-    LOGV("AMLOGIC CAMERA autoFocus111");	

-    if (createThread(beginAutoFocusThread, this) == false)

-        return UNKNOWN_ERROR;

-    LOGV("AMLOGIC CAMERA autoFocus222");

-    return NO_ERROR;

+	if(mStateLock.tryLock() == 0)

+	{

+		if((mState&PROCESS_FOCUS) == 0)

+		{

+			if (createThread(beginAutoFocusThread, this) == false)

+			{

+				ret = UNKNOWN_ERROR;

+			}

+			else

+				mState |= PROCESS_FOCUS;

+		}

+		mStateLock.unlock();

+	}

+

+    return ret;

 }

 

 status_t AmlogicCameraHardware::cancelAutoFocus()

 {

-	LOGV("AMLOGIC CAMERA cancelAutoFocus");

-    return NO_ERROR;

+	Mutex::Autolock lock(mLock);

+	return mCamera->StopFocus();

 }

 

 /*static*/ int AmlogicCameraHardware::beginPictureThread(void *cookie)

 {

     AmlogicCameraHardware *c = (AmlogicCameraHardware *)cookie;

-    LOGV("AMLOGIC CAMERA beginPictureThread");

     return c->pictureThread();

 }

 

@@ -480,68 +337,45 @@ int AmlogicCameraHardware::pictureThread()
 {

     if (mMsgEnabled & CAMERA_MSG_SHUTTER)

         mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);

-	LOGV("AMLOGIC CAMERA pictureThread111");

-    if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {

-        //FIXME: use a canned YUV image!

-        // In the meantime just make another fake camera picture.

-        

-        mParameters.getPictureSize(&global_w, &global_h);//important

-        

-        sp<MemoryBase> mem = new MemoryBase(mRawHeap, 0, global_w * 2 * global_h);

 

+	mCamera->TakePicture();

+	int w, h;

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

+	//Capture picture is RGB 24 BIT

+	#if 0

+    if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {

+		sp<MemoryHeapBase> tmpheap = new MemoryHeapBase( w * 3 * h);

+		sp<MemoryBase> tmpmem = new MemoryBase(tmpheap, 0, w * 3 * h);  

+		

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

-

-        mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);

-        

-        LOGV("AMLOGIC CAMERA pictureThread222");

+		convert_rgb24_to_rgb16((uint8_t*)mRawHeap->base(),(uint8_t*)tmpheap->base(),w,h);

+		convert_rgb16_to_yuv420sp((uint8_t*)tmpheap->base(), (uint8_t*)mRawHeap->base(), w,h);

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

+		mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);

     }

+	#endif

 

     if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {

-        //sp<MemoryHeapBase> heap = new MemoryHeapBase(kCannedJpegSize);

-        //sp<MemoryBase> mem = new MemoryBase(heap, 0, kCannedJpegSize);

-        //memcpy(heap->base(), kCannedJpeg, kCannedJpegSize);       

-       

-        mParameters.getPictureSize(&global_w, &global_h);

-        

-        //LOGE(" picture_w = (%x),picture_h = (%x)",  w,h);

-        sp<MemoryHeapBase> heap = new MemoryHeapBase( global_w * 3 * global_h);

-        sp<MemoryBase> mem = new MemoryBase(heap, 0, global_w * 3 * global_h);        

-        

-        

-        sp<MemoryHeapBase> heap_input = new MemoryHeapBase( global_w * 3 * global_h);

-        GetCameraOutputData((char*)heap_input->base(),GE2D_FORMAT_S24_BGR);        

-        

-	    enc.width=global_w;

-		enc.height=global_h;	

-		enc.idata = (unsigned char*)heap_input->base();	

-		enc.odata = (unsigned char*)heap->base();

-		enc.ibuff_size =  global_w * 3 * global_h;

-		enc.obuff_size =  global_w * 3 * global_h;

-	enc.quality=camera_info.qulity;	

-	

-	LOGV("AMLOGIC CAMERA pictureThread333 %d",camera_info.qulity);

-		

-  	mCamera->GetJpegFrame((uint8_t*)heap->base());

-  		

-        mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);

-    } 

-    LOGV("AMLOGIC CAMERA pictureThread444");

+		sp<MemoryHeapBase> jpgheap = new MemoryHeapBase( w * 3 * h);

+		sp<MemoryBase> jpgmem = new MemoryBase(jpgheap, 0, w * 3 * h);        

+  		mCamera->GetJpegFrame((uint8_t*)jpgheap->base());

+        mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, jpgmem, mCallbackCookie);

+    }

+	mCamera->TakePictureEnd();

     return NO_ERROR;

 }

 

 status_t AmlogicCameraHardware::takePicture()

 {

     stopPreview();

-    LOGV("AMLOGIC CAMERA takePicture111");

     if (createThread(beginPictureThread, this) == false)

         return -1;

-    LOGV("AMLOGIC CAMERA takePicture222");

     return NO_ERROR;

 }

 

+

 status_t AmlogicCameraHardware::cancelPicture()

 {

-	LOGV("AMLOGIC CAMERA cancelPicture");

     return NO_ERROR;

 }

 

@@ -562,40 +396,19 @@ status_t AmlogicCameraHardware::dump(int fd, const Vector<String16>& args) const
     }

     write(fd, result.string(), result.size());\

 */

-LOGV("AMLOGIC CAMERA dump");

     return NO_ERROR;

 }

 

 status_t AmlogicCameraHardware::setParameters(const CameraParameters& params)

 {

     Mutex::Autolock lock(mLock);

-    // to verify parameters

-

-	//surface view is yuv422

-    //if (strcmp(params.getPreviewFormat(), "yuv422sp") != 0) 

-    //surface view is rgb565

-    if (strcmp(params.getPreviewFormat(), "rgb565") != 0)     	

-    {

-		LOGE(params.getPreviewFormat());

-        LOGE("Only rgb565 preview is supported  ");

-        return -1;

-    }

+    // to verify parameter

 

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

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

         return -1;

     }

 

-    int w, h;

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

-/*    if (w != kCannedJpegWidth && h != kCannedJpegHeight) {

-        LOGE("Still picture size must be size of canned JPEG (%dx%d)",

-             kCannedJpegWidth, kCannedJpegHeight);

-        return -1;

-    }*/

-

-LOGV("AMLOGIC CAMERA setParameters");

-

     mParameters = params;

     initHeapLocked();

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

@@ -604,8 +417,8 @@ LOGV("AMLOGIC CAMERA setParameters");
 

 CameraParameters AmlogicCameraHardware::getParameters() const

 {

+	LOGE("get AmlogicCameraHardware::getParameters()");

     Mutex::Autolock lock(mLock);

-    LOGV("AMLOGIC CAMERA getParameters");	

     return mParameters;

 }

 

@@ -617,34 +430,152 @@ status_t AmlogicCameraHardware::sendCommand(int32_t command, int32_t arg1,
 

 void AmlogicCameraHardware::release()

 {

-

+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

+	SYS_disable_colorkey();

+#endif

+	mCamera->Close();

 }

 

+

 wp<CameraHardwareInterface> AmlogicCameraHardware::singleton;

 

-sp<CameraHardwareInterface> AmlogicCameraHardware::createInstance()

+sp<CameraHardwareInterface> AmlogicCameraHardware::createInstance(int CamId)

 {

-    if (singleton != 0) {

-        sp<CameraHardwareInterface> hardware = singleton.promote();

-        if (hardware != 0) {

-            return hardware;

-        }

-    }

-    sp<CameraHardwareInterface> hardware(new AmlogicCameraHardware());

-    singleton = hardware;

+	sp<CameraHardwareInterface> hardware = NULL;

+    if (singleton != 0)

+	{

+		hardware = singleton.promote();

+		#ifdef AMLOGIC_MULTI_CAMERA_SUPPORT

+		if(CamId != hardware->getCamId() )

+		{

+			singleton.clear();

+			hardware = NULL;

+		}

+		#endif

+	}

+	if(hardware == NULL)

+	{

+		hardware = new AmlogicCameraHardware(CamId);

+		singleton = hardware;

+	}

+

     return hardware;

 }

 

+

+//for amlogic OverLay

+//============================================

+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

+#ifndef FBIOPUT_OSD_SRCCOLORKEY

+#define  FBIOPUT_OSD_SRCCOLORKEY    0x46fb

+#endif

+#ifndef FBIOPUT_OSD_SRCKEY_ENABLE

+#define  FBIOPUT_OSD_SRCKEY_ENABLE  0x46fa

+#endif

+#ifndef FBIOPUT_OSD_SET_GBL_ALPHA

+#define  FBIOPUT_OSD_SET_GBL_ALPHA	0x4500

+#endif

+

+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;       

+		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);    

+	}    

+	return ret;

+}

+int SYS_disable_colorkey()

+{

+	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);  

+	}   

+	return ret;

+}

+#endif

+

+#ifdef AMLOGIC_MULTI_CAMERA_SUPPORT

+extern "C" sp<CameraHardwareInterface> openCameraHardware(int CamId)

+{

+	LOGV("openCameraHardware with camid");

+    return AmlogicCameraHardware::createInstance(CamId);

+}

+#else

 extern "C" sp<CameraHardwareInterface> openCameraHardware()

 {

-	LOGV("CameraHardwreStub::openCameraHardware");

-    return AmlogicCameraHardware::createInstance();

+	LOGV("openCameraHardware");

+    return AmlogicCameraHardware::createInstance(0);

 }

+#endif

+}; // namespace android

 

 

+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);

+		dst[j+1] = ((src[i+1]>>2)<<5) | (src[i+2]>>3);

+        j += 2;

+    }

+}

 

 

+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;
+    uint8_t* buf_uv = buf_y + width * height;
+    uint16_t* buf_rgb = (uint16_t *)rgb;
+	int h,w,val_rgb,val_r,val_g,val_b;
+	int y,u,v;
+    for (h = 0; h < height; h++) {
+        for (w = 0; w < width; w++) {
+            val_rgb = buf_rgb[h * width + w];
+            val_r = ((val_rgb & (0x1f << 11)) >> 11)<<3;
+            val_g = ((val_rgb & (0x3f << 5)) >> 5)<<2;
+            val_b = ((val_rgb & (0x1f << 0)) >> 0)<<3;
+            y = 0.30078 * val_r + 0.5859 * val_g + 0.11328 * val_b;
+            if (y > 255) {
+                y = 255;
+            } else if (y < 0) {
+                y = 0;
+            }
+            buf_y[iy++] = y;
+            if (0 == h % 2 && 0 == w % 2) {
+                u = -0.11328 * val_r - 0.33984 * val_g + 0.51179 * val_b + 128;
+                if (u > 255) {
+                    u = 255;
+                } 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; 
+            }
+        }
+}

+}
 

-}; // namespace android

 

 

diff --git a/AmlogicCameraHardware.h b/AmlogicCameraHardware.h
index fb42595..536a65c 100644..100755
--- a/AmlogicCameraHardware.h
+++ b/AmlogicCameraHardware.h
@@ -6,7 +6,8 @@
 #include <camera/CameraHardwareInterface.h>

 #include <binder/MemoryBase.h>

 #include <binder/MemoryHeapBase.h>

-#include <utils/threads.h>

+

+//#define AMLOGIC_CAMERA_OVERLAY_SUPPORT 1

 

 namespace android {

 

@@ -15,15 +16,23 @@ class CameraInterface
 public:

 	CameraInterface(){};

 	virtual ~CameraInterface(){};

-	virtual int  Open() = 0;

-	virtual int  Close() = 0;

-	virtual int  StartPreview() = 0;

-	virtual int  StopPreview() = 0;

-	virtual void InitParameters(CameraParameters& pParameters) = 0;

-	virtual void SetParameters(CameraParameters& pParameters) = 0;

-	virtual void GetPreviewFrame(uint8_t* framebuf) = 0;

-	virtual void GetRawFrame(uint8_t* framebuf) = 0;

-	virtual void GetJpegFrame(uint8_t* framebuf) = 0;

+	virtual status_t	Open() = 0;

+	virtual status_t	Close() = 0;

+	virtual status_t	StartPreview() = 0;

+	virtual status_t	StopPreview() = 0;

+	virtual status_t	StartRecord() = 0;

+	virtual status_t	StopRecord() = 0;

+	virtual status_t	TakePicture() = 0;

+	virtual status_t	TakePictureEnd() = 0;

+	virtual status_t	StartFocus(){return 1;};

+	virtual status_t	StopFocus(){return 1;};

+	virtual status_t	InitParameters(CameraParameters& pParameters) = 0;

+	virtual status_t	SetParameters(CameraParameters& pParameters) = 0;

+	virtual status_t	GetPreviewFrame(uint8_t* framebuf) = 0;

+	virtual status_t	GetRawFrame(uint8_t* framebuf) = 0;

+	virtual status_t	GetJpegFrame(uint8_t* framebuf) = 0;

+

+	virtual int			GetCamId() {return 0;};

 };

 

 

@@ -31,7 +40,7 @@ class AmlogicCameraHardware : public CameraHardwareInterface {
 public:

     virtual sp<IMemoryHeap> getPreviewHeap() const;

     virtual sp<IMemoryHeap> getRawHeap() const;

-

+	

     virtual void        setCallbacks(notify_callback notify_cb,

                                      data_callback data_cb,

                                      data_callback_timestamp data_cb_timestamp,

@@ -60,19 +69,31 @@ public:
     virtual status_t    sendCommand(int32_t command, int32_t arg1,

                                     int32_t arg2);

     virtual void release();

-    

-    //virtual bool         useOverlay() {return true;}//pan

 

-    static sp<CameraHardwareInterface> createInstance();

+    static sp<CameraHardwareInterface> createInstance(int CamId);

+

+#ifdef AMLOGIC_MULTI_CAMERA_SUPPORT

+	virtual int		getCamId(){return mCamera->GetCamId();}

+#endif

+

+#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT

+	virtual bool		useOverlay() {return true;}

+    virtual status_t     setOverlay(const sp<Overlay> &overlay) {return NO_ERROR;}

+#endif

 

 private:

-                        AmlogicCameraHardware();

+                        AmlogicCameraHardware(int camid = 0);

     virtual             ~AmlogicCameraHardware();

 

     static wp<CameraHardwareInterface> singleton;

 

     static const int kBufferCount = 4;

 

+#ifndef AMLOGIC_CAMERA_OVERLAY_SUPPORT

+	sp<MemoryHeapBase>  mRecordHeap;

+    sp<MemoryBase>      mRecordBuffers[kBufferCount];

+#endif

+

     class PreviewThread : public Thread {

         AmlogicCameraHardware* mHardware;

     public:

@@ -107,6 +128,9 @@ private:
     int pictureThread();

 

     mutable Mutex       mLock;

+	mutable Mutex       mStateLock;

+

+	int					mState;

 

     CameraParameters    mParameters;

 

@@ -121,6 +145,9 @@ private:
     // protected by mLock

     sp<PreviewThread>   mPreviewThread;

 

+	//if reord is enable!

+	bool				mRecordEnable;

+

     notify_callback    mNotifyCb;

     data_callback      mDataCb;

     data_callback_timestamp mDataCbTimestamp;

@@ -132,6 +159,13 @@ private:
     int                 mCurrentPreviewFrame;

 

 	CameraInterface* 	mCamera;

+

+

+	enum

+	{

+		PROCESS_FOCUS = 0x1,

+		PROCESS_TAKEPIC = 0x2,

+	};

 };

 

 }; // namespace android

diff --git a/Android.mk b/Android.mk
index b446e7c..4e20d22 100755
--- a/Android.mk
+++ b/Android.mk
@@ -4,19 +4,22 @@ include $(CLEAR_VARS)
 LOCAL_MODULE := libcamera
 
 LOCAL_SHARED_LIBRARIES := \
+		libutils \
 		libcutils \
-    libutils \
     liblog  \
     libcamera_client \
     libbinder \
     libjpeg
     
+LOCAL_C_INCLUDES += ../../kernel/include/
+
+#jpeg encode
+LOCAL_SRC_FILES += jpegenc/amljpeg_enc.c
+
+#LOCAL_SRC_FILES += AmlogicCameraHardware.cpp FakeCamera/FakeCamera.cpp
+LOCAL_SRC_FILES += AmlogicCameraHardware.cpp V4L2/V4L2Camera.cpp FakeCamera/FakeCamera.cpp
 
-LOCAL_SRC_FILES += AmlogicCameraHardware.cpp OpCameraHardware.c OpVdin.c cmem.c
 
-include $(BUILD_SHARED_LIBRARY)
 
-file := $(TARGET_OUT_SHARED_LIBRARIES)/cmemk.ko
-ALL_PREBUILT += $(file)
-$(file) : $(LOCAL_PATH)/cmemk.ko | $(ACP)
-	$(transform-prebuilt-to-target)
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/FakeCamera/FakeCamera.cpp b/FakeCamera/FakeCamera.cpp
new file mode 100755
index 0000000..8fb3c7b
--- a/dev/null
+++ b/FakeCamera/FakeCamera.cpp
@@ -0,0 +1,636 @@
+/*
+**
+** 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.
+*/
+
+#define LOG_TAG "FakeCamera"
+#include <utils/Log.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <utils/String8.h>
+
+#include "FakeCamera.h"
+#include "AmlogicCameraHardware.h"
+
+
+
+
+namespace android {
+
+//====================================================
+class fakecamerainter : public CameraInterface
+{
+public:
+	FakeCamera *pfakeCamera;
+	int Width;
+	int Height;
+	int 		mCamId;
+
+	fakecamerainter(int w,int h,int id)
+	{
+		Width = w;
+		Height = h;
+		mCamId = id;
+	}
+	status_t  Open()
+	{
+		pfakeCamera = new FakeCamera(Width,Height);
+		return NO_ERROR;
+	}
+	status_t  Close()
+	{
+		return NO_ERROR;
+	}
+	status_t  StartPreview()
+	{
+		return NO_ERROR;
+	}
+	status_t  StopPreview()
+	{
+		return NO_ERROR;
+	}
+	status_t  StartRecord()
+	{
+		return NO_ERROR;
+	}
+	status_t  StopRecord()
+	{
+		return NO_ERROR;
+	}
+	status_t  TakePicture()
+	{
+		return NO_ERROR;
+	}
+	int			GetCamId()
+	{
+		return mCamId;
+	}
+	status_t InitParameters(CameraParameters& pParameters)
+	{
+		//set the limited & the default parameter
+		pParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,"320x240");
+		pParameters.setPreviewSize(Width, Height);
+		pParameters.setPreviewFrameRate(15);
+		pParameters.setPreviewFormat(CameraParameters::PIXEL_FORMAT_RGB565);
+
+		pParameters.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,"320x240");
+		pParameters.setPictureSize(320,240);
+		pParameters.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
+
+		pParameters.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,"auto,daylight,incandescent");
+		pParameters.set(CameraParameters::KEY_WHITE_BALANCE,"auto");
+		
+		pParameters.set(CameraParameters::KEY_SUPPORTED_EFFECTS,"none,mono,negative");		
+		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_SCENE_MODE,"auto");
+
+		pParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,"auto,infinity,macro");		
+		pParameters.set(CameraParameters::KEY_FOCUS_MODE,"auto");
+
+		pParameters.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,2);		
+		pParameters.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,-2);
+		pParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,1);		
+		pParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,0);
+
+		pParameters.set(CameraParameters::KEY_MAX_ZOOM,3);		
+		pParameters.set(CameraParameters::KEY_ZOOM_RATIOS,"100,120,140,160,200,220,150,280,290,300");
+		pParameters.set(CameraParameters::KEY_ZOOM_SUPPORTED,CameraParameters::TRUE);
+		pParameters.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,1);
+		pParameters.set(CameraParameters::KEY_ZOOM,1);
+
+		//set the default value to hardwarey
+		SetParameters(pParameters);
+		return NO_ERROR;
+	}
+
+	status_t 	TakePictureEnd()
+	{
+		return NO_ERROR;
+	}
+	status_t SetParameters(CameraParameters& pParameters)
+	{
+		return NO_ERROR;
+	}
+
+	status_t GetPreviewFrame(uint8_t* framebuf)
+	{
+		//pfakeCamera->getNextFrameAsYuv422(framebuf);
+		pfakeCamera->getNextFrameAsRgb565((uint16_t*)framebuf);
+		return NO_ERROR;
+	}
+
+	status_t GetRawFrame(uint8_t* framebuf)
+	{
+		pfakeCamera->getNextFrameAsYuv422((uint8_t*)framebuf);
+		return NO_ERROR;
+	}
+
+	status_t GetJpegFrame(uint8_t* framebuf)
+	{
+		return NO_ERROR;
+	}	
+};
+
+
+// TODO: All this rgb to yuv should probably be in a util class.
+
+// TODO: I think something is wrong in this class because the shadow is kBlue
+// and the square color should alternate between kRed and kGreen. However on the
+// emulator screen these are all shades of gray. Y seems ok but the U and V are
+// probably not.
+
+static int tables_initialized = 0;
+uint8_t *gYTable, *gCbTable, *gCrTable;
+
+static int
+clamp(int  x)
+{
+    if (x > 255) return 255;
+    if (x < 0)   return 0;
+    return x;
+}
+
+/* the equation used by the video code to translate YUV to RGB looks like this
+ *
+ *    Y  = (Y0 - 16)*k0
+ *    Cb = Cb0 - 128
+ *    Cr = Cr0 - 128
+ *
+ *    G = ( Y - k1*Cr - k2*Cb )
+ *    R = ( Y + k3*Cr )
+ *    B = ( Y + k4*Cb )
+ *
+ */
+
+static const double  k0 = 1.164;
+static const double  k1 = 0.813;
+static const double  k2 = 0.391;
+static const double  k3 = 1.596;
+static const double  k4 = 2.018;
+
+/* let's try to extract the value of Y
+ *
+ *   G + k1/k3*R + k2/k4*B = Y*( 1 + k1/k3 + k2/k4 )
+ *
+ *   Y  = ( G + k1/k3*R + k2/k4*B ) / (1 + k1/k3 + k2/k4)
+ *   Y0 = ( G0 + k1/k3*R0 + k2/k4*B0 ) / ((1 + k1/k3 + k2/k4)*k0) + 16
+ *
+ * let define:
+ *   kYr = k1/k3
+ *   kYb = k2/k4
+ *   kYy = k0 * ( 1 + kYr + kYb )
+ *
+ * we have:
+ *    Y  = ( G + kYr*R + kYb*B )
+ *    Y0 = clamp[ Y/kYy + 16 ]
+ */
+
+static const double kYr = k1/k3;
+static const double kYb = k2/k4;
+static const double kYy = k0*( 1. + kYr + kYb );
+
+static void
+initYtab( void )
+{
+    const  int imax = (int)( (kYr + kYb)*(31 << 2) + (61 << 3) + 0.1 );
+    int    i;
+
+    gYTable = (uint8_t *)malloc(imax);
+
+    for(i=0; i<imax; i++) {
+        int  x = (int)(i/kYy + 16.5);
+        if (x < 16) x = 16;
+        else if (x > 235) x = 235;
+        gYTable[i] = (uint8_t) x;
+    }
+}
+
+/*
+ *   the source is RGB565, so adjust for 8-bit range of input values:
+ *
+ *   G = (pixels >> 3) & 0xFC;
+ *   R = (pixels >> 8) & 0xF8;
+ *   B = (pixels & 0x1f) << 3;
+ *
+ *   R2 = (pixels >> 11)      R = R2*8
+ *   B2 = (pixels & 0x1f)     B = B2*8
+ *
+ *   kYr*R = kYr2*R2 =>  kYr2 = kYr*8
+ *   kYb*B = kYb2*B2 =>  kYb2 = kYb*8
+ *
+ *   we want to use integer multiplications:
+ *
+ *   SHIFT1 = 9
+ *
+ *   (ALPHA*R2) >> SHIFT1 == R*kYr  =>  ALPHA = kYr*8*(1 << SHIFT1)
+ *
+ *   ALPHA = kYr*(1 << (SHIFT1+3))
+ *   BETA  = kYb*(1 << (SHIFT1+3))
+ */
+
+static const int  SHIFT1  = 9;
+static const int  ALPHA   = (int)( kYr*(1 << (SHIFT1+3)) + 0.5 );
+static const int  BETA    = (int)( kYb*(1 << (SHIFT1+3)) + 0.5 );
+
+/*
+ *  now let's try to get the values of Cb and Cr
+ *
+ *  R-B = (k3*Cr - k4*Cb)
+ *
+ *    k3*Cr = k4*Cb + (R-B)
+ *    k4*Cb = k3*Cr - (R-B)
+ *
+ *  R-G = (k1+k3)*Cr + k2*Cb
+ *      = (k1+k3)*Cr + k2/k4*(k3*Cr - (R-B)/k0)
+ *      = (k1 + k3 + k2*k3/k4)*Cr - k2/k4*(R-B)
+ *
+ *  kRr*Cr = (R-G) + kYb*(R-B)
+ *
+ *  Cr  = ((R-G) + kYb*(R-B))/kRr
+ *  Cr0 = clamp(Cr + 128)
+ */
+
+static const double  kRr = (k1 + k3 + k2*k3/k4);
+
+static void
+initCrtab( void )
+{
+    uint8_t *pTable;
+    int i;
+
+    gCrTable = (uint8_t *)malloc(768*2);
+
+    pTable = gCrTable + 384;
+    for(i=-384; i<384; i++)
+        pTable[i] = (uint8_t) clamp( i/kRr + 128.5 );
+}
+
+/*
+ *  B-G = (k2 + k4)*Cb + k1*Cr
+ *      = (k2 + k4)*Cb + k1/k3*(k4*Cb + (R-B))
+ *      = (k2 + k4 + k1*k4/k3)*Cb + k1/k3*(R-B)
+ *
+ *  kBb*Cb = (B-G) - kYr*(R-B)
+ *
+ *  Cb   = ((B-G) - kYr*(R-B))/kBb
+ *  Cb0  = clamp(Cb + 128)
+ *
+ */
+
+static const double  kBb = (k2 + k4 + k1*k4/k3);
+
+static void
+initCbtab( void )
+{
+    uint8_t *pTable;
+    int i;
+
+    gCbTable = (uint8_t *)malloc(768*2);
+
+    pTable = gCbTable + 384;
+    for(i=-384; i<384; i++)
+        pTable[i] = (uint8_t) clamp( i/kBb + 128.5 );
+}
+
+/*
+ *   SHIFT2 = 16
+ *
+ *   DELTA = kYb*(1 << SHIFT2)
+ *   GAMMA = kYr*(1 << SHIFT2)
+ */
+
+static const int  SHIFT2 = 16;
+static const int  DELTA  = kYb*(1 << SHIFT2);
+static const int  GAMMA  = kYr*(1 << SHIFT2);
+
+int32_t ccrgb16toyuv_wo_colorkey(uint8_t *rgb16,uint8_t *yuv422,uint32_t *param,uint8_t *table[])
+{
+    uint16_t *inputRGB = (uint16_t*)rgb16;
+    uint8_t *outYUV =  yuv422;
+    int32_t width_dst = param[0];
+    int32_t height_dst = param[1];
+    int32_t pitch_dst = param[2];
+    int32_t mheight_dst = param[3];
+    int32_t pitch_src = param[4];
+    uint8_t *y_tab = table[0];
+    uint8_t *cb_tab = table[1];
+    uint8_t *cr_tab = table[2];
+
+    int32_t size16 = pitch_dst*mheight_dst;
+    int32_t i,j,count;
+    int32_t ilimit,jlimit;
+    uint8_t *tempY,*tempU,*tempV;
+    uint16_t pixels;
+    int   tmp;
+uint32_t temp;
+
+    tempY = outYUV;
+    tempU = outYUV + (height_dst * pitch_dst);
+    tempV = tempU + 1;
+
+    jlimit = height_dst;
+    ilimit = width_dst;
+
+    for(j=0; j<jlimit; j+=1)
+    {
+        for (i=0; i<ilimit; i+=2)
+        {
+            int32_t   G_ds = 0, B_ds = 0, R_ds = 0;
+            uint8_t   y0, y1, u, v;
+
+            pixels =  inputRGB[i];
+            temp = (BETA*(pixels & 0x001F) + ALPHA*(pixels>>11) );
+            y0   = y_tab[(temp>>SHIFT1) + ((pixels>>3) & 0x00FC)];
+
+            G_ds    += (pixels>>1) & 0x03E0;
+            B_ds    += (pixels<<5) & 0x03E0;
+            R_ds    += (pixels>>6) & 0x03E0;
+
+            pixels =  inputRGB[i+1];
+            temp = (BETA*(pixels & 0x001F) + ALPHA*(pixels>>11) );
+            y1   = y_tab[(temp>>SHIFT1) + ((pixels>>3) & 0x00FC)];
+
+            G_ds    += (pixels>>1) & 0x03E0;
+            B_ds    += (pixels<<5) & 0x03E0;
+            R_ds    += (pixels>>6) & 0x03E0;
+
+            R_ds >>= 1;
+            B_ds >>= 1;
+            G_ds >>= 1;
+
+            tmp = R_ds - B_ds;
+
+            u = cb_tab[(((B_ds-G_ds)<<SHIFT2) - GAMMA*tmp)>>(SHIFT2+2)];
+            v = cr_tab[(((R_ds-G_ds)<<SHIFT2) + DELTA*tmp)>>(SHIFT2+2)];
+
+            tempY[0] = y0;
+            tempY[1] = y1;
+            tempU[0] = u;
+            tempV[0] = v;
+
+            tempY += 2;
+            tempU += 2;
+            tempV += 2;
+        }
+
+        inputRGB += pitch_src;
+    }
+
+    return 1;
+}
+
+#define min(a,b) ((a)<(b)?(a):(b))
+#define max(a,b) ((a)>(b)?(a):(b))
+
+static void convert_rgb16_to_yuv422(uint8_t *rgb, uint8_t *yuv, int width, int height)
+{
+    if (!tables_initialized) {
+        initYtab();
+        initCrtab();
+        initCbtab();
+        tables_initialized = 1;
+    }
+
+    uint32_t param[6];
+    param[0] = (uint32_t) width;
+    param[1] = (uint32_t) height;
+    param[2] = (uint32_t) width;
+    param[3] = (uint32_t) height;
+    param[4] = (uint32_t) width;
+    param[5] = (uint32_t) 0;
+
+    uint8_t *table[3];
+    table[0] = gYTable;
+    table[1] = gCbTable + 384;
+    table[2] = gCrTable + 384;
+
+    ccrgb16toyuv_wo_colorkey(rgb, yuv, param, table);
+}
+
+const int FakeCamera::kRed;
+const int FakeCamera::kGreen;
+const int FakeCamera::kBlue;
+
+FakeCamera::FakeCamera(int width, int height)
+          : mTmpRgb16Buffer(0)
+{
+    setSize(width, height);
+}
+
+FakeCamera::~FakeCamera()
+{
+    delete[] mTmpRgb16Buffer;
+}
+
+void FakeCamera::setSize(int width, int height)
+{
+    mWidth = width;
+    mHeight = height;
+    mCounter = 0;
+    mCheckX = 0;
+    mCheckY = 0;
+
+    // This will cause it to be reallocated on the next call
+    // to getNextFrameAsYuv422().
+    delete[] mTmpRgb16Buffer;
+    mTmpRgb16Buffer = 0;
+}
+
+void FakeCamera::getNextFrameAsRgb565(uint16_t *buffer)
+{
+    int size = mWidth / 10;
+
+    drawCheckerboard(buffer, size);
+
+    int x = ((mCounter*3)&255);
+    if(x>128) x = 255 - x;
+    int y = ((mCounter*5)&255);
+    if(y>128) y = 255 - y;
+
+    drawSquare(buffer, x*size/32, y*size/32, (size*5)>>1, (mCounter&0x100)?kRed:kGreen, kBlue);
+
+    mCounter++;
+}
+
+void convert_yuv422_to_yuv420sp(uint8_t *yuv422, uint8_t *yuv420sp, int width, int height)
+{
+	uint8_t* tmp_yuv422 = yuv422;
+	uint8_t* dst_y = yuv420sp;
+	uint8_t* dst_uv = dst_y + width*height;
+
+	int irow = 0,icol = 0;
+	for( irow=0; irow++; irow<height)
+	{
+		for(icol=0; ;icol<width)
+		{
+			dst_y[0] = tmp_yuv422[0];
+			dst_uv[0] = tmp_yuv422[1];
+			dst_y[1] = tmp_yuv422[2];
+			dst_uv[1] = tmp_yuv422[3];
+
+			dst_y+=2;
+			dst_uv+=2;
+			icol+=4;
+		}
+	}
+
+}
+
+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;
+    uint8_t* buf_uv = buf_y + width * height;
+    uint16_t* buf_rgb = (uint16_t *)rgb;
+	int h,w,val_rgb,val_r,val_g,val_b;
+	int y,u,v;
+    for (h = 0; h < height; h++) {
+        for (w = 0; w < width; w++) {
+            val_rgb = buf_rgb[h * width + w];
+            val_r = ((val_rgb & (0x1f << 11)) >> 11)<<3;
+            val_g = ((val_rgb & (0x3f << 5)) >> 5)<<2;
+            val_b = ((val_rgb & (0x1f << 0)) >> 0)<<3;
+            y = 0.30078 * val_r + 0.5859 * val_g + 0.11328 * val_b;
+            if (y > 255) {
+                y = 255;
+            } else if (y < 0) {
+                y = 0;
+            }
+            buf_y[iy++] = y;
+            if (0 == h % 2 && 0 == w % 2) {
+                u = -0.11328 * val_r - 0.33984 * val_g + 0.51179 * val_b + 128;
+                if (u > 255) {
+                    u = 255;
+                } 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; 
+            }
+        }
+}
+}
+void FakeCamera::getNextFrameAsYuv422(uint8_t *buffer)
+{
+    if (mTmpRgb16Buffer == 0)
+        mTmpRgb16Buffer = new uint16_t[mWidth * mHeight];
+
+    getNextFrameAsRgb565(mTmpRgb16Buffer);
+    convert_rgb16_to_yuv420sp((uint8_t*)mTmpRgb16Buffer, buffer, mWidth, mHeight);
+}
+
+void FakeCamera::drawSquare(uint16_t *dst, int x, int y, int size, int color, int shadow)
+{
+    int square_xstop, square_ystop, shadow_xstop, shadow_ystop;
+
+    square_xstop = min(mWidth, x+size);
+    square_ystop = min(mHeight, y+size);
+    shadow_xstop = min(mWidth, x+size+(size/4));
+    shadow_ystop = min(mHeight, y+size+(size/4));
+
+    // Do the shadow.
+    uint16_t *sh = &dst[(y+(size/4))*mWidth];
+    for (int j = y + (size/4); j < shadow_ystop; j++) {
+        for (int i = x + (size/4); i < shadow_xstop; i++) {
+            sh[i] &= shadow;
+        }
+        sh += mWidth;
+    }
+
+    // Draw the square.
+    uint16_t *sq = &dst[y*mWidth];
+    for (int j = y; j < square_ystop; j++) {
+        for (int i = x; i < square_xstop; i++) {
+            sq[i] = color;
+        }
+        sq += mWidth;
+    }
+}
+
+void FakeCamera::drawCheckerboard(uint16_t *dst, int size)
+{
+    bool black = true;
+
+    if((mCheckX/size)&1)
+        black = false;
+    if((mCheckY/size)&1)
+        black = !black;
+
+    int county = mCheckY%size;
+    int checkxremainder = mCheckX%size;
+
+    for(int y=0;y<mHeight;y++) {
+        int countx = checkxremainder;
+        bool current = black;
+        for(int x=0;x<mWidth;x++) {
+            dst[y*mWidth+x] = current?0:0xffff;
+            if(countx++ >= size) {
+                countx=0;
+                current = !current;
+            }
+        }
+        if(county++ >= size) {
+            county=0;
+            black = !black;
+        }
+    }
+    mCheckX += 3;
+    mCheckY++;
+}
+
+
+void FakeCamera::dump(int fd) const
+{
+/*
+    const size_t SIZE = 256;
+    char buffer[SIZE];
+    String8 result;
+    snprintf(buffer, 255, " width x height (%d x %d), counter (%d), check x-y coordinate(%d, %d)\n", mWidth, mHeight, mCounter, mCheckX, mCheckY);
+    result.append(buffer);
+    ::write(fd, result.string(), result.size());
+    */
+}
+
+#if 0
+extern CameraInterface* HAL_GetCameraInterface(int Id)
+{
+	if(Id == 0)
+	{
+		return new fakecamerainter(320,240,0);
+	}
+	else
+		return new fakecamerainter(320,240,1);
+}
+#else
+extern CameraInterface* HAL_GetFakeCamera()
+{
+	return new fakecamerainter(320,240,1);
+}
+#endif
+
+}; // namespace android
+
diff --git a/FakeCamera/FakeCamera.h b/FakeCamera/FakeCamera.h
new file mode 100755
index 0000000..0ec69ab
--- a/dev/null
+++ b/FakeCamera/FakeCamera.h
@@ -0,0 +1,68 @@
+/*
+**
+** 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_FAKECAMERA_H
+#define ANDROID_HARDWARE_FAKECAMERA_H
+
+#include <sys/types.h>
+#include <stdint.h>
+
+namespace android {
+
+/*
+ * FakeCamera is used in the CameraHardwareStub to provide a fake video feed
+ * when the system does not have a camera in hardware.
+ * The fake video is a moving black and white checkerboard background with a
+ * bouncing gray square in the foreground.
+ * This class is not thread-safe.
+ *
+ * TODO: Since the major methods provides a raw/uncompressed video feed, rename
+ * this class to RawVideoSource.
+ */
+
+class FakeCamera {
+public:
+    FakeCamera(int width, int height);
+    ~FakeCamera();
+
+    void setSize(int width, int height);
+    void getNextFrameAsYuv422(uint8_t *buffer);
+    // Write to the fd a string representing the current state.
+    void dump(int fd) const;
+
+    // TODO: remove the uint16_t buffer param everywhere since it is a field of
+    // this class.
+    void getNextFrameAsRgb565(uint16_t *buffer);
+private:
+
+
+    void drawSquare(uint16_t *buffer, int x, int y, int size, int color, int shadow);
+    void drawCheckerboard(uint16_t *buffer, int size);
+
+    static const int kRed = 0xf800;
+    static const int kGreen = 0x07c0;
+    static const int kBlue = 0x003e;
+
+    int         mWidth, mHeight;
+    int         mCounter;
+    int         mCheckX, mCheckY;
+    uint16_t    *mTmpRgb16Buffer;
+};
+
+}; // namespace android
+
+#endif // ANDROID_HARDWARE_FAKECAMERA_H
diff --git a/OpCameraHardware.c b/OpCameraHardware.c
deleted file mode 100755
index 1d6cc5f..0000000
--- a/OpCameraHardware.c
+++ b/dev/null
@@ -1,431 +0,0 @@
-#define LOG_NDEBUG 0
-//#define NDEBUG 0
-#define LOG_TAG "OpCameraHardware"
-#include <utils/Log.h>
-#include "tvin.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>	
-	
-struct camera_info_s camera_info = 
-{
-	.camera_name = NULL,
-    .saturation = SATURATION_0_STEP,
-    .brighrness = BRIGHTNESS_0_STEP,
-    .contrast = CONTRAST_0_STEP,
-    .hue = HUE_0_DEGREE,
-    .exposure = EXPOSURE_0_STEP,
-    .sharpness = SHARPNESS_AUTO_STEP,
-    .mirro_flip = MF_NORMAL,
-    .resolution = TVIN_SIG_FMT_CAMERA_640X480P_30Hz,
-    .night_mode = CAM_NM_AUTO,
-    .effect = CAM_EFFECT_ENC_NORMAL,
-    .white_balance = CAM_WB_AUTO,
-    .qulity = 75,
-};
-char cameraName[PROPERTY_VALUE_MAX];
-
-int OpenCamera(void)
-{
- 	int camera_fd, ret  = 0;
-
-	/*open iotcl close*/
-	camera_fd = open("/dev/camera0", O_RDWR);
-	//printf("camera device open, fd is %d \n ", camera_fd);
-	if(camera_fd < 0)
-	{		
-		ret = -1;	
-		LOGV("AMLOGIC CAMERA OpenCamera camera0 fail !! ");
-		//printf("camera device  open return error string: %s\n", strerror(errno));
-	}
-	else
-	{
-		if (ioctl(camera_fd, CAMERA_IOC_START, &camera_info)<0)
-		{
-			ret = -1;
-			LOGV("AMLOGIC CAMERA open successful !! ");
-		}
-		close(camera_fd);
-	}
-	
-	return ret ;
-}
-
-int StopCamera(void)
-{
-	int camera_fd, ret = 0;
-	//struct camera_info_s camera_info;
-	camera_fd = open("/dev/camera0", O_RDWR);
-	if(camera_fd < 0)
-	{		
-		LOGV("AMLOGIC CAMERA open error !! ");
-		ret = -1;
-	}
-	else
-	{
-		if (ioctl(camera_fd, CAMERA_IOC_STOP, &camera_info)<0)
-		{	
-			LOGV("AMLOGIC CAMERA open successful !! ");
-			ret = -1;
-		}
-		close(camera_fd);			
-	}
-	return ret ;
-}
-
-int SetOsdOnOff(char* buf)
-{
-	int fd;	 
-	//fd = open("/sys/class/graphics/fb0/blank", O_RDWR);
-	//fd = open("/sys/class/amhdmitx/amhdmitx0/debug", O_RDWR);	
-	fd = open("/sys/bus/pseudo/drivers/amlogic_debug/amlogic_reg", O_RDWR);
-	if (fd<0)
-	{
-		LOGV("osd open error !! ");
-		return -1;
-	}
-	else
-	{
-		LOGV("osd open successful !! ");
-		lseek(fd,0,2);
-		write(fd,buf,15);
-		close(fd);				
-	}
-	return 0;		
-}
-
-tvin_sig_fmt_t ConvertResToDriver(int preview_width,int preview_height,int preview_FrameRate)
-{
-	tvin_sig_fmt_t index = TVIN_SIG_FMT_NULL ;
-
-    switch (preview_FrameRate)
-    {
-    	case 30:
-    		if ((preview_width==640)&&(preview_height==480))
-    		 	index = TVIN_SIG_FMT_CAMERA_640X480P_30Hz;
-    		else if ((preview_width==800)&&(preview_height==600))
-    		    index = TVIN_SIG_FMT_CAMERA_800X600P_30Hz;
-    		else if ((preview_width==1024)&&(preview_height==768))
-    		 	index = TVIN_SIG_FMT_CAMERA_1024X768P_30Hz;
-    		else if ((preview_width==1280)&&(preview_height==720))
-    		    index = TVIN_SIG_FMT_CAMERA_1280X720P_30Hz;
-    		else if ((preview_width==1920)&&(preview_height==1080))
-    		    index = TVIN_SIG_FMT_CAMERA_1920X1080P_30Hz;
-    	break;
-     	case 25:    	
-    	break;   	
-      	case 15:    	
-    	break;  
-    	default:
-    		//ret = TVIN_SIG_FMT_CAMERA_1280X720P_30Hz;
-    	break;
-    }
-    return index;
-}
-
-int SetParametersToDriver(void)
-{
- 	int camera_fd ,ret = 0;
-
-	/*open iotcl close*/
-	camera_fd = open("/dev/camera0", O_RDWR);
-	//printf("camera device open, fd is %d \n ", camera_fd);
-	if(camera_fd < 0)
-	{	
-		ret = -1;
-		LOGV("AMLOGIC CAMERA open camera0 fail !! ");
-		//printf("camera device  open return error string: %s\n", strerror(errno));
-	}
-	else
-	{
-		if(ioctl(camera_fd, CAMERA_IOC_SET_PARA, &camera_info)<0)
-		{	
-			ret = -1;
-			LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
-		}
-		close(camera_fd);
-	}	
-	return ret ;
-}
-
-char * getCameraName(void)
-{
-	memset(cameraName,0,sizeof(cameraName));
-	property_get("camera.name", cameraName, "camera");
-	return cameraName;
-}
-
-tvin_sig_fmt_t getCameraResolution(int *width,int *height)
-{
-	char resolution[PROPERTY_VALUE_MAX];
-	char *buf,*tmp;
-	tvin_sig_fmt_t ret;
-	buf = resolution;
-	property_get("camera.resolution", resolution, "640x480");
-	tmp = strsep(&buf,"x");
-	*width = atoi(tmp);
-	*height = atoi(buf);
-	if ((*width==640)&&(*height==480))
-		ret = TVIN_SIG_FMT_CAMERA_640X480P_30Hz;
-	else if ((*width==800)&&(*height==600))
-		ret = TVIN_SIG_FMT_CAMERA_800X600P_30Hz;
-	else if ((*width==1024)&&(*height==768))
-		ret = TVIN_SIG_FMT_CAMERA_1024X768P_30Hz;
-	else if ((*width==1280)&&(*height==720))
-		ret = TVIN_SIG_FMT_CAMERA_1280X720P_30Hz;
-	else if ((*width==1920)&&(*height==1080))
-		ret = TVIN_SIG_FMT_CAMERA_1920X1080P_30Hz;
-	else
-		ret = TVIN_SIG_FMT_CAMERA_640X480P_30Hz;
-	return ret;
-}
-
-camera_mirror_flip_t  getCameraMirrorFlip(void)
-{
-	char mirrorflip[PROPERTY_VALUE_MAX];
-	property_get("camera.mirrorflip", mirrorflip, "0");
-	return (camera_mirror_flip_t)atoi(mirrorflip);
-}
-
-int start_Capture(void)
-{
- 	int camera_fd ,ret = 0;
-
-	/*open iotcl close*/
-	camera_fd = open("/dev/camera0", O_RDWR);
-	//printf("camera device open, fd is %d \n ", camera_fd);
-	if(camera_fd < 0)
-	{	
-		ret = -1;
-		LOGV("AMLOGIC CAMERA open camera0 fail !! ");
-		//printf("camera device  open return error string: %s\n", strerror(errno));
-	}
-	else
-	{
-		if(ioctl(camera_fd, CAMERA_IOC_START_CAPTURE_PARA, &camera_info)<0)
-		{	
-			ret = -1;
-			LOGV("AMLOGIC CAMERA CAMERA_IOC_START_CAPTURE_PARA fail !! ");
-		}
-		LOGV("AMLOGIC CAMERA CAMERA_IOC_START_CAPTURE_PARA !! ");
-		close(camera_fd);
-	}	
-	return ret ;
-}
-
-int stop_Capture(void)
-{
- 	int camera_fd ,ret = 0;
-
-	/*open iotcl close*/
-	camera_fd = open("/dev/camera0", O_RDWR);
-	//printf("camera device open, fd is %d \n ", camera_fd);
-	if(camera_fd < 0)
-	{	
-		ret = -1;
-		LOGV("AMLOGIC CAMERA open camera0 fail !! ");
-		//printf("camera device  open return error string: %s\n", strerror(errno));
-	}
-	else
-	{
-		if(ioctl(camera_fd, CAMERA_IOC_STOP_CAPTURE_PARA, &camera_info)<0)
-		{	
-			ret = -1;
-			LOGV("AMLOGIC CAMERA CAMERA_IOC_STOP_CAPTURE_PARA fail !! ");
-		}
-		LOGV("AMLOGIC CAMERA CAMERA_IOC_STOP_CAPTURE_PARA !! ");
-		close(camera_fd);
-	}	
-	return ret ;
-}
-int SetExposure(const char *sbn)
-{
- 	int camera_fd ,ret = 0;
-	enum camera_exposure_e bn=0;
-
-	if(strcasecmp(sbn,"4")==0)
-		bn=EXPOSURE_P4_STEP;
-	else if(strcasecmp(sbn,"3")==0)
-		bn=EXPOSURE_P3_STEP;
-	else if(strcasecmp(sbn,"2")==0)
-		bn=EXPOSURE_P2_STEP;
-	else if(strcasecmp(sbn,"1")==0)
-		bn=EXPOSURE_P1_STEP;
-	else if(strcasecmp(sbn,"0")==0)
-		bn=EXPOSURE_0_STEP;
-	else if(strcasecmp(sbn,"-1")==0)
-		bn=EXPOSURE_N1_STEP;
-	else if(strcasecmp(sbn,"-2")==0)
-		bn=EXPOSURE_N2_STEP;
-	else if(strcasecmp(sbn,"-3")==0)
-		bn=EXPOSURE_N3_STEP;
-	else if(strcasecmp(sbn,"-4")==0)
-		bn=EXPOSURE_N4_STEP;
-
-	if(camera_info.exposure!=bn){
-		camera_info.exposure =bn;
-		LOGV("AMLOGIC CAMERA SetExposure!! ");
-
-		/*open iotcl close*/
-		camera_fd = open("/dev/camera0", O_RDWR);
-		//printf("camera device open, fd is %d \n ", camera_fd);
-		if(camera_fd < 0)
-			{	
-			ret = -1;
-			LOGV("AMLOGIC CAMERA open camera0 fail !! ");
-			//printf("camera device  open return error string: %s\n", strerror(errno));
-			}
-		else
-			{
-			if(ioctl(camera_fd, CAMERA_IOC_SET_PARA, &camera_info)<0)
-				{	
-				ret = -1;
-				LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
-				}
-			close(camera_fd);
-			}	
-		}
-	return ret ;
-}
-
-int set_white_balance(const char *swb)
-{
- 	int camera_fd ,ret = 0;
-	enum camera_wb_flip_e wb=0;
-
-	if(strcasecmp(swb,"auto")==0)
-		wb=CAM_WB_AUTO;
-	else if(strcasecmp(swb,"daylight")==0)
-		wb=CAM_WB_DAYLIGHT;
-	else if(strcasecmp(swb,"incandescent")==0)
-		wb=CAM_WB_INCANDESCENCE;
-	else if(strcasecmp(swb,"fluorescent")==0)
-		wb=CAM_WB_INCANDESCENCE;
-
-
-	if(camera_info.white_balance!=wb){
-		camera_info.white_balance =wb;
-
-		/*open iotcl close*/
-		LOGV("AMLOGIC CAMERA set_white_balance!! ");
-		camera_fd = open("/dev/camera0", O_RDWR);
-		//printf("camera device open, fd is %d \n ", camera_fd);
-		if(camera_fd < 0)
-			{	
-			ret = -1;
-			LOGV("AMLOGIC CAMERA open camera0 fail !! ");
-			//printf("camera device  open return error string: %s\n", strerror(errno));
-			}
-		else
-			{
-			if(ioctl(camera_fd, CAMERA_IOC_SET_PARA, &camera_info)<0)
-				{	
-				ret = -1;
-				LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
-				}
-			close(camera_fd);
-			}	
-		}
-	return ret ;
-}
-int set_effect(const char *sef)
-{
- 	int camera_fd ,ret = 0;
-	enum camera_effect_flip_e ef=0;
-
-	if(strcasecmp(sef,"auto")==0)
-		ef=CAM_EFFECT_ENC_NORMAL;
-	else if(strcasecmp(sef,"negative")==0)
-		ef=CAM_EFFECT_ENC_COLORINV;
-	else if(strcasecmp(sef,"sepia")==0)
-		ef=CAM_EFFECT_ENC_SEPIA;
-
-
-	if(camera_info.effect!=ef){
-		camera_info.effect =ef;
-
-		/*open iotcl close*/
-		LOGV("AMLOGIC CAMERA set_effect!! ");
-		camera_fd = open("/dev/camera0", O_RDWR);
-		//printf("camera device open, fd is %d \n ", camera_fd);
-		if(camera_fd < 0)
-			{	
-			ret = -1;
-			LOGV("AMLOGIC CAMERA open camera0 fail !! ");
-			//printf("camera device  open return error string: %s\n", strerror(errno));
-			}
-		else
-			{
-			if(ioctl(camera_fd, CAMERA_IOC_SET_PARA, &camera_info)<0)
-				{	
-				ret = -1;
-				LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
-				}
-			close(camera_fd);
-			}	
-		}
-	return ret ;
-}
-
-int set_night_mode(const char *snm)
-{
- 	int camera_fd ,ret = 0;
-	enum camera_night_mode_flip_e nm=0;
-
-	if(strcasecmp(snm,"auto")==0)
-		nm=CAM_NM_AUTO;
-	else if(strcasecmp(snm,"night")==0)
-		nm=CAM_NM_ENABLE;
-
-
-	if(camera_info.effect!=nm){
-		camera_info.effect =nm;
-
-		/*open iotcl close*/
-		LOGV("AMLOGIC CAMERA set_night_mode!! ");
-		camera_fd = open("/dev/camera0", O_RDWR);
-		//printf("camera device open, fd is %d \n ", camera_fd);
-		if(camera_fd < 0)
-			{	
-			ret = -1;
-			LOGV("AMLOGIC CAMERA open camera0 fail !! ");
-			//printf("camera device  open return error string: %s\n", strerror(errno));
-			}
-		else
-			{
-			if(ioctl(camera_fd, CAMERA_IOC_SET_PARA, &camera_info)<0)
-				{	
-				ret = -1;
-				LOGV("AMLOGIC CAMERA SetParametersToDriver fail !! ");
-				}
-			close(camera_fd);
-			}	
-		}
-	return ret ;
-}
-
-int set_qulity(const char *squ)
-{
- 	int camera_fd ,ret = 0;
-
-	if(strcasecmp(squ,"70")==0)
-		camera_info.qulity=70;
-	else if(strcasecmp(squ,"80")==0)
-		camera_info.qulity=80;
-	else if(strcasecmp(squ,"90")==0)
-		camera_info.qulity=90;
-	else
-		camera_info.qulity=90;
-
-	return ret ;
-}
-
-
diff --git a/OpVdin.c b/OpVdin.c
deleted file mode 100755
index 8e54c27..0000000
--- a/OpVdin.c
+++ b/dev/null
@@ -1,339 +0,0 @@
-#define LOG_NDEBUG 0
-#define NDEBUG 0
-#define LOG_TAG "OpVdin"
-#include <utils/Log.h>
-#include <sys/mman.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 "tvin.h"
-
-
-int global_w=1280,global_h=720;
-
-
-#include "jpeglib.h"
-#include "jconfig.h"
-
-#include <setjmp.h>
-#include "amljpeg_enc.h"
-typedef struct {
-  struct jpeg_destination_mgr pub; /* public fields */
-
-  char* obuf;
-  int buf_size;
-  int data_size;
-} aml_destination_mgr;
-
-typedef aml_destination_mgr * aml_dest_ptr;
-
-static void init_destination (j_compress_ptr cinfo)
-{
-  aml_dest_ptr dest = (aml_dest_ptr) cinfo->dest;
-
-  dest->pub.next_output_byte = dest->obuf;
-  dest->pub.free_in_buffer = dest->buf_size;
-}
-
-static boolean empty_output_buffer (j_compress_ptr cinfo)
-{
-  aml_dest_ptr dest = (aml_dest_ptr) cinfo->dest;
-
-  /* error handling, input buffer too small. */
-  /* maybe you need not use jpeg encoder. */
-
-  return FALSE;
-}
-
-static void term_destination (j_compress_ptr cinfo)
-{
-  aml_dest_ptr dest = (aml_dest_ptr) cinfo->dest;
-  size_t datacount = dest->buf_size - dest->pub.free_in_buffer;
-
-  dest->data_size = datacount;
-}
-
-int encode_jpeg(jpeg_enc_t* enc) 
-{
-
-	/* create compress. information data. */
-	struct jpeg_compress_struct cinfo;
-	struct jpeg_error_mgr jerr;
-	aml_destination_mgr dest;
-	
-	JSAMPROW row_pointer[1];	/* pointer to JSAMPLE row[s] */
-	int row_stride;		/* physical row width in image buffer */
-	cinfo.err = jpeg_std_error(&jerr);
-	jpeg_create_compress(&cinfo);
-	//jpeg_stdio_dest(&cinfo, outfile);
-	cinfo.dest=(struct jpeg_destination_mgr *)&dest;
-	dest.pub.init_destination = init_destination;
-	dest.pub.empty_output_buffer = empty_output_buffer;
-	dest.pub.term_destination = term_destination;
-	
-	dest.obuf = enc->odata;
-	dest.buf_size = enc->obuff_size;
-
-	/* set parameters. */
-	cinfo.image_width = enc->width; 	
-	cinfo.image_height = enc->height;
-	cinfo.input_components = 3;		
-	cinfo.in_color_space = JCS_RGB;
-	jpeg_set_defaults(&cinfo);
-	if(enc->quality==0)
-		enc->quality=75;
-	jpeg_set_quality(&cinfo, enc->quality, TRUE);
-
-	jpeg_start_compress(&cinfo, TRUE);
-
-	row_stride = enc->width * 3;	
-
-	/* processing. */
-	while (cinfo.next_scanline < cinfo.image_height) {
-		row_pointer[0] = & enc->idata[cinfo.next_scanline * row_stride];
-		(void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
-	}
-
-	jpeg_finish_compress(&cinfo);
-	jpeg_destroy_compress(&cinfo);
-	return dest.data_size;
-}
-
-
-
-#include <cmem.h>
-#include "ge2d.h"
-#define CANVAS_ALIGNED(x)	(((x) + 7) & ~7)
-CMEM_AllocParams cmemParm;
-#define   FILE_NAME_GE2D		  "/dev/ge2d"
-
-int cmem_init()
-{
-	cmemParm.type=CMEM_HEAP; cmemParm.flags=CMEM_NONCACHED; cmemParm.alignment=8;
-	if(CMEM_init())
-    {    
-		LOGV("cmem init error\n");	
-		return -1;	
-    }
-    return 0;
-}
-
-void cmem_exit()
-{
-	CMEM_exit();    
-}
-int GetCameraOutputData(char *buf,int dst_format)
-{
-	int fd_vdin, fd_ge2d;	
-	struct tvin_parm_s src_mux_cfg;
-	ge2d_op_para_t op_para={0};
-	config_para_ex_t ge2d_config_ex={0};
-	char *mp = NULL , *dst_plan =NULL;;
-	
-	fd_vdin = open("/dev/vdin0", O_RDWR);
-	
-	if (fd_vdin>=0)
-	{	
-		
-		if(ioctl(fd_vdin, TVIN_IOC_G_PARM, &src_mux_cfg) < 0)
-			LOGV("AMLOGIC CAMERA API: ioctl get parm error");
-			
-		if (src_mux_cfg.status != TVIN_SIG_STATUS_STABLE)
-        {
-        	//sleep(40); 	//delay 40ms wait for nex field	
-        	usleep(40000); //delay 40ms wait for nex field
-        	LOGV("AMLOGIC CAMERA API: status not stable");            
-        }
-                
-		src_mux_cfg.flag |= TVIN_PARM_FLAG_CAP;
-		
-		if (ioctl(fd_vdin, TVIN_IOC_S_PARM, &src_mux_cfg) < 0)
-			LOGV("AMLOGIC CAMERA API: ioctl set cap_falg error");	
-			
-		usleep(40000); 		
-		//sleep(2);
-		if(ioctl(fd_vdin, TVIN_IOC_G_PARM, &src_mux_cfg) < 0)
-			LOGV("AMLOGIC CAMERA API: ioctl get cap parm error");				
-
-		
-		if (cmem_init()<0)
-		{
-			close(fd_vdin);
-			return -1;
-		}
-	
-	    fd_ge2d = open(FILE_NAME_GE2D, O_RDWR);
-		if (fd_ge2d<0)
-		{
-			LOGV("AMLOGIC CAMERA API: open ge2d fail ");
-			close(fd_vdin);
-			return -1;	
-		}
-		if (dst_format==GE2D_FORMAT_S24_BGR)
-	    	dst_plan=CMEM_alloc(0,global_w*global_h*3, &cmemParm);
-	    else
-	    	dst_plan=CMEM_alloc(0,global_w*global_h*2, &cmemParm);
-	    if(!dst_plan) 
-	    {
-		    LOGV("AMLOGIC CAMERA API: CMEM_alloc error ");
-			close(fd_ge2d);
-			close(fd_vdin);
-			return -1;
-	    }
-	    
-	    mp = (char *)mmap(0, src_mux_cfg.cap_size, (PROT_WRITE | PROT_READ), MAP_SHARED, fd_vdin, 0);
-	    
-	    //LOGE("API: mmap return addr is:%x \n", (int)mp);
-	    
-	    if(MAP_FAILED == mp) 
-	    {
-	    	LOGV("AMLOGIC CAMERA API: mmap failed\n");        
-	    	CMEM_free(dst_plan, &cmemParm); 		   
-	        cmem_exit();  
-	        close(fd_ge2d);
-	        close(fd_vdin);
-	        return -1;
-	    }  
-	    
-	   // LOGV("AMLOGIC CAMERA API: write mmap OK ");  
-		
-	    ge2d_config_ex.alu_const_color = 0xff0000ff;
-	    ge2d_config_ex.src1_gb_alpha = 0xff;
-	    ge2d_config_ex.dst_xy_swap = 0;
-	
-	    ge2d_config_ex.src_para.canvas_index=(src_mux_cfg.canvas_index);
-	    ge2d_config_ex.src_para.mem_type = TYPE_INVALID;
-	    ge2d_config_ex.src_para.format  = GE2D_FORMAT_S16_YUV422;//GE2D_FORMAT_S16_YUV422;
-	    ge2d_config_ex.src_para.x_rev = 0;
-	    ge2d_config_ex.src_para.y_rev = 0;
-	    ge2d_config_ex.src_para.color = 0xff;
-	    ge2d_config_ex.src_para.top = 0;
-	    ge2d_config_ex.src_para.left = 0;
-	    ge2d_config_ex.src_para.width = global_w;/* buffer width. */
-	    ge2d_config_ex.src_para.height = global_h;/* buffer height. */
-	
-	    ge2d_config_ex.src2_para.mem_type = CANVAS_TYPE_INVALID;
-	
-	    ge2d_config_ex.dst_para.mem_type = CANVAS_ALLOC;//CANVAS_OSD1;//CANVAS_ALLOC;//CANVAS_OSD0
-	    ge2d_config_ex.dst_para.format  = dst_format;//GE2D_FORMAT_S16_RGB_565;//GE2D_FORMAT_S32_ARGB;//GE2D_FORMAT_S16_RGB_565;
-	    ge2d_config_ex.dst_para.x_rev = 0;
-	    ge2d_config_ex.dst_para.y_rev = 0;
-	    ge2d_config_ex.dst_para.color = 0;
-	    ge2d_config_ex.dst_para.top = 0;
-	    ge2d_config_ex.dst_para.left = 0;
-	    ge2d_config_ex.dst_para.width = global_w;/* buffer width. */;
-	    ge2d_config_ex.dst_para.height =global_h; /* buffer height. */;
-	    
-	 	ge2d_config_ex.dst_planes[0].addr = CMEM_getPhys(dst_plan);
-	    ge2d_config_ex.dst_planes[0].w = global_w;
-	    ge2d_config_ex.dst_planes[0].h = global_h;  
-		
-	    ioctl(fd_ge2d, FBIOPUT_GE2D_CONFIG_EX, &ge2d_config_ex);
-		
-	    memset((char*)&op_para,0,sizeof(ge2d_op_para_t));
-	    
-	    op_para.src1_rect.x = 0;
-	    op_para.src1_rect.y = 0;
-	    op_para.src1_rect.w =global_w; /*input_image_width*/;
-	    op_para.src1_rect.h =global_h; /*input_image_height*/;
-	    op_para.dst_rect.x = 0;
-	    op_para.dst_rect.y = 0;
-	    op_para.dst_rect.w = global_w;/*output_image_width*/;
-	    op_para.dst_rect.h = global_h;/*output_image_height*/;    
-	    
-	    ioctl(fd_ge2d, FBIOPUT_GE2D_STRETCHBLIT_NOALPHA, &op_para); 
-	    	
-		//LOGV("AMLOGIC CAMERA API: ge2d  ioctl 444");
-			
-		if (dst_format==GE2D_FORMAT_S24_BGR)
-			memcpy(buf,dst_plan,global_w*global_h*3);
-		else		
-			memcpy(buf,dst_plan,global_w*global_h*2);
-			
-		CMEM_free(dst_plan, &cmemParm); 	 
-		   
-	    cmem_exit();  
-	
-	        
-	    if (munmap(mp, src_mux_cfg.cap_size) < 0)
-	       LOGV("API: nunmap error\n");  
-	       
-	    src_mux_cfg.flag &= ~TVIN_PARM_FLAG_CAP ;        
-	    
-	    if (ioctl(fd_vdin, TVIN_IOC_S_PARM, &src_mux_cfg) < 0)
-			LOGV("AMLOGIC CAMERA API: ioctl set para error");
-									
-		close(fd_vdin);
-		close(fd_ge2d);	
-			
-		return 0 ;
-		
-	}
-	else
-	{
-		LOGV("AMLOGIC CAMERA vdin device open error !!");
-		return -1;	
-	}			
-
-}
-
-
-
-int Openvdin(void)
-{
- 	int vdin_fd, temp_index = -1;
-	tvin_sig_fmt_t resolution_index = ConvertResToDriver(global_w,global_h,30);
-	struct tvin_parm_s src_mux_cfg = {TVIN_PORT_CAMERA,resolution_index, TVIN_SIG_STATUS_NULL, 0, 0,0,0};
-//	struct tvin_parm_s src_mux_cfg = {TVIN_PORT_BT656, TVIN_SIG_FMT_BT656IN_576I, TVIN_SIG_STATUS_NULL, 0x82000000, 0};
-	/*open iotcl close*/
-	vdin_fd = open("/dev/vdin0", O_RDWR);
-
-	if(vdin_fd >= 0)
-	{	
-		temp_index = ioctl(vdin_fd, TVIN_IOC_START_DEC, &src_mux_cfg);			
-		close(vdin_fd);
-		LOGV("AMLOGIC CAMERA vdin device open successful !!");	
-		return 0;
-	}
-	else
-	{
-		LOGV("AMLOGIC CAMERA vdin device open error !!");
-		return -1;
-	}
-
-}
-
-int Stopvdin(void)
-{
- 	int vdin_fd, temp_index = -1;
-	tvin_sig_fmt_t resolution_index = ConvertResToDriver(global_w,global_h,30);
-	struct tvin_parm_s src_mux_cfg = {TVIN_PORT_CAMERA,resolution_index, TVIN_SIG_STATUS_NULL, 0x82000000,0, 0,0};
-//	struct tvin_parm_s src_mux_cfg = {TVIN_PORT_BT656, TVIN_SIG_FMT_BT656IN_576I, TVIN_SIG_STATUS_NULL, 0x82000000, 0};
-	/*open iotcl close*/
-	vdin_fd = open("/dev/vdin0", O_RDWR);
-
-	if(vdin_fd < 0)
-	{
-		LOGV("AMLOGIC CAMERA Stopvdin error !!");
-		return -1;
-	}	
-	else
-	{	
-		temp_index = ioctl(vdin_fd, TVIN_IOC_STOP_DEC, &src_mux_cfg);			
-		close(vdin_fd);
-		LOGV("AMLOGIC CAMERA Stopvdin successful !!");	
-		return 0;
-	}
-
-}
-
-	
-
diff --git a/V4L2/V4L2Camera.cpp b/V4L2/V4L2Camera.cpp
new file mode 100755
index 0000000..acec82e
--- a/dev/null
+++ b/V4L2/V4L2Camera.cpp
@@ -0,0 +1,391 @@
+#define LOG_NDEBUG 0

+#define NDEBUG 0

+

+#define LOG_TAG "V4L2Camera"

+#include <utils/Log.h>

+#include "V4L2Camera.h"

+#include <linux/videodev2.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 <jpegenc/amljpeg_enc.h>

+

+namespace android {

+

+static void dump_to_file(const char *fname,uint8_t *buf, uint32_t size);

+

+

+#define V4L2_PREVIEW_BUFF_NUM (2)

+#define V4L2_TAKEPIC_BUFF_NUM (1)

+#define V4L2_JPEG_QUALITY	(90)

+

+V4L2Camera::V4L2Camera(char* devname)

+{

+	int namelen = strlen(devname)+1;

+	m_pDevName = new char[namelen];

+	strcpy(m_pDevName,devname);

+	m_iDevFd = -1;

+

+	m_V4L2BufNum = 0;

+	pV4L2Frames = NULL;

+	pV4L2FrameSize = NULL;

+	m_iPicIdx = -1;

+}

+V4L2Camera::~V4L2Camera()

+{

+	delete m_pDevName;

+}

+

+status_t	V4L2Camera::Open()

+{

+	if(m_iDevFd == -1)

+	{

+		m_iDevFd = open(m_pDevName, O_RDWR);

+    	if (m_iDevFd != -1)

+		{

+    		LOGD("open %s success %d \n", m_pDevName,m_iDevFd);

+      		return NO_ERROR;

+    	}

+		else

+		{

+			LOGD("open %s fail\n", m_pDevName);

+			return UNKNOWN_ERROR;

+		}

+	}

+

+	return NO_ERROR;

+}

+status_t	V4L2Camera::Close()

+{

+	if(m_iDevFd != -1)

+	{

+		close(m_iDevFd);

+		m_iDevFd = -1;

+	}

+	return NO_ERROR;

+}

+status_t	V4L2Camera::InitParameters(CameraParameters& pParameters)

+{

+	//set the limited & the default parameter

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

+	pParameters.setPreviewSize(640, 480);

+	pParameters.setPreviewFrameRate(15);

+	pParameters.setPreviewFormat(CameraParameters::PIXEL_FORMAT_RGB565);

+

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

+	pParameters.setPictureSize(800,600);

+	pParameters.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);

+

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

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

+	

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

+	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_SCENE_MODE,"auto");

+

+	//pParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,"auto,infinity,macro");		

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

+

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

+	pParameters.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,-2);

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

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

+

+	//pParameters.set(CameraParameters::KEY_MAX_ZOOM,3);		

+	//pParameters.set(CameraParameters::KEY_ZOOM_RATIOS,"100,120,140,160,200,220,150,280,290,300");

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

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

+	//pParameters.set(CameraParameters::KEY_ZOOM,1);

+

+	return NO_ERROR;

+}

+

+//write parameter to v4l2 driver

+status_t	V4L2Camera::SetParameters(CameraParameters& pParameters)

+{

+	m_hParameter = pParameters;

+	LOGD("V4L2Camera::SetParameters");

+	return NO_ERROR;

+}

+

+status_t	V4L2Camera::StartPreview()

+{

+	int w,h;

+	m_hParameter.getPreviewSize(&w,&h);

+	if( (NO_ERROR == V4L2_BufferInit(w,h,V4L2_PREVIEW_BUFF_NUM,V4L2_PIX_FMT_RGB565X))

+		&& (V4L2_StreamOn() == NO_ERROR))

+		return NO_ERROR;

+	else

+		return UNKNOWN_ERROR;

+}

+status_t	V4L2Camera::StopPreview()

+{

+	if( (NO_ERROR == V4L2_StreamOff())

+		&& (V4L2_BufferUnInit() == NO_ERROR))

+		return NO_ERROR;

+	else

+		return UNKNOWN_ERROR;

+}

+

+status_t	V4L2Camera::TakePicture()

+{

+	int w,h;

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

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

+	V4L2_StreamOn();

+	m_iPicIdx = V4L2_BufferDeQue();

+	V4L2_StreamOff();

+	return NO_ERROR;

+}

+

+status_t	V4L2Camera::TakePictureEnd()

+{

+	m_iPicIdx = -1;

+	return 	V4L2_BufferUnInit();

+}

+

+status_t	V4L2Camera::GetPreviewFrame(uint8_t* framebuf)

+{

+	//LOGD("V4L2Camera::GetPreviewFrame\n");

+	int idx = V4L2_BufferDeQue();

+	memcpy((char*)framebuf,pV4L2Frames[idx],pV4L2FrameSize[idx]);

+	V4L2_BufferEnQue(idx);

+	return NO_ERROR;	

+}

+

+status_t	V4L2Camera::GetRawFrame(uint8_t* framebuf) 

+{

+	if(m_iPicIdx!=-1)

+	{

+		memcpy(framebuf,pV4L2Frames[m_iPicIdx],pV4L2FrameSize[m_iPicIdx]);

+	}

+	else

+		LOGD("GetRawFraem index -1");

+	return NO_ERROR;	

+}

+status_t	V4L2Camera::GetJpegFrame(uint8_t* framebuf)

+{

+	if(m_iPicIdx!=-1)

+	{

+		jpeg_enc_t enc;

+		m_hParameter.getPictureSize(&enc.width,&enc.height);

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

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

+		enc.ibuff_size =  pV4L2FrameSize[m_iPicIdx];

+		enc.obuff_size =  pV4L2FrameSize[m_iPicIdx];

+		enc.quality = V4L2_JPEG_QUALITY;

+		encode_jpeg(&enc);

+	}

+	else

+		LOGD("GetRawFraem index -1");

+	return NO_ERROR;		

+}

+

+

+//===============================

+//functions for set V4L2

+status_t V4L2Camera::V4L2_BufferInit(int Buf_W,int Buf_H,int Buf_Num,int colorfmt)

+{

+	struct v4l2_format hformat;

+	memset(&hformat,0,sizeof(v4l2_format));

+	hformat.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

+	hformat.fmt.pix.width = Buf_W;

+	hformat.fmt.pix.height = Buf_H;

+	hformat.fmt.pix.pixelformat = colorfmt;

+	LOGD("V4L2_BufferInit::Set Video Size %d,%d",Buf_W,Buf_H);

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

+	{

+		return UNKNOWN_ERROR;

+	}

+

+	//requeset buffers in V4L2

+	v4l2_requestbuffers hbuf_req;

+	memset(&hbuf_req,0,sizeof(v4l2_requestbuffers));

+	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_iDevFd, VIDIOC_REQBUFS, &hbuf_req) == -1) 

+	{

+		LOGD("Req V4L2 buffer fail");

+		return UNKNOWN_ERROR;

+	}

+	else

+	{

+		if (hbuf_req.count < Buf_Num) 

+		{

+		    LOGD("Req V4L2 buffer Fail");

+			return UNKNOWN_ERROR;

+		}

+		else//memmap these buffer to user space

+		{

+			pV4L2Frames = (void**)new int[Buf_Num];

+			pV4L2FrameSize = new int[Buf_Num];

+			int i = 0;

+			v4l2_buffer hbuf_query;

+			memset(&hbuf_query,0,sizeof(v4l2_buffer));

+

+			hbuf_query.type = hbuf_req.type;

+			hbuf_query.memory = V4L2_MEMORY_MMAP;

+			for(;i<Buf_Num;i++)

+			{

+				hbuf_query.index = i;

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

+				{

+					LOGD("Memap V4L2 buffer Fail");

+					return UNKNOWN_ERROR;

+				}

+

+				pV4L2FrameSize[i] = hbuf_query.length;

+				LOGD("V4L2_BufferInit::Get Buffer Idx %d Len %d",i,pV4L2FrameSize[i]);

+				pV4L2Frames[i] = mmap(NULL,pV4L2FrameSize[i],PROT_READ | PROT_WRITE,MAP_SHARED,m_iDevFd,hbuf_query.m.offset);

+				if(pV4L2Frames[i] == MAP_FAILED)

+				{

+					LOGD("Memap V4L2 buffer Fail");

+					return UNKNOWN_ERROR;

+				}

+				//enqueue buffer

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

+				{

+					LOGD("GetPreviewFrame nque buffer fail");

+					return UNKNOWN_ERROR;

+			    }

+			}

+			m_V4L2BufNum = Buf_Num;

+		}

+	}

+	return NO_ERROR;

+}

+

+status_t V4L2Camera::V4L2_BufferUnInit()

+{

+	if(m_V4L2BufNum > 0)

+	{

+		//un-memmap

+		int i = 0;

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

+		{

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

+			pV4L2Frames[i] = NULL;

+			pV4L2FrameSize[i] = 0;

+		}

+		m_V4L2BufNum = 0;

+		delete pV4L2Frames;

+		delete pV4L2FrameSize;

+		pV4L2FrameSize = NULL;

+		pV4L2Frames = NULL;

+	}

+	return NO_ERROR;

+}

+

+status_t V4L2Camera::V4L2_BufferEnQue(int idx)

+{

+	v4l2_buffer hbuf_query;

+	memset(&hbuf_query,0,sizeof(v4l2_buffer));

+	hbuf_query.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

+	hbuf_query.memory = V4L2_MEMORY_MMAP;//¼ÓºÍ²»¼ÓindexÓÐʲôÇø±ð¿

+	hbuf_query.index = idx;

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

+	{

+		LOGD("V4L2_BufferEnQue fail");

+		return UNKNOWN_ERROR;

+    }

+

+	LOGD("V4L2_BufferEnQue success");

+	return NO_ERROR;

+}

+int  V4L2Camera::V4L2_BufferDeQue()

+{

+	LOGD("V4L2_BufferEnQue ");

+	v4l2_buffer hbuf_query;

+	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_iDevFd, VIDIOC_DQBUF, &hbuf_query) == -1) 

+	{

+		LOGD("V4L2_StreamGet Deque buffer fail");

+		return UNKNOWN_ERROR;

+    }

+	LOGD("V4L2_StreamGet bufferidx %d\n",hbuf_query.index);

+	assert (hbuf_query.index < m_V4L2BufNum);

+	return hbuf_query.index;	

+}

+

+status_t	V4L2Camera::V4L2_StreamOn()

+{

+	LOGD("V4L2_StreamOn");

+	int stream_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

+	if (ioctl(m_iDevFd, VIDIOC_STREAMON, &stream_type) == -1)

+		LOGD("V4L2_StreamOn Fail");

+	LOGD("V4L2_StreamOn Succes");

+	return NO_ERROR;

+}

+

+status_t	V4L2Camera::V4L2_StreamOff()

+{

+	LOGD("V4L2_StreamOff");

+	int stream_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

+	if (ioctl(m_iDevFd, VIDIOC_STREAMOFF, &stream_type) == -1)

+		LOGD("V4L2_StreamOff  Fail");

+	else

+		LOGD("V4L2_StreamOff  Success");

+	return NO_ERROR;

+}

+

+//extern CameraInterface* HAL_GetFakeCamera();

+extern CameraInterface* HAL_GetCameraInterface(int Id)

+{

+	LOGD("HAL_GetCameraInterface return V4L2 interface");

+	if(Id == 0)

+		return new V4L2Camera("/dev/video0");

+	else

+		return new V4L2Camera("/dev/video1");

+}

+

+

+

+#if 0

+//debug funtctions

+static void dump_to_file(const char *fname,uint8_t *buf, uint32_t size)

+{
+    int nw, cnt = 0;
+    uint32_t written = 0;
+
+    LOGV("opening file [%s]\n", fname);
+    int fd = open(fname, O_RDWR | O_CREAT);
+    if (fd < 0) {
+        LOGE("failed to create file [%s]: %s", fname, strerror(errno));
+        return;
+    }
+
+    LOGV("writing %d bytes to file [%s]\n", size, fname);
+    while (written < size) {
+        nw = ::write(fd,
+                     buf + written,
+                     size - written);
+        if (nw < 0) {
+            LOGE("failed to write to file [%s]: %s",
+                 fname, strerror(errno));
+            break;
+        }
+        written += nw;
+        cnt++;
+    }
+    LOGV("done writing %d bytes to file [%s] in %d passes\n",
+         size, fname, cnt);
+    ::close(fd);
+}

+#endif

+

+};

diff --git a/V4L2/V4L2Camera.h b/V4L2/V4L2Camera.h
new file mode 100755
index 0000000..e9dda99
--- a/dev/null
+++ b/V4L2/V4L2Camera.h
@@ -0,0 +1,56 @@
+#include "../AmlogicCameraHardware.h"

+#include <camera/CameraHardwareInterface.h>

+

+

+namespace android {

+

+class V4L2Camera : public CameraInterface

+{

+public:

+	V4L2Camera(char* devname);

+	~V4L2Camera();

+	status_t	Open() ;

+	status_t	Close();

+	status_t	StartPreview();

+	status_t	StopPreview();

+	status_t	StartRecord()	{return NO_ERROR;}

+	status_t	StopRecord() {return NO_ERROR;}

+	status_t	TakePicture();

+	status_t	TakePictureEnd();

+	status_t	StartFocus() {return NO_ERROR;}

+	status_t	StopFocus() {return NO_ERROR;}

+	status_t	InitParameters(CameraParameters& pParameters);

+	status_t	SetParameters(CameraParameters& pParameters) ;

+	status_t	GetPreviewFrame(uint8_t* framebuf) ;

+	status_t	GetRawFrame(uint8_t* framebuf) ;

+	status_t	GetJpegFrame(uint8_t* framebuf) ;	

+	int			GetCamId() {return 0;}

+

+protected:

+	CameraParameters m_hParameter;

+

+

+protected:

+	//internal used for controling V4L2

+	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

+

+

+	status_t	V4L2_StreamOn();

+	status_t	V4L2_StreamOff();

+

+

+

+	void**		pV4L2Frames;

+	int*		pV4L2FrameSize;

+

+	char* 		m_pDevName;

+	int			m_iDevFd;

+	int 		m_V4L2BufNum;

+	int			m_iPicIdx;

+};

+

+

+};

diff --git a/cmem.c b/cmem.c
deleted file mode 100644
index 71c0f9e..0000000
--- a/cmem.c
+++ b/dev/null
@@ -1,607 +0,0 @@
-/*

- * Copyright (c) 2009, Texas Instruments Incorporated

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- *

- * *  Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- *

- * *  Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- *

- * *  Neither the name of Texas Instruments Incorporated nor the names of

- *    its contributors may be used to endorse or promote products derived

- *    from this software without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

- * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- *

- */

-

-/*

- * cmem.c

- */

-

-#include <stdio.h>

-#include <unistd.h>

-#include <sys/mman.h>

-#include <sys/types.h>

-#include <sys/stat.h>

-#include <sys/ioctl.h>

-#include <fcntl.h>

-#include <errno.h>

-#include <string.h>

-#include <cutils/log.h>

-

-#include "cmem.h"

-

-CMEM_AllocParams CMEM_DEFAULTPARAMS = {

-    CMEM_POOL,          /* type */

-    CMEM_NONCACHED,     /* flags */

-    1                   /* alignment */

-};

-#ifdef __DEBUG

-#define __D(fmt, args...) fprintf(stderr, "CMEM Debug: " fmt, ## args)

-#else

-#define __D(fmt, args...)

-#endif

-

-#define __E(fmt, args...) fprintf(stderr, "CMEM Error: " fmt, ## args)

-

-/*

-#undef __D

-#undef __E

-#define __D(fmt, args...) LOGD("CMEM Debug: " fmt, ## args)

-#define __E(fmt, args...) LOGD("CMEM Error: " fmt, ## args)

-*/

-struct block_struct {

-    unsigned long addr;

-    size_t size;

-};

-

-/* set cmem_fd to -2 to distinguish from failed open (-1) */

-static int cmem_fd = -2;

-static int ref_count = 0;

-

-static int validate_init()

-{

-    switch (cmem_fd) {

-      case -3:

-        __E("CMEM_exit() already called, check stderr output for earlier "

-            "CMEM failure messages (possibly version mismatch).\n");

-

-        return 0;

-

-      case -2:

-        __E("CMEM_init() not called, you must initialize CMEM before "

-            "making API calls.\n");

-

-        return 0;

-

-      case -1:

-        __E("CMEM file descriptor -1 (failed 'open()'), ensure CMEMK "

-            "kernel module cmemk.ko has been installed with 'insmod'");

-

-        return 0;

-

-      default:

-        return 1;

-    }

-}

-

-int CMEM_init(void)

-{

-    int flags;

-    unsigned int version;

-

-    __D("init: entered - ref_count %d, cmem_fd %d\n", ref_count, cmem_fd);

-

-    if (cmem_fd >= 0) {

-        ref_count++;

-        __D("init: /dev/cmem already opened, incremented ref_count %d\n",

-            ref_count);

-        return 0;

-    }

-

-    cmem_fd = open("/dev/cmem", O_RDWR);

-

-    if (cmem_fd == -1) {

-        __E("init: Failed to open /dev/cmem: '%s'\n", strerror(errno));

-        return -1;

-    }

-

-    ref_count++;

-

-    __D("init: successfully opened /dev/cmem, matching driver version...\n");

-

-    version = CMEM_getVersion();

-    if ((version & 0xffff0000) != (CMEM_VERSION & 0xffff0000)) {

-        __E("init: major version mismatch between interface and driver.\n");

-        __E("    needs driver version %#x, got %#x\n", CMEM_VERSION, version);

-        CMEM_exit();

-        return -1;

-    }

-    else if ((version & 0x0000ffff) < (CMEM_VERSION & 0x0000ffff)) {

-        __E("init: minor version mismatch between interface and driver.\n");

-        __E("    needs driver minor version %#x or greater.\n"

-            "    got minor version %#x (full version %#x)\n",

-            CMEM_VERSION & 0x0000ffff, version & 0x0000ffff, version);

-        CMEM_exit();

-        return -1;

-    }

-

-    __D("init: ... match good (%#x)\n", version);

-

-    flags = fcntl(cmem_fd, F_GETFD);

-    if (flags != -1) {

-        fcntl(cmem_fd, F_SETFD, flags | FD_CLOEXEC);

-    }

-    else {

-        __E("init: fcntl(F_GETFD) failed: '%s'\n", strerror(errno));

-    }

-

-    __D("init: exiting, returning success\n");

-

-    return 0;

-}

-

-static void *allocFromPool(int blockid, int poolid, CMEM_AllocParams *params)

-{

-    union CMEM_AllocUnion allocDesc;

-    unsigned long physp;

-    void *userp;

-    size_t size;

-    unsigned int cmd;

-    int rv;

-

-    allocDesc.alloc_pool_inparams.poolid = poolid;

-    allocDesc.alloc_pool_inparams.blockid = blockid;

-    cmd = CMEM_IOCALLOC | params->flags;

-    rv = ioctl(cmem_fd, cmd | CMEM_IOCMAGIC, &allocDesc);

-    if (rv != 0) {

-        __E("allocPool: ioctl %s failed from pool %d: %d\n",

-            cmd == CMEM_IOCALLOC ? "CMEM_IOCALLOC" : "CMEM_IOCALLOCCACHED",

-            poolid, rv);

-        return NULL;

-    }

-    physp = allocDesc.alloc_pool_outparams.physp;

-    size = allocDesc.alloc_pool_outparams.size;

-

-    __D("allocPool: allocated phys buffer %#lx, size %#x\n", physp, size);

-

-    /* Map the physical address to user space */

-    userp = mmap(0,                       // Preferred start address

-                 size,                    // Length to be mapped

-                 PROT_WRITE | PROT_READ,  // Read and write access

-                 MAP_SHARED,              // Shared memory

-                 cmem_fd,                 // File descriptor

-                 physp);                  // The byte offset from fd

-

-    if (userp == MAP_FAILED) {

-        __E("allocPool: Failed to mmap buffer at physical address %#lx\n",

-            physp);

-        __E("    Freeing phys buffer %#lx\n", physp);

-        ioctl(cmem_fd, CMEM_IOCFREEPHYS | CMEM_IOCMAGIC , &physp);

-        return NULL;

-    }

-

-    __D("allocPool: mmap succeeded, returning virt buffer %p\n", userp);

-

-    return userp;

-}

-

-static void *getAndAllocFromPool(int blockid, size_t size, CMEM_AllocParams *params)

-{

-    int poolid;

-

-    poolid = CMEM_getPool(blockid, size);

-

-    if (poolid == -1) return NULL;

-

-    return allocFromPool(blockid, poolid, params);

-}

-

-static void *allocFromHeap(int blockid, size_t size, CMEM_AllocParams *params)

-{

-    void *userp;

-    union CMEM_AllocUnion allocDesc;

-    unsigned long physp;

-    unsigned int cmd;

-    int rv;

-

-    cmd = CMEM_IOCALLOCHEAP | params->flags;

-    allocDesc.alloc_heap_inparams.size = size;

-    allocDesc.alloc_heap_inparams.align = params->alignment == 0 ?

-                                  1 : params->alignment;

-    allocDesc.alloc_heap_inparams.blockid = blockid;

-

-    rv = ioctl(cmem_fd, cmd | CMEM_IOCMAGIC, &allocDesc);

-    if (rv != 0) {

-        __E("allocHeap: ioctl %s failed: %d\n",

-            cmd == CMEM_IOCALLOCHEAP ?

-                   "CMEM_IOCALLOCHEAP" : "CMEM_IOCALLOCHEAPCACHED",

-            rv);

-        return NULL;

-    }

-    physp = allocDesc.physp;

-

-    __D("allocHeap: allocated phys buffer %#lx\n", physp);

-

-    /* Map the physical address to user space */

-    userp = mmap(0,                       // Preferred start address

-                 size,                    // Length to be mapped

-                 PROT_WRITE | PROT_READ,  // Read and write access

-                 MAP_SHARED,              // Shared memory

-                 cmem_fd,                 // File descriptor

-                 physp);                  // The byte offset from fd

-

-    if (userp == MAP_FAILED) {

-        __E("allocHeap: Failed to mmap buffer at physical address %#lx\n",

-            physp);

-        __E("    Freeing phys buffer %#lx\n", physp);

-        ioctl(cmem_fd, CMEM_IOCFREEHEAPPHYS | CMEM_IOCMAGIC, &physp);

-        return NULL;

-    }

-

-    __D("allocHeap: mmap succeeded, returning virt buffer %p\n", userp);

-

-    return userp;

-}

-

-/*

- *  Single interface into all flavors of alloc.

- *  Need to support:

- *    - cached vs. noncached

- *    - heap vs. pool

- *    - alignment w/ heap allocs

- */

-void *CMEM_alloc(int blockid, size_t size, CMEM_AllocParams *params)

-{

-    if (params == NULL) {

-        params = &CMEM_DEFAULTPARAMS;

-    }

-

-    __D("alloc: entered w/ size %#x, params - type %s, flags %s, align %#x%s\n",

-        size,

-        params->type == CMEM_POOL ? "POOL" : "HEAP",

-        params->flags & CMEM_CACHED ? "CACHED" : "NONCACHED",

-        params->alignment,

-        params == &CMEM_DEFAULTPARAMS ? " (default)" : "");

-

-    if (!validate_init()) {

-        return NULL;

-    }

-

-    if (params->type == CMEM_POOL) {

-        return getAndAllocFromPool(blockid, size, params);

-    }

-    else {

-        return allocFromHeap(blockid, size, params);

-    }

-}

-

-void *CMEM_registerAlloc(unsigned long physp)

-{

-    union CMEM_AllocUnion allocDesc;

-    void *userp;

-    size_t size;

-    int rv;

-

-    allocDesc.physp = physp;

-    rv = ioctl(cmem_fd, CMEM_IOCREGUSER | CMEM_IOCMAGIC, &allocDesc);

-    if (rv != 0) {

-        __E("registerAlloc: ioctl CMEM_IOCREGUSER failed for phys addr %#lx: %d\n",

-            physp, rv);

-

-        return NULL;

-    }

-    size = allocDesc.size;

-

-    __D("registerAlloc: registered use of phys buffer %#lx, size %#x\n",

-        physp, size);

-

-    /* Map the physical address to user space */

-    userp = mmap(0,                       // Preferred start address

-                 size,                    // Length to be mapped

-                 PROT_WRITE | PROT_READ,  // Read and write access

-                 MAP_SHARED,              // Shared memory

-                 cmem_fd,                 // File descriptor

-                 physp);               // The byte offset from fd

-

-    if (userp == MAP_FAILED) {

-        __E("registerAlloc: Failed to mmap buffer at physical address %#lx\n",

-            physp);

-        __E("    Unregistering use of phys buffer %#lx\n", physp);

-        ioctl(cmem_fd, CMEM_IOCFREEPHYS | CMEM_IOCMAGIC, &physp);

-

-        return NULL;

-    }

-

-    __D("registerAlloc: mmap succeeded, returning virt buffer %p\n", userp);

-

-    return userp;

-}

-

-void *CMEM_allocPool(int blockid, int poolid, CMEM_AllocParams *params)

-{

-    if (params == NULL) {

-        params = &CMEM_DEFAULTPARAMS;

-    }

-

-    __D("allocPool: entered w/ poolid %d, params - flags %s%s\n", poolid,

-        params->flags & CMEM_CACHED ? "CACHED" : "NONCACHED",

-        params == &CMEM_DEFAULTPARAMS ? " (default)" : "");

-

-    if (!validate_init()) {

-        return NULL;

-    }

-

-    return allocFromPool(blockid, poolid, params);

-}

-

-int CMEM_free(void *ptr, CMEM_AllocParams *params)

-{

-    union CMEM_AllocUnion freeDesc;

-    unsigned int cmd;

-    size_t size;

-

-    if (params == NULL) {

-        params = &CMEM_DEFAULTPARAMS;

-    }

-

-    __D("free: entered w/ ptr %p, params - type %s%s\n",

-        ptr,

-        params->type == CMEM_POOL ? "POOL" : "HEAP",

-        params == &CMEM_DEFAULTPARAMS ? " (default)" : "");

-

-    if (!validate_init()) {

-        return -1;

-    }

-

-    freeDesc.virtp = (int)ptr;

-    cmd = CMEM_IOCFREE | params->type;

-    if (ioctl(cmem_fd, cmd | CMEM_IOCMAGIC, &freeDesc) == -1) {

-        __E("free: failed to free %#x\n", (unsigned int) ptr);

-        return -1;

-    }

-    size = freeDesc.free_outparams.size;

-

-    __D("free: ioctl CMEM_IOCFREE%s succeeded, size %#x\n",

-        params->type == CMEM_POOL ? "POOL" : "HEAP", size);

-

-    if (munmap(ptr, size) == -1) {

-        __E("free: failed to munmap %#x\n", (unsigned int) ptr);

-        return -1;

-    }

-

-    __D("free: munmap succeeded, returning 0\n");

-

-    return 0;

-}

-

-int CMEM_unregister(void *ptr, CMEM_AllocParams *params)

-{

-    __D("unregister: delegating to CMEM_free()...\n");

-

-    return CMEM_free(ptr, params);

-}

-

-static int getPoolFromBlock(int blockid, size_t size)

-{

-    union CMEM_AllocUnion poolDesc;

-

-    if (!validate_init()) {

-        return -1;

-    }

-

-    poolDesc.get_pool_inparams.size = size;

-    poolDesc.get_pool_inparams.blockid = blockid;

-    if (ioctl(cmem_fd, CMEM_IOCGETPOOL | CMEM_IOCMAGIC, &poolDesc) == -1) {

-        __E("getPool: Failed to get a pool fitting a size %d\n", size);

-        return -1;

-    }

-

-    __D("getPool: exiting, ioctl CMEM_IOCGETPOOL succeeded, returning %d\n",

-        poolDesc.poolid);

-

-    return poolDesc.poolid;

-}

-

-int CMEM_getPool(int blockid, size_t size)

-{

-    __D("getPool: entered w/ size %#x\n", size);

-

-    return getPoolFromBlock(blockid, size);

-}

-

-unsigned long CMEM_getPhys(void *ptr)

-{

-    union CMEM_AllocUnion getDesc;

-

-    __D("getPhys: entered w/ addr %p\n", ptr);

-

-    if (!validate_init()) {

-        return 0;

-    }

-

-    getDesc.virtp = (unsigned long)ptr;

-    if (ioctl(cmem_fd, CMEM_IOCGETPHYS | CMEM_IOCMAGIC, &getDesc) == -1) {

-        __E("getPhys: Failed to get physical address of %#x\n",

-            (unsigned int) ptr);

-        return 0;

-    }

-

-    __D("getPhys: exiting, ioctl CMEM_IOCGETPHYS succeeded, returning %#lx\n",

-        getDesc.physp);

-

-    return getDesc.physp;

-}

-

-int CMEM_cacheWb(void *ptr, size_t size)

-{

-    struct block_struct block;

-

-    __D("cacheWb: entered w/ addr %p, size %#x\n", ptr, size);

-

-    if (!validate_init()) {

-        return -1;

-    }

-

-    block.addr = (unsigned long)ptr;

-    block.size = size;

-    if (ioctl(cmem_fd, CMEM_IOCCACHEWB | CMEM_IOCMAGIC, &block) == -1) {

-        __E("cacheWb: Failed to writeback %#x\n", (unsigned int) ptr);

-

-        return -1;

-    }

-

-    __D("cacheWb: exiting, ioctl CMEM_IOCCACHEWB succeeded, returning 0\n");

-

-    return 0;

-}

-

-int CMEM_cacheWbInv(void *ptr, size_t size)

-{

-    struct block_struct block;

-

-    __D("cacheWbInv: entered w/ addr %p, size %#x\n", ptr, size);

-

-    if (!validate_init()) {

-        return -1;

-    }

-

-    block.addr = (unsigned long)ptr;

-    block.size = size;

-    if (ioctl(cmem_fd, CMEM_IOCCACHEWBINV | CMEM_IOCMAGIC, &block) == -1) {

-        __E("cacheWbInv: Failed to writeback & invalidate %#x\n",

-            (unsigned int) ptr);

-

-        return -1;

-    }

-

-    __D("cacheWbInv: exiting, ioctl CMEM_IOCCACHEWBINV succeeded, returning 0\n");

-

-    return 0;

-}

-

-int CMEM_cacheInv(void *ptr, size_t size)

-{

-    struct block_struct block;

-

-    __D("cacheInv: entered w/ addr %p, size %#x\n", ptr, size);

-

-    if (!validate_init()) {

-        return -1;

-    }

-

-    block.addr = (unsigned long)ptr;

-    block.size = size;

-    if (ioctl(cmem_fd, CMEM_IOCCACHEINV | CMEM_IOCMAGIC, &block) == -1) {

-        __E("cacheInv: Failed to invalidate %#x\n", (unsigned int) ptr);

-

-        return -1;

-    }

-

-    __D("cacheInv: exiting, ioctl CMEM_IOCCACHEINV succeeded, returning 0\n");

-

-    return 0;

-}

-

-int CMEM_getVersion(void)

-{

-    unsigned int version;

-    int rv;

-

-    __D("getVersion: entered\n");

-

-    if (!validate_init()) {

-        return -1;

-    }

-

-    rv = ioctl(cmem_fd, CMEM_IOCGETVERSION | CMEM_IOCMAGIC, &version);

-    if (rv != 0) {

-        __E("getVersion: Failed to retrieve version from driver: %d.\n", rv);

-

-        return -1;

-    }

-

-    __D("getVersion: exiting, ioctl CMEM_IOCGETVERSION returned %#x\n",

-        version);

-

-    return version;

-}

-

-static int getBlock(int blockid, unsigned long *pphys_base, size_t *psize)

-{

-    union CMEM_AllocUnion block;

-    int rv;

-

-    __D("getBlock: entered\n");

-

-    if (!validate_init()) {

-        return -1;

-    }

-

-    block.blockid = blockid;

-    rv = ioctl(cmem_fd, CMEM_IOCGETBLOCK | CMEM_IOCMAGIC, &block);

-    if (rv != 0) {

-        __E("getBlock: Failed to retrieve memory block bounds for block %d "

-            "from driver: %d.\n", blockid, rv);

-

-        return -1;

-    }

-

-    *pphys_base = block.get_block_outparams.physp;

-    *psize = block.get_block_outparams.size;

-

-    __D("getBlock: exiting, ioctl CMEM_IOCGETBLOCK succeeded, "

-        "returning *pphys_base=0x%lx, *psize=0x%x\n", *pphys_base, *psize);

-

-    return 0;

-}

-

-int CMEM_getBlockAttrs(int blockid, CMEM_BlockAttrs *pattrs)

-{

-    return getBlock(blockid, &pattrs->phys_base, &pattrs->size);

-}

-

-int CMEM_exit(void)

-{

-    int result = 0;

-

-    __D("exit: entered - ref_count %d, cmem_fd %d\n", ref_count, cmem_fd);

-

-    if (!validate_init()) {

-        return -1;

-    }

-

-    __D("exit: decrementing ref_count\n");

-

-    ref_count--;

-    if (ref_count == 0) {

-        result = close(cmem_fd);

-

-        __D("exit: ref_count == 0, closed /dev/cmem (%s)\n",

-            result == -1 ? strerror(errno) : "succeeded");

-

-        /* setting -3 allows to distinguish CMEM exit from CMEM failed */

-        cmem_fd = -3;

-    }

-

-    __D("exit: exiting, returning %d\n", result);

-

-    return result;

-}

diff --git a/cmem.h b/cmem.h
deleted file mode 100644
index 51a233c..0000000
--- a/cmem.h
+++ b/dev/null
@@ -1,496 +0,0 @@
-/*

- *  Copyright 2010 by AMLOGIC INC.

- *  Common physical memory allocator driver.

- */

-

-/*

- * Copyright (c) 2009, Texas Instruments Incorporated

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- *

- * *  Redistributions of source code must retain the above copyright

- *    notice, this list of conditions and the following disclaimer.

- *

- * *  Redistributions in binary form must reproduce the above copyright

- *    notice, this list of conditions and the following disclaimer in the

- *    documentation and/or other materials provided with the distribution.

- *

- * *  Neither the name of Texas Instruments Incorporated nor the names of

- *    its contributors may be used to endorse or promote products derived

- *    from this software without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

- * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- *

- */

-

-/**

- * @file    cmem.h

- * @brief   Describes the interface to the contiguous memory allocator.

- *

- * The cmem user interface library wraps file system calls to an associated

- * kernel module (cmemk.ko), which needs to be loaded in order for calls to

- * this library to succeed.

- *

- * The following is an example of installing the cmem kernel module:

- * 

- * @verbatim /sbin/insmod cmemk.ko pools=4x30000,2x500000 phys_start=0x0 phys_end=0x3000000 @endverbatim

- *     - phys_start and phys_end must be specified in hexadecimal format

- *     - phys_start is "inclusive" and phys_end is "exclusive", i.e.,

- *       phys_end should be "end address + 1".

- *     - pools must be specified using decimal format (for both number and

- *       size), since using hexadecimal format would visually clutter the

- *       specification due to the use of "x" as a token separator

- *     - it's possible to insmod cmemk.ko without specifying any memory blocks,

- *       in which case CMEM_getPhys() and CMEM_cache*() APIs can still be

- *       utilized by an application.

- *

- * This particular command creates 2 pools. The first pool is created with 4

- * buffers of size 30000 bytes and the second pool is created with 2 buffers

- * of size 500000 bytes. The CMEM pool buffers start at 0x0 and end at

- * 0x2FFFFFF (max). 

- *

- * There is also support for a 2nd contiguous memory block to be specified,

- * with all the same features supported for the 2nd block as with the 1st.

- * This 2nd block is specified with *_1 parameters.  The following example

- * expands upon the first example above:

- * 

- * @verbatim /sbin/insmod cmemk.ko pools=4x30000,2x500000 phys_start=0x0 phys_end=0x3000000

-    pools_1=4x65536 phys_start_1=0x80000000 phys_end_1=0x80010000 @endverbatim

- *

- * This particular command, in addition to the pools explained above,

- * creates 1 pool (with 4 buffers of size 64KB) in a 2nd memory block which

- * starts at 0x80000000 and ends at 0x8000FFFF (specified as "end + 1" on the

- * insmod command).

- *

- * In order to access this 2nd memory block, new APIs have been added to

- * CMEM which allow specification of the block ID.

- *

- * Pool buffers are aligned on a module-dependent boundary, and their sizes are

- * rounded up to this same boundary.  This applies to each buffer within a

- * pool.  The total space used by an individual pool will therefore be greater

- * than (or equal to) the exact amount requested in the installation of the

- * module.

- *

- * The poolid used in the driver calls would be 0 for the first pool and 1 for

- * the second pool.

- *

- * Pool allocations can be requested explicitly by pool number, or more

- * generally by just a size.  For size-based allocations, the pool which best

- * fits the requested size is automatically chosen.  Some CMEM APIs (newer

- * ones) accept a blockid as a parameter, in order to specify which of the

- * multiple blocks to operate on.  For 'legacy' APIs (ones that existed before

- * the support for multiple blocks) where a blockid is still needed, block 0

- * is assumed.

- *

- * There is also support for a general purpose heap.  In addition to the 2

- * pools described above, a general purpose heap block is created from which

- * allocations of any size can be requested.  Internally, allocation sizes are

- * rounded up to a module-dependent boundary and allocation addresses are

- * aligned either to this same boundary or to the requested alignment

- * (whichever is greater).

- *

- * The size of the heap block is the amount of CMEM memory remaining after all

- * pool allocations.  If more heap space is needed than is available after pool

- * allocations, you must reduce the amount of CMEM memory granted to the pools.

- *

- * Buffer allocation is tracked at the file descriptor level by way of a

- * 'registration' list.  The initial allocator of a buffer (the process that

- * calls CMEM_alloc()) is automatically added to the registration list,

- * and further processes can become registered for the same buffer by way

- * of the CMEM_registerAlloc() API (and unregister with the

- * CMEM_unregister() API).  This registration list for each buffer

- * allows for buffer ownership tracking and cleanup on a

- * per-file-descriptor basis, so that when a process exits or dies without

- * having explicitly freed/unregistered its buffers, they get automatically

- * unregistered (and freed when no more registered file descriptors exist).

- * Only when the last registered file descriptor frees a buffer (either

- * explictily, or by auto-cleanup) does a buffer actually get freed back to

- * the kernel module.

- *

- * Since the CMEM interface library doesn't use the GT tracing facility, there

- * is one configuration option available for the CMEM module to control

- * whether the debug or release interface library is used for building the

- * application.  This config parameter is named 'debug' and is of type bool,

- * and the default value is 'false'.

- *

- * The following line is an example of enabling usage of the debug interface

- * library:

- *     var cmem = xdc.useModule('ti.sdo.linuxutils.cmem.CMEM');

- *     cmem.debug = true;

- * This will enable "CMEM Debug" statements to be printed to stdout.

- */

-/**

- *  @defgroup   ti_sdo_linuxutils_cmem_CMEM  Contiguous Memory Manager

- *

- *  This is the API for the Contiguous Memory Manager.

- */

-

-#ifndef CMEM_H

-#define CMEM_H

-

-#if defined (__cplusplus)

-extern "C" {

-#endif

-

-/** @ingroup    CMEM */

-/*@{*/

-

-#define CMEM_VERSION    0x03000000U

-

-/* ioctl cmd "flavors" */

-#define CMEM_WB                         0x00010000

-#define CMEM_INV                        0x00020000

-#define CMEM_HEAP                       0x00040000  /**< operation applies to heap */

-#define CMEM_POOL                       0x00000000  /**< operation applies to a pool */

-#define CMEM_CACHED                     0x00080000  /**< allocated buffer is cached */

-#define CMEM_NONCACHED                  0x00000000  /**< allocated buffer is not cached */

-#define CMEM_PHYS                       0x00100000

-

-#define CMEM_IOCMAGIC                   0x0000fe00

-

-/* supported "base" ioctl cmds for the driver. */

-#define CMEM_IOCALLOC                   1

-#define CMEM_IOCALLOCHEAP               2

-#define CMEM_IOCFREE                    3

-#define CMEM_IOCGETPHYS                 4

-#define CMEM_IOCGETSIZE                 5

-#define CMEM_IOCGETPOOL                 6

-#define CMEM_IOCCACHE                   7

-#define CMEM_IOCGETVERSION              8

-#define CMEM_IOCGETBLOCK                9

-#define CMEM_IOCREGUSER                 10

-/*

- * New ioctl cmds should use integers greater than the largest current cmd

- * in order to not break backward compatibility.

- */

-

-/* supported "flavors" to "base" ioctl cmds for the driver. */

-#define CMEM_IOCCACHEWBINV              CMEM_IOCCACHE | CMEM_WB | CMEM_INV

-#define CMEM_IOCCACHEWB                 CMEM_IOCCACHE | CMEM_WB

-#define CMEM_IOCCACHEINV                CMEM_IOCCACHE | CMEM_INV

-#define CMEM_IOCALLOCCACHED             CMEM_IOCALLOC | CMEM_CACHED

-#define CMEM_IOCALLOCHEAPCACHED         CMEM_IOCALLOCHEAP | CMEM_CACHED

-#define CMEM_IOCFREEHEAP                CMEM_IOCFREE | CMEM_HEAP

-#define CMEM_IOCFREEPHYS                CMEM_IOCFREE | CMEM_PHYS

-#define CMEM_IOCFREEHEAPPHYS            CMEM_IOCFREE | CMEM_HEAP | CMEM_PHYS

-

-#define CMEM_IOCCMDMASK                 0x000000ff

-

-/**

- * @brief Parameters for CMEM_alloc(), CMEM_allocPool(), CMEM_free().

- */

-typedef struct CMEM_AllocParams {

-    int type;           /**< either CMEM_HEAP or CMEM_POOL */

-    int flags;          /**< either CMEM_CACHED or CMEM_NONCACHED */

-    size_t alignment;   /**<

-                         * only used for heap allocations, must be power of 2

-                         */

-} CMEM_AllocParams;

-

-extern CMEM_AllocParams CMEM_DEFAULTPARAMS;

-

-typedef struct CMEM_BlockAttrs {

-    unsigned long phys_base;

-    size_t size;

-} CMEM_BlockAttrs;

-

-/** @cond INTERNAL */

-

-/**

- */

-union CMEM_AllocUnion {

-    struct {                    /**< */

-        size_t size;

-        size_t align;

-        int blockid;

-    } alloc_heap_inparams;      /**< */

-    struct {                    /**< */

-        int poolid;

-        int blockid;

-    } alloc_pool_inparams;      /**< */

-    struct {                    /**< */

-        int poolid;

-        int blockid;

-    } get_size_inparams;        /**< */

-    struct {                    /**< */

-        size_t size;

-        int blockid;

-    } get_pool_inparams;        /**< */

-    struct {                    /**< */

-        unsigned long physp;

-        size_t size;

-    } alloc_pool_outparams;     /**< */

-    struct {                    /**< */

-        unsigned long physp;

-        size_t size;

-    } get_block_outparams;      /**< */

-    struct {                    /**< */

-        int poolid;

-        size_t size;

-    } free_outparams;           /**< */

-    unsigned long physp;

-    unsigned long virtp;

-    size_t size;

-    int poolid;

-    int blockid;

-};

-

-/** @endcond */

-

-/**

- * @brief Initialize the CMEM module. Must be called before other API calls.

- *

- * @return 0 for success or -1 for failure.

- *

- * @sa CMEM_exit

- */

-int CMEM_init(void);

-

-/**

- * @brief Find the pool in memory block blockid that best fits a given

- * buffer size and has a buffer available.

- *

- * @param   blockid  Block number

- * @param   size     The buffer size for which a pool is needed.

- *

- * @return A poolid that can be passed to CMEM_allocPool(), or -1 for error.

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_allocPool()

- * @sa CMEM_free()

- */

-int CMEM_getPool(int blockid, size_t size);

-

-/**

- * @brief Allocate memory from a specified pool in a specified memory block.

- *

- * @param   blockid The memory block from which to allocate.

- * @param   poolid  The pool from which to allocate memory.

- * @param   params  Allocation parameters.

- *

- * @remarks @c params->type is ignored - a pool will always be used.

- * @remarks @c params->alignment is unused, since pool buffers are already

- *          aligned to specific boundaries.

- *

- * @return A pointer to the allocated buffer, or NULL for failure.

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_alloc()

- * @sa CMEM_registerAlloc()

- * @sa CMEM_unregister()

- * @sa CMEM_free()

- */

-void *CMEM_allocPool(int blockid, int poolid, CMEM_AllocParams *params);

-

-/**

- * @brief Allocate memory of a specified size from a specified memory block

- *

- * @param   blockid The memory block from which to allocate.

- * @param   size    The size of the buffer to allocate.

- * @param   params  Allocation parameters.

- *

- * @remarks Used to allocate memory from either a pool or the heap.

- *          If doing a pool allocation, the pool that best fits the requested

- *          size will be selected.  Use CMEM_allocPool() to allocate from a

- *          specific pool.

- *

- * @remarks Allocation will be cached or noncached, as specified by params.

- *          params->alignment valid only for heap allocation.

- *

- * @return A pointer to the allocated buffer, or NULL for failure.

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_allocPool()

- * @sa CMEM_registerAlloc()

- * @sa CMEM_unregister()

- * @sa CMEM_free()

- */

-void *CMEM_alloc(int blockid, size_t size, CMEM_AllocParams *params);

-

-/**

- * @brief Register shared usage of an already-allocated buffer

- *

- * @param   physp  Physical address of the already-allocated buffer.

- *

- * @remarks Used to register the calling process for usage of an

- *          already-allocated buffer, for the purpose of shared usage of

- *          the buffer.

- *

- * @remarks Allocation properties (such as cached/noncached or heap/pool)

- *          are inherited from original allocation call.

- *

- * @return  A process-specific pointer to the allocated buffer, or NULL

- *          for failure.

- *

- * @pre Must have called some form of CMEM_alloc*()

- *

- * @sa CMEM_allocPool()

- * @sa CMEM_alloc()

- * @sa CMEM_free()

- * @sa CMEM_unregister()

- */

-void *CMEM_registerAlloc(unsigned long physp);

-

-/**

- * @brief Free a buffer previously allocated with

- *        CMEM_alloc()/CMEM_allocPool().

- *

- * @param   ptr     The pointer to the buffer.

- * @param   params  Allocation parameters.

- *

- * @remarks Use the same CMEM_AllocParams as was used for the allocation.

- *          params->flags is "don't care".  params->alignment is "don't

- *          care".

- *

- * @return 0 for success or -1 for failure.

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_alloc()

- * @sa CMEM_allocPool()

- * @sa CMEM_registerAlloc()

- * @sa CMEM_unregister()

- */

-int CMEM_free(void *ptr, CMEM_AllocParams *params);

-

-/**

- * @brief Unregister use of a buffer previously registered with

- *        CMEM_registerAlloc().

- *

- * @param   ptr     The pointer to the buffer.

- * @param   params  Allocation parameters.

- *

- * @remarks Use the same CMEM_AllocParams as was used for the allocation.

- *          params->flags is "don't care".  params->alignment is "don't

- *          care".

- *

- * @return 0 for success or -1 for failure.

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_alloc()

- * @sa CMEM_allocPool()

- * @sa CMEM_registerAlloc()

- * @sa CMEM_free()

- */

-int CMEM_unregister(void *ptr, CMEM_AllocParams *params);

-

-/**

- * @brief Get the physical address of a contiguous buffer.

- *

- * @param   ptr     The pointer to the buffer.

- *

- * @return The physical address of the buffer or 0 for failure.

- *

- * @pre Must have called CMEM_init()

- */

-unsigned long CMEM_getPhys(void *ptr);

-

-/**

- * @brief Do a cache writeback of the block pointed to by @c ptr/@c size

- *

- * @param   ptr     Pointer to block to writeback

- * @param   size    Size in bytes of block to writeback.

- *

- * @return Success/failure boolean value

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_cacheInv()

- * @sa CMEM_cacheWbInv()

- */

-int CMEM_cacheWb(void *ptr, size_t size);

-

-/**

- * @brief Do a cache invalidate of the block pointed to by @c ptr/@c size

- *

- * @param   ptr     Pointer to block to invalidate

- * @param   size    Size in bytes of block to invalidate

- *

- * @return Success/failure boolean value

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_cacheWb()

- * @sa CMEM_cacheWbInv()

- */

-int CMEM_cacheInv(void *ptr, size_t size);

-

-/**

- * @brief Do a cache writeback/invalidate of the block pointed to by

- *        @c ptr/@c size

- *

- * @param   ptr     Pointer to block to writeback/invalidate

- * @param   size    Size in bytes of block to writeback/invalidate

- *

- * @return Success/failure boolean value

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_cacheInv()

- * @sa CMEM_cacheWb()

- */

-int CMEM_cacheWbInv(void *ptr, size_t size);

-

-/**

- * @brief Retrieve version from CMEM driver.

- *

- * @return Installed CMEM driver's version number.

- *

- * @pre Must have called CMEM_init()

- */

-int CMEM_getVersion(void);

-

-/**

- * @brief Retrieve extended memory block attributes from CMEM driver

- *

- * @param   blockid      Block number

- * @param   pattrs       Pointer to CMEM_BlockAttrs struct

- *

- * @return Success (0) or failure (-1).

- *

- * @remarks Currently this API returns the same values as CMEM_getBlock().

- *

- * @pre Must have called CMEM_init()

- *

- * @sa  CMEM_getBlock()

- */

-int CMEM_getBlockAttrs(int blockid, CMEM_BlockAttrs *pattrs);

-

-/**

- * @brief Finalize the CMEM module.

- *

- * @return 0 for success or -1 for failure.

- *

- * @remarks After this function has been called, no other CMEM function may be

- *          called (unless CMEM is reinitialized).

- *

- * @pre Must have called CMEM_init()

- *

- * @sa CMEM_init()

- */

-int CMEM_exit(void);

-

-/*@}*/

-

-#if defined (__cplusplus)

-}

-#endif

-

-#endif

diff --git a/cmemk.ko b/cmemk.ko
deleted file mode 100755
index d726c3d..0000000
--- a/cmemk.ko
+++ b/dev/null
@@ -1,552 +0,0 @@
-ELF



-
 Fâ
-
-
-
0‚à
-

-
- àá
 
-â
-
-
-
-
-
-
@cà`Fâ

-
-$ å
-
-
-$ å
-
-
-
-$0å
-
-� áˆŸå
‘ç
-
-†¡ áL2Ÿå
- fà

-²å
-à³å
-$À“å
@„â
-0“å
-
@„â0 á
-•å
-80˜å â
-
-fà„!dà@�å0 á�Á á
-†
fà„!dà@�å
-@
-
-� á0`å  á` áp áP á
-
-
-p á	  á –å
-4å
-` á
-
-Pàå8Àå
-–è
-0•å
-
-ÀŒã!éŽãÀ„å0aàà„å
-
-
-
-à�å
	ã
-D0�å
-
-

- ‰à	
-
-(Ÿåþÿÿë½ÿÿê
à áÍÎã? Ìã’å –â
 Ò0
-
-
-
-
- ƒà
-
-¡„à
- ƒà
-¡„à
- ƒà
-  á
-À
-
-
-þÿÿë
-nà
-—å

-À—å0‡â —å
-àœå
-

-À�å
-@Ÿå\ åþÿÿë
ã\ åû
-L å< å
 áÍÁã? Ìã@ å0’å –â Ò0
- Œà
-
- áþÿÿë
-´ŸåРãþÿÿë
-H
-РãÀ
ŸåþÿÿëÀ áP€å
-  áþÿÿë
- á
-0 å4àå0ŽàÌ “å
-P„å
-
-
- †â0†â
-à†â
-pã´
-ØP’å
-
-èœå
-8àKâ
-  ã

-þÿÿ묟å
-  ã

-þÿÿë á  á
- á
|†âP
-¬
-°
-˜ç
-		 Set to 1 if cmem range is allowed to overlap memory range
-		 allocated to kernel physical mem (via mem=xxx)
-		 List of Pool Sizes and Number of Entries, comma separated,
-		 decimal sizes, for Extended CMEM Pool
-		 End Address for Extended CMEM Pool Memory
-		 Start Address for Extended CMEM Pool Memory
-		 List of Pool Sizes and Number of Entries, comma separated,
-		 decimal sizes
-		 End Address for CMEM Pool Memory
-		 Start Address for CMEM Pool Memory
-
-Pool %d free bufs:
-
-Block %d: Pool %d: %d bufs size %d (%d requested)
-
-Pool %d busy bufs:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-okmalloc_caches
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-g
-y
-‹
-�
-¯
-U
-Ì
-Þ
-u16
-.�
-s32
-0¯
-u32
-1U
-s64
-3Ì
-u64
-4Þ
-
-
-
ˆ%
-
-
-
-
-
-
-
-
-
-ìl
-
-*
-
-
-
-
-
-
-
-3
-)
-
-
-
-
-
-
-
-	
-
-4
-
-
-TU
-J
-
-
-
-
-
-7
-
Rk
-pl
-n
-7
-R

-
-
-
-´
-
-
-
-
-„
-ˆ
-ˆ
-
-
-
-
-
-ˆ
-
-
-
-
-
-
-
-
-
-
-
-4
-�
-�
-�
-�
-�
-�
-Ö¥
-)
-¯
-ˆ
-ˆ
-ˆ
-ˆ
-ˆ
-¥
-ˆ
-ˆ
-
-0
-
-¯
-u16
-Š…

-N
-
-
-
-
-
‡
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-..gJ
-.v..g.	J.q.JÜ
-.y.60+3--0EJç
-J¯J+tMJÐÑ
-Ö/-//
çº-/-/-//Nnx.Šx.6xJj†1+i+/-/-2)JZ‚2*3%a
-.v.3*2ør.
�
.çr.-.
Œ
.v.
-.v.ÔzfÌr.
´
.tJË
-<‡}.
ù.'.OJ
-fw.j.ƒg,1c.h,Æ{‚
¼.\„K\¼òò‚.kJJ3úÈÚ}‚Ó.Eƒ”v.!
–‚O-4/-4	 ¾yJ5yf5y.J/Ëy.
´ž/Ëy.
”.ãxf!
Ê‚P,5z.5-3¤‹‚”vf!
�‚O-1P‡É2MzfRvž»2Mzfnvfƒ2MzfŠwf-OMzfH0RvJ
-.v.JLO³
ž”vJ!
‚,JWf).Ët 
éžÉ
-fgÊxJ
»fÅx.»
»‚§J—vJ
ឆL,0/Z–y.
Ä	žÍx</,//,0j-Kh,jdcÍfƒ	ãxf
¦fQ5y.LÂw.
À./¿w.
¾.	Ñx.
±.Àw.
¼J4+1�w.	À
.À~.-
÷.»w.^f"J].1-	°
.
»f	Åx.ã~.
Û.‘w.-1-
îJ0ãžÎsJ
-ž
î
-žMŸÔw.
¶ž¸wf
Í.³w.¡.
¬	.Ôv.	°
.þ~JA.$..R.-1-	°
.ã~.
 	.	ýw.ã~.
£	.Év.-1-
¶	.RÁ{.z‚¢ºMŸl.ˆvJÌ
-.øu..R.o.$..R.-1-
›
-.fcX®v‚
Ô	J v.-.
Ó	.
.‘~f‡º	ýtJã~f
®.	ït.ã~.
².ºs.-1-
Å.4¦Ê|J"g·.gƒgt.„g>.>è{.Ì‚€~‚ ü}.Ÿ½
.ü
-.v..-/i.^J=<Ÿ2b2g…¡g®‚ß
-
-.ù
-		
-D
-		
-D
-		
-D
-		
-D
-		
-D
-		
-D
-		
-D
-		
-D
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-A
	



,

-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-,
-O
-P
-i
-j
-‹
-—
-¿
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/ge2d.h b/ge2d.h
deleted file mode 100644
index 3f94bd5..0000000
--- a/ge2d.h
+++ b/dev/null
@@ -1,311 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2010 AMLOGIC, INC.
-** All rights reserved.
-****************************************************************************/
-
-#ifndef GE2D_H
-#define GE2D_H
-
-#define  FBIOPUT_GE2D_STRETCHBLIT_NOALPHA   0x4702
-#define  FBIOPUT_GE2D_BLIT_NOALPHA			0x4701
-#define  FBIOPUT_GE2D_BLEND					0x4700
-#define  FBIOPUT_GE2D_BLIT					0x46ff
-#define  FBIOPUT_GE2D_STRETCHBLIT   		0x46fe
-#define  FBIOPUT_GE2D_FILLRECTANGLE 		0x46fd
-#define  FBIOPUT_GE2D_SRCCOLORKEY   		0x46fc
-#define  FBIOPUT_GE2D_SET_COEF			0x46fb
-#define  FBIOPUT_GE2D_CONFIG_EX			0x46fa
-#define  FBIOPUT_GE2D_CONFIG				0x46f9
-#define  FBIOPUT_GE2D_ANTIFLICKER_ENABLE    0x46f8 
-typedef enum  	
-{
-	OSD0_OSD0 = 0,
-	OSD0_OSD1,	 
-	OSD1_OSD1,
-	OSD1_OSD0,
-	ALLOC_OSD0,
-	ALLOC_OSD1,
-	ALLOC_ALLOC,
-	TYPE_INVALID,
-} ge2d_src_dst_t;
-
-
-typedef enum  	
-{
-    CANVAS_OSD0 =0,
-    CANVAS_OSD1,	 
-    CANVAS_ALLOC,
-    CANVAS_TYPE_INVALID,
-}ge2d_src_canvas_type;
-
-typedef struct {
-	unsigned long  addr;
-	unsigned int	w;
-	unsigned int	h;
-}config_planes_t;
-
-typedef    struct {
-	int  src_dst_type;
-	int  alu_const_color;
-	unsigned int src_format;
-	unsigned int dst_format ; //add for src&dst all in user space.
-
-	config_planes_t src_planes[4];
-	config_planes_t dst_planes[4];
-}config_para_t;
-
-typedef struct {
-	int	x;   /* X coordinate of its top-left point */
-	int	y;   /* Y coordinate of its top-left point */
-	int	w;   /* width of it */
-	int	h;   /* height of it */
-} rectangle_t;
-
-typedef  struct {
-	unsigned int color ;
-	rectangle_t src1_rect;
-	rectangle_t src2_rect;
-	rectangle_t	dst_rect;
-	int op;
-} ge2d_op_para_t ;
-
-typedef    struct {
-    int key_enable;
-    int key_mode;
-    int key_mask;
-    int key;      
-}key_ctrl_ex_t;
-
-typedef  struct  {
-    int  canvas_index;
-    int  top;
-    int  left;
-    int  width;
-    int  height;
-    int  format;
-    int  mem_type;
-    int  color;
-    unsigned char x_rev;
-    unsigned char y_rev;
-    unsigned char fill_color_en;
-    unsigned char fill_mode;    
-}src_dst_para_ex_t ;
-
-typedef    struct {
-    src_dst_para_ex_t src_para;
-    src_dst_para_ex_t src2_para;
-    src_dst_para_ex_t dst_para;
-
-//key mask
-    key_ctrl_ex_t  src_key;
-    key_ctrl_ex_t  src2_key;
-
-    int alu_const_color;
-    unsigned src1_gb_alpha;
-    unsigned op_mode;
-    unsigned char bitmask_en;
-    unsigned char bytemask_only;
-    unsigned int  bitmask;
-    unsigned char dst_xy_swap;
-
-// scaler and phase releated
-    unsigned hf_init_phase;
-    int hf_rpt_num;
-    unsigned hsc_start_phase_step;
-    int hsc_phase_slope;
-    unsigned vf_init_phase;
-    int vf_rpt_num;
-    unsigned vsc_start_phase_step;
-    int vsc_phase_slope;
-    unsigned char src1_vsc_phase0_always_en;
-    unsigned char src1_hsc_phase0_always_en;
-    unsigned char src1_hsc_rpt_ctrl;  //1bit, 0: using minus, 1: using repeat data
-    unsigned char src1_vsc_rpt_ctrl;  //1bit, 0: using minus  1: using repeat data
-
-//canvas info
-    config_planes_t src_planes[4];
-    config_planes_t src2_planes[4];
-    config_planes_t dst_planes[4];
-}config_para_ex_t;
-
-#define GE2D_ENDIAN_SHIFT		24
-#define GE2D_ENDIAN_MASK		(0x1 << GE2D_ENDIAN_SHIFT)
-#define GE2D_BIG_ENDIAN			(0 << GE2D_ENDIAN_SHIFT)
-#define GE2D_LITTLE_ENDIAN		(1 << GE2D_ENDIAN_SHIFT)
-
-#define GE2D_COLOR_MAP_SHIFT	20
-#define GE2D_COLOR_MAP_MASK		(0xf << GE2D_COLOR_MAP_SHIFT)
-/* 16 bit */
-#define GE2D_COLOR_MAP_YUV422	(0 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_RGB655	(1 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUV655	(1 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_RGB844	(2 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUV844	(2 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_RGBA6442	(3 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUVA6442	(3 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_RGBA4444	(4 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUVA4444	(4 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_RGB565	(5 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUV565	(5 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_ARGB4444	(6 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_AYUV4444	(6 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_ARGB1555	(7 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_AYUV1555	(7 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_RGBA4642	(8 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUVA4642	(8 << GE2D_COLOR_MAP_SHIFT)
-/* 24 bit */
-#define GE2D_COLOR_MAP_RGB888	(0 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUV444	(0 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_RGBA5658	(1 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUVA5658	(1 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_ARGB8565	(2 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_AYUV8565	(2 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_RGBA6666	(3 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUVA6666	(3 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_ARGB6666	(4 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_AYUV6666	(4 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_BGR888	(5 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_VUY888	(5 << GE2D_COLOR_MAP_SHIFT)
-/* 32 bit */
-#define GE2D_COLOR_MAP_RGBA8888	(0 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_YUVA8888	(0 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_ARGB8888	(1 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_AYUV8888	(1 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_ABGR8888	(2 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_AVUY8888	(2 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_BGRA8888	(3 << GE2D_COLOR_MAP_SHIFT)
-#define GE2D_COLOR_MAP_VUYA8888	(3 << GE2D_COLOR_MAP_SHIFT)
-
-#define GE2D_FMT_S8_Y			0x00000 /* 00_00_0_00_0_00 */
-#define GE2D_FMT_S8_CB			0x00040 /* 00_01_0_00_0_00 */
-#define GE2D_FMT_S8_CR			0x00080 /* 00_10_0_00_0_00 */
-#define GE2D_FMT_S8_R			0x00000 /* 00_00_0_00_0_00 */
-#define GE2D_FMT_S8_G			0x00040 /* 00_01_0_00_0_00 */
-#define GE2D_FMT_S8_B			0x00080 /* 00_10_0_00_0_00 */
-#define GE2D_FMT_S8_A			0x000c0 /* 00_11_0_00_0_00 */
-#define GE2D_FMT_S8_LUT			0x00020 /* 00_00_1_00_0_00 */
-#define GE2D_FMT_S16_YUV422		0x20102 /* 01_00_0_00_0_00 */
-#define GE2D_FMT_S16_RGB		(GE2D_LITTLE_ENDIAN|0x00100) /* 01_00_0_00_0_00 */
-#define GE2D_FMT_S24_YUV444		0x20200 /* 10_00_0_00_0_00 */
-#define GE2D_FMT_S24_RGB		(GE2D_LITTLE_ENDIAN|0x00200) /* 10_00_0_00_0_00 */
-#define GE2D_FMT_S32_YUVA444	0x20300 /* 11_00_0_00_0_00 */
-#define GE2D_FMT_S32_RGBA		(GE2D_LITTLE_ENDIAN|0x00300) /* 11_00_0_00_0_00 */
-#define GE2D_FMT_M24_YUV420		0x20007 /* 00_00_0_00_1_11 */
-#define GE2D_FMT_M24_YUV422		0x20006 /* 00_00_0_00_1_10 */
-#define GE2D_FMT_M24_YUV444		0x20004 /* 00_00_0_00_1_00 */
-#define GE2D_FMT_M24_RGB		0x00004 /* 00_00_0_00_1_00 */
-#define GE2D_FMT_M24_YUV420T	0x20017 /* 00_00_0_10_1_11 */
-#define GE2D_FMT_M24_YUV420B	0x2001f /* 00_00_0_11_1_11 */
-#define GE2D_FMT_S16_YUV422T	0x20110 /* 01_00_0_10_0_00 */
-#define GE2D_FMT_S16_YUV422B	0x20138 /* 01_00_0_11_0_00 */
-#define GE2D_FMT_S24_YUV444T	0x20210 /* 10_00_0_10_0_00 */
-#define GE2D_FMT_S24_YUV444B	0x20218 /* 10_00_0_11_0_00 */
-
-#define GE2D_FORMAT_S8_Y			(GE2D_FMT_S8_Y)           
-#define GE2D_FORMAT_S8_CB			(GE2D_FMT_S8_CB)           
-#define GE2D_FORMAT_S8_CR			(GE2D_FMT_S8_CR)           
-#define GE2D_FORMAT_S8_R			(GE2D_FMT_S8_R)           
-#define GE2D_FORMAT_S8_G			(GE2D_FMT_S8_G)           
-#define GE2D_FORMAT_S8_B			(GE2D_FMT_S8_B)           
-#define GE2D_FORMAT_S8_A			(GE2D_FMT_S8_A)           
-#define GE2D_FORMAT_S8_LUT			(GE2D_FMT_S8_LUT)         
-#define GE2D_FORMAT_S16_YUV422		(GE2D_FMT_S16_YUV422	| GE2D_COLOR_MAP_YUV422)
-#define GE2D_FORMAT_S16_RGB_655		(GE2D_FMT_S16_RGB		| GE2D_COLOR_MAP_RGB655)  
-#define GE2D_FORMAT_S16_RGB_565		(GE2D_FMT_S16_RGB		| GE2D_COLOR_MAP_RGB565) 
-#define GE2D_FORMAT_S16_RGB_844		(GE2D_FMT_S16_RGB		| GE2D_COLOR_MAP_RGB844) 
-#define GE2D_FORMAT_S16_RGBA_6442	(GE2D_FMT_S16_RGB		| GE2D_COLOR_MAP_RGBA6442)
-#define GE2D_FORMAT_S16_RGBA_4444	(GE2D_FMT_S16_RGB		| GE2D_COLOR_MAP_RGBA4444)
-#define GE2D_FORMAT_S16_ARGB_4444	(GE2D_FMT_S16_RGB		| GE2D_COLOR_MAP_ARGB4444)
-#define GE2D_FORMAT_S16_ARGB_1555	(GE2D_FMT_S16_RGB		| GE2D_COLOR_MAP_ARGB1555)
-#define GE2D_FORMAT_S16_RGBA_4642	(GE2D_FMT_S16_RGB		| GE2D_COLOR_MAP_RGBA4642)
-#define GE2D_FORMAT_S24_YUV444		(GE2D_FMT_S24_YUV444	| GE2D_COLOR_MAP_YUV444) 
-#define GE2D_FORMAT_S24_RGB			(GE2D_FMT_S24_RGB		| GE2D_COLOR_MAP_RGB888)   
-#define GE2D_FORMAT_S32_YUVA444		(GE2D_FMT_S32_YUVA444	| GE2D_COLOR_MAP_YUVA4444)   
-#define GE2D_FORMAT_S32_RGBA		(GE2D_FMT_S32_RGBA		| GE2D_COLOR_MAP_RGBA8888) 
-#define GE2D_FORMAT_S32_ARGB		(GE2D_FMT_S32_RGBA		| GE2D_COLOR_MAP_ARGB8888) 
-#define GE2D_FORMAT_S32_ABGR		(GE2D_FMT_S32_RGBA		| GE2D_COLOR_MAP_ABGR8888) 
-#define GE2D_FORMAT_S32_BGRA		(GE2D_FMT_S32_RGBA		| GE2D_COLOR_MAP_BGRA8888) 
-#define GE2D_FORMAT_S24_RGBA_5658	(GE2D_FMT_S24_RGB		| GE2D_COLOR_MAP_RGBA5658)  
-#define GE2D_FORMAT_S24_ARGB_8565	(GE2D_FMT_S24_RGB		| GE2D_COLOR_MAP_ARGB8565) 
-#define GE2D_FORMAT_S24_RGBA_6666	(GE2D_FMT_S24_RGB		| GE2D_COLOR_MAP_RGBA6666)
-#define GE2D_FORMAT_S24_ARGB_6666	(GE2D_FMT_S24_RGB		| GE2D_COLOR_MAP_ARGB6666)
-#define GE2D_FORMAT_S24_BGR			(GE2D_FMT_S24_RGB		| GE2D_COLOR_MAP_BGR888)
-#define GE2D_FORMAT_M24_YUV420		(GE2D_FMT_M24_YUV420)   
-#define GE2D_FORMAT_M24_YUV422		(GE2D_FMT_M24_YUV422)
-#define GE2D_FORMAT_M24_YUV444		(GE2D_FMT_M24_YUV444)
-#define GE2D_FORMAT_M24_RGB			(GE2D_FMT_M24_RGB)
-#define GE2D_FORMAT_M24_YUV420T		(GE2D_FMT_M24_YUV420T)
-#define GE2D_FORMAT_M24_YUV420B		(GE2D_FMT_M24_YUV420B)
-#define GE2D_FORMAT_S16_YUV422T		(GE2D_FMT_S16_YUV422T | GE2D_COLOR_MAP_YUV422)
-#define GE2D_FORMAT_S16_YUV422B		(GE2D_FMT_S16_YUV422B | GE2D_COLOR_MAP_YUV422)   
-#define GE2D_FORMAT_S24_YUV444T		(GE2D_FMT_S24_YUV444T | GE2D_COLOR_MAP_YUV444)   
-#define GE2D_FORMAT_S24_YUV444B		(GE2D_FMT_S24_YUV444B | GE2D_COLOR_MAP_YUV444)
-
-
-#define OPERATION_ADD           0    //Cd = Cs*Fs+Cd*Fd
-#define OPERATION_SUB           1    //Cd = Cs*Fs-Cd*Fd
-#define OPERATION_REVERSE_SUB   2    //Cd = Cd*Fd-Cs*Fs
-#define OPERATION_MIN           3    //Cd = Min(Cd*Fd,Cs*Fs)
-#define OPERATION_MAX           4    //Cd = Max(Cd*Fd,Cs*Fs)
-#define OPERATION_LOGIC         5
-
-#define COLOR_FACTOR_ZERO                     0
-#define COLOR_FACTOR_ONE                      1
-#define COLOR_FACTOR_SRC_COLOR                2
-#define COLOR_FACTOR_ONE_MINUS_SRC_COLOR      3
-#define COLOR_FACTOR_DST_COLOR                4
-#define COLOR_FACTOR_ONE_MINUS_DST_COLOR      5
-#define COLOR_FACTOR_SRC_ALPHA                6
-#define COLOR_FACTOR_ONE_MINUS_SRC_ALPHA      7
-#define COLOR_FACTOR_DST_ALPHA                8
-#define COLOR_FACTOR_ONE_MINUS_DST_ALPHA      9
-#define COLOR_FACTOR_CONST_COLOR              10
-#define COLOR_FACTOR_ONE_MINUS_CONST_COLOR    11
-#define COLOR_FACTOR_CONST_ALPHA              12
-#define COLOR_FACTOR_ONE_MINUS_CONST_ALPHA    13
-#define COLOR_FACTOR_SRC_ALPHA_SATURATE       14
-
-#define ALPHA_FACTOR_ZERO                     0
-#define ALPHA_FACTOR_ONE                      1
-#define ALPHA_FACTOR_SRC_ALPHA                2
-#define ALPHA_FACTOR_ONE_MINUS_SRC_ALPHA      3
-#define ALPHA_FACTOR_DST_ALPHA                4
-#define ALPHA_FACTOR_ONE_MINUS_DST_ALPHA      5
-#define ALPHA_FACTOR_CONST_ALPHA              6
-#define ALPHA_FACTOR_ONE_MINUS_CONST_ALPHA    7
-
-#define LOGIC_OPERATION_CLEAR       0
-#define LOGIC_OPERATION_COPY        1
-#define LOGIC_OPERATION_NOOP        2
-#define LOGIC_OPERATION_SET         3
-#define LOGIC_OPERATION_COPY_INVERT 4
-#define LOGIC_OPERATION_INVERT      5
-#define LOGIC_OPERATION_AND_REVERSE 6
-#define LOGIC_OPERATION_OR_REVERSE  7
-#define LOGIC_OPERATION_AND         8
-#define LOGIC_OPERATION_OR          9
-#define LOGIC_OPERATION_NAND        10
-#define LOGIC_OPERATION_NOR         11
-#define LOGIC_OPERATION_XOR         12
-#define LOGIC_OPERATION_EQUIV       13
-#define LOGIC_OPERATION_AND_INVERT  14
-#define LOGIC_OPERATION_OR_INVERT   15 
-
-static inline unsigned blendop(unsigned color_blending_mode,
-                               unsigned color_blending_src_factor,
-                               unsigned color_blending_dst_factor,
-                               unsigned alpha_blending_mode,
-                               unsigned alpha_blending_src_factor,
-                               unsigned alpha_blending_dst_factor)
-{
-    return (color_blending_mode << 24) |
-           (color_blending_src_factor << 20) |
-           (color_blending_dst_factor << 16) |
-           (alpha_blending_mode << 8) |
-           (alpha_blending_src_factor << 4) |
-           (alpha_blending_dst_factor << 0);
-}
-
-
-#endif /* GE2D_H */
diff --git a/jpegenc/amljpeg_enc.c b/jpegenc/amljpeg_enc.c
new file mode 100755
index 0000000..5d44138
--- a/dev/null
+++ b/jpegenc/amljpeg_enc.c
@@ -0,0 +1,98 @@
+#include"amljpeg_enc.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 "jpeglib.h"
+#include "jconfig.h"

+#include <setjmp.h>
+#include "amljpeg_enc.h"
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  char* obuf;
+  int buf_size;
+  int data_size;
+} aml_destination_mgr;
+
+typedef aml_destination_mgr * aml_dest_ptr;
+
+static void init_destination (j_compress_ptr cinfo)
+{
+  aml_dest_ptr dest = (aml_dest_ptr) cinfo->dest;
+
+  dest->pub.next_output_byte = dest->obuf;
+  dest->pub.free_in_buffer = dest->buf_size;
+}
+
+static boolean empty_output_buffer (j_compress_ptr cinfo)
+{
+  aml_dest_ptr dest = (aml_dest_ptr) cinfo->dest;
+
+  /* error handling, input buffer too small. */
+  /* maybe you need not use jpeg encoder. */
+
+  return FALSE;
+}
+
+static void term_destination (j_compress_ptr cinfo)
+{
+  aml_dest_ptr dest = (aml_dest_ptr) cinfo->dest;
+  size_t datacount = dest->buf_size - dest->pub.free_in_buffer;
+
+  dest->data_size = datacount;
+}
+
+int encode_jpeg(jpeg_enc_t* enc) 
+{
+
+	/* create compress. information data. */
+	struct jpeg_compress_struct cinfo;
+	struct jpeg_error_mgr jerr;
+	aml_destination_mgr dest;
+	
+	JSAMPROW row_pointer[1];	/* pointer to JSAMPLE row[s] */
+	int row_stride;		/* physical row width in image buffer */
+	cinfo.err = jpeg_std_error(&jerr);
+	jpeg_create_compress(&cinfo);
+	//jpeg_stdio_dest(&cinfo, outfile);
+	cinfo.dest=(struct jpeg_destination_mgr *)&dest;
+	dest.pub.init_destination = init_destination;
+	dest.pub.empty_output_buffer = empty_output_buffer;
+	dest.pub.term_destination = term_destination;
+	
+	dest.obuf = enc->odata;
+	dest.buf_size = enc->obuff_size;
+
+	/* set parameters. */
+	cinfo.image_width = enc->width; 	
+	cinfo.image_height = enc->height;
+	cinfo.input_components = 3;		
+	cinfo.in_color_space = JCS_RGB;
+	jpeg_set_defaults(&cinfo);
+	if(enc->quality==0)
+		enc->quality=75;
+	jpeg_set_quality(&cinfo, enc->quality, TRUE);
+
+	jpeg_start_compress(&cinfo, TRUE);
+
+	row_stride = enc->width * 3;	
+
+	/* processing. */
+	while (cinfo.next_scanline < cinfo.image_height) {
+		row_pointer[0] = & enc->idata[cinfo.next_scanline * row_stride];
+		(void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
+	}
+
+	jpeg_finish_compress(&cinfo);
+	jpeg_destroy_compress(&cinfo);
+	return dest.data_size;
+}
+

+

diff --git a/amljpeg_enc.h b/jpegenc/amljpeg_enc.h
index bc27467..e2523fd 100644..100755
--- a/amljpeg_enc.h
+++ b/jpegenc/amljpeg_enc.h
@@ -10,9 +10,15 @@ typedef struct {
 	unsigned char* odata;

 	int ibuff_size;

 	int obuff_size;

-	

 } jpeg_enc_t;

 

-extern int encode_jpeg(jpeg_enc_t* enc);

+#ifdef __cplusplus

+extern "C"

+{

+#endif

+int encode_jpeg(jpeg_enc_t* enc);

+#ifdef __cplusplus

+}

+#endif

 

 #endif /* AM_JPEG_ENCODER_9908049 */
\ No newline at end of file
diff --git a/jconfig.h b/jpegenc/jconfig.h
index 15a9817..15a9817 100644..100755
--- a/jconfig.h
+++ b/jpegenc/jconfig.h
diff --git a/jmorecfg.h b/jpegenc/jmorecfg.h
index 236bbcb..236bbcb 100644..100755
--- a/jmorecfg.h
+++ b/jpegenc/jmorecfg.h
diff --git a/jpeglib.h b/jpegenc/jpeglib.h
index 0f3a547..0f3a547 100644..100755
--- a/jpeglib.h
+++ b/jpegenc/jpeglib.h
diff --git a/tvin.h b/tvin.h
deleted file mode 100755
index 8f9a2fd..0000000
--- a/tvin.h
+++ b/dev/null
@@ -1,868 +0,0 @@
-/*

- * 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 __TVIN_H

-#define __TVIN_H

-

-// ***************************************************************************

-// *** TVIN general definition/enum/struct ***********************************

-// ***************************************************************************

-

-/* tvin input port select */

-typedef enum tvin_port_e {

-    TVIN_PORT_NULL    = 0x00000000,

-    TVIN_PORT_MPEG0   = 0x00000100,

-    TVIN_PORT_BT656   = 0x00000200,

-    TVIN_PORT_BT601,

-    TVIN_PORT_CAMERA,

-    TVIN_PORT_VGA0    = 0x00000400,

-    TVIN_PORT_VGA1,

-    TVIN_PORT_VGA2,

-    TVIN_PORT_VGA3,

-    TVIN_PORT_VGA4,

-    TVIN_PORT_VGA5,

-    TVIN_PORT_VGA6,

-    TVIN_PORT_VGA7,

-    TVIN_PORT_COMP0   = 0x00000800,

-    TVIN_PORT_COMP1,

-    TVIN_PORT_COMP2,

-    TVIN_PORT_COMP3,

-    TVIN_PORT_COMP4,

-    TVIN_PORT_COMP5,

-    TVIN_PORT_COMP6,

-    TVIN_PORT_COMP7,

-    TVIN_PORT_CVBS0   = 0x00001000,

-    TVIN_PORT_CVBS1,

-    TVIN_PORT_CVBS2,

-    TVIN_PORT_CVBS3,

-    TVIN_PORT_CVBS4,

-    TVIN_PORT_CVBS5,

-    TVIN_PORT_CVBS6,

-    TVIN_PORT_CVBS7,

-    TVIN_PORT_SVIDEO0 = 0x00002000,

-    TVIN_PORT_SVIDEO1,

-    TVIN_PORT_SVIDEO2,

-    TVIN_PORT_SVIDEO3,

-    TVIN_PORT_SVIDEO4,

-    TVIN_PORT_SVIDEO5,

-    TVIN_PORT_SVIDEO6,

-    TVIN_PORT_SVIDEO7,

-    TVIN_PORT_HDMI0   = 0x00004000,

-    TVIN_PORT_HDMI1,

-    TVIN_PORT_HDMI2,

-    TVIN_PORT_HDMI3,

-    TVIN_PORT_HDMI4,

-    TVIN_PORT_HDMI5,

-    TVIN_PORT_HDMI6,

-    TVIN_PORT_HDMI7,

-    TVIN_PORT_DVIN0   = 0x00008000,

-    TVIN_PORT_MAX     = 0x80000000,

-} tvin_port_t;

-

-/* tvin signal format table */

-typedef enum tvin_sig_fmt_e {

-    TVIN_SIG_FMT_NULL = 0,

-    //VGA Formats

-    TVIN_SIG_FMT_VGA_512X384P_60D147,

-    TVIN_SIG_FMT_VGA_560X384P_60D147,

-    TVIN_SIG_FMT_VGA_640X200P_59D924,

-    TVIN_SIG_FMT_VGA_640X350P_85D080,

-    TVIN_SIG_FMT_VGA_640X400P_59D940,

-    TVIN_SIG_FMT_VGA_640X400P_85D080,

-    TVIN_SIG_FMT_VGA_640X400P_59D638,

-    TVIN_SIG_FMT_VGA_640X400P_56D416,

-    TVIN_SIG_FMT_VGA_640X480I_29D970,

-    TVIN_SIG_FMT_VGA_640X480P_66D619, // 10

-    TVIN_SIG_FMT_VGA_640X480P_66D667,

-    TVIN_SIG_FMT_VGA_640X480P_59D940,

-    TVIN_SIG_FMT_VGA_640X480P_60D000,

-    TVIN_SIG_FMT_VGA_640X480P_72D809,

-    TVIN_SIG_FMT_VGA_640X480P_75D000_A,

-    TVIN_SIG_FMT_VGA_640X480P_85D008,

-    TVIN_SIG_FMT_VGA_640X480P_59D638,

-    TVIN_SIG_FMT_VGA_640X480P_75D000_B,

-    TVIN_SIG_FMT_VGA_640X870P_75D000,

-    TVIN_SIG_FMT_VGA_720X350P_70D086, // 20

-    TVIN_SIG_FMT_VGA_720X400P_85D039,

-    TVIN_SIG_FMT_VGA_720X400P_70D086,

-    TVIN_SIG_FMT_VGA_720X400P_87D849,

-    TVIN_SIG_FMT_VGA_720X400P_59D940,

-    TVIN_SIG_FMT_VGA_720X480P_59D940,

-    TVIN_SIG_FMT_VGA_752X484I_29D970,

-    TVIN_SIG_FMT_VGA_768X574I_25D000,

-    TVIN_SIG_FMT_VGA_800X600P_56D250,

-    TVIN_SIG_FMT_VGA_800X600P_60D317,

-    TVIN_SIG_FMT_VGA_800X600P_72D188, // 30

-    TVIN_SIG_FMT_VGA_800X600P_75D000,

-    TVIN_SIG_FMT_VGA_800X600P_85D061,

-    TVIN_SIG_FMT_VGA_832X624P_75D087,

-    TVIN_SIG_FMT_VGA_848X480P_84D751,

-    TVIN_SIG_FMT_VGA_1024X768P_59D278,

-    TVIN_SIG_FMT_VGA_1024X768P_74D927,

-    TVIN_SIG_FMT_VGA_1024X768I_43D479,

-    TVIN_SIG_FMT_VGA_1024X768P_60D004,

-    TVIN_SIG_FMT_VGA_1024X768P_70D069,

-    TVIN_SIG_FMT_VGA_1024X768P_75D029, // 40

-    TVIN_SIG_FMT_VGA_1024X768P_84D997,

-    TVIN_SIG_FMT_VGA_1024X768P_60D000,

-    TVIN_SIG_FMT_VGA_1024X768P_74D925,

-    TVIN_SIG_FMT_VGA_1024X768P_75D020,

-    TVIN_SIG_FMT_VGA_1024X768P_70D008,

-    TVIN_SIG_FMT_VGA_1024X768P_75D782,

-    TVIN_SIG_FMT_VGA_1024X768P_77D069,

-    TVIN_SIG_FMT_VGA_1024X768P_71D799,

-    TVIN_SIG_FMT_VGA_1024X1024P_60D000,

-    TVIN_SIG_FMT_VGA_1053X754I_43D453, // 50

-    TVIN_SIG_FMT_VGA_1056X768I_43D470,

-    TVIN_SIG_FMT_VGA_1120X750I_40D021,

-    TVIN_SIG_FMT_VGA_1152X864P_70D012,

-    TVIN_SIG_FMT_VGA_1152X864P_75D000,

-    TVIN_SIG_FMT_VGA_1152X864P_84D999,

-    TVIN_SIG_FMT_VGA_1152X870P_75D062,

-    TVIN_SIG_FMT_VGA_1152X900P_65D950,

-    TVIN_SIG_FMT_VGA_1152X900P_66D004,

-    TVIN_SIG_FMT_VGA_1152X900P_76D047,

-    TVIN_SIG_FMT_VGA_1152X900P_76D149, // 60

-    TVIN_SIG_FMT_VGA_1244X842I_30D000,

-    TVIN_SIG_FMT_VGA_1280X768P_59D995,

-    TVIN_SIG_FMT_VGA_1280X768P_74D893,

-    TVIN_SIG_FMT_VGA_1280X768P_84D837,

-    TVIN_SIG_FMT_VGA_1280X960P_60D000,

-    TVIN_SIG_FMT_VGA_1280X960P_75D000,

-    TVIN_SIG_FMT_VGA_1280X960P_85D002,

-    TVIN_SIG_FMT_VGA_1280X1024I_43D436,

-    TVIN_SIG_FMT_VGA_1280X1024P_60D020,

-    TVIN_SIG_FMT_VGA_1280X1024P_75D025, // 70

-    TVIN_SIG_FMT_VGA_1280X1024P_85D024,

-    TVIN_SIG_FMT_VGA_1280X1024P_59D979,

-    TVIN_SIG_FMT_VGA_1280X1024P_72D005,

-    TVIN_SIG_FMT_VGA_1280X1024P_60D002,

-    TVIN_SIG_FMT_VGA_1280X1024P_67D003,

-    TVIN_SIG_FMT_VGA_1280X1024P_74D112,

-    TVIN_SIG_FMT_VGA_1280X1024P_76D179,

-    TVIN_SIG_FMT_VGA_1280X1024P_66D718,

-    TVIN_SIG_FMT_VGA_1280X1024P_66D677,

-    TVIN_SIG_FMT_VGA_1280X1024P_76D107, // 80

-    TVIN_SIG_FMT_VGA_1280X1024P_59D996,

-    TVIN_SIG_FMT_VGA_1360X768P_59D799,

-    TVIN_SIG_FMT_VGA_1360X1024I_51D476,

-    TVIN_SIG_FMT_VGA_1440X1080P_60D000,

-    TVIN_SIG_FMT_VGA_1600X1200I_48D040,

-    TVIN_SIG_FMT_VGA_1600X1200P_60D000,

-    TVIN_SIG_FMT_VGA_1600X1200P_65D000,

-    TVIN_SIG_FMT_VGA_1600X1200P_70D000,

-    TVIN_SIG_FMT_VGA_1600X1200P_75D000,

-    TVIN_SIG_FMT_VGA_1600X1200P_80D000, // 90

-    TVIN_SIG_FMT_VGA_1600X1200P_85D000,

-    TVIN_SIG_FMT_VGA_1600X1280P_66D931,

-    TVIN_SIG_FMT_VGA_1680X1080P_60D000,

-    TVIN_SIG_FMT_VGA_1792X1344P_60D000,

-    TVIN_SIG_FMT_VGA_1792X1344P_74D997,

-    TVIN_SIG_FMT_VGA_1856X1392P_59D995,

-    TVIN_SIG_FMT_VGA_1856X1392P_75D000,

-    TVIN_SIG_FMT_VGA_1868X1200P_75D000,

-    TVIN_SIG_FMT_VGA_1920X1080P_60D000,

-    TVIN_SIG_FMT_VGA_1920X1080P_75D000, // 100

-    TVIN_SIG_FMT_VGA_1920X1080P_85D000,

-    TVIN_SIG_FMT_VGA_1920X1200P_84D932,

-    TVIN_SIG_FMT_VGA_1920X1200P_59D950,

-    TVIN_SIG_FMT_VGA_1920X1200P_75D000,

-    TVIN_SIG_FMT_VGA_1920X1200P_85D000,

-    TVIN_SIG_FMT_VGA_1920X1234P_75D000,

-    TVIN_SIG_FMT_VGA_1920X1234P_85D000,

-    TVIN_SIG_FMT_VGA_1920X1440P_60D000,

-    TVIN_SIG_FMT_VGA_1920X1440P_75D000,

-    TVIN_SIG_FMT_VGA_2048X1536P_60D000_A, // 110

-    TVIN_SIG_FMT_VGA_2048X1536P_75D000,

-    TVIN_SIG_FMT_VGA_2048X1536P_60D000_B,

-    TVIN_SIG_FMT_VGA_2048X2048P_60D008,

-    TVIN_SIG_FMT_VGA_MAX,

-    //Component Formats

-    TVIN_SIG_FMT_COMP_480P_60D000,

-    TVIN_SIG_FMT_COMP_480I_59D940,

-    TVIN_SIG_FMT_COMP_576P_50D000,

-    TVIN_SIG_FMT_COMP_576I_50D000,

-    TVIN_SIG_FMT_COMP_720P_59D940,

-    TVIN_SIG_FMT_COMP_720P_50D000, // 120

-    TVIN_SIG_FMT_COMP_1080P_23D976,

-    TVIN_SIG_FMT_COMP_1080P_24D000,

-    TVIN_SIG_FMT_COMP_1080P_25D000,

-    TVIN_SIG_FMT_COMP_1080P_30D000,

-    TVIN_SIG_FMT_COMP_1080P_50D000,

-    TVIN_SIG_FMT_COMP_1080P_60D000,

-    TVIN_SIG_FMT_COMP_1080I_47D952,

-    TVIN_SIG_FMT_COMP_1080I_48D000,

-    TVIN_SIG_FMT_COMP_1080I_50D000_A,

-    TVIN_SIG_FMT_COMP_1080I_50D000_B, // 130

-    TVIN_SIG_FMT_COMP_1080I_50D000_C,

-    TVIN_SIG_FMT_COMP_1080I_60D000,

-    TVIN_SIG_FMT_COMP_MAX,

-    //HDMI Formats

-    TVIN_SIG_FMT_HDMI_640x480P_60Hz,

-    TVIN_SIG_FMT_HDMI_720x480P_60Hz,

-    TVIN_SIG_FMT_HDMI_1280x720P_60Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080I_60Hz,

-    TVIN_SIG_FMT_HDMI_1440x480I_60Hz,

-    TVIN_SIG_FMT_HDMI_1440x240P_60Hz,

-    TVIN_SIG_FMT_HDMI_2880x480I_60Hz, // 140

-    TVIN_SIG_FMT_HDMI_2880x240P_60Hz,

-    TVIN_SIG_FMT_HDMI_1440x480P_60Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080P_60Hz,

-    TVIN_SIG_FMT_HDMI_720x576P_50Hz,

-    TVIN_SIG_FMT_HDMI_1280x720P_50Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080I_50Hz_A,

-    TVIN_SIG_FMT_HDMI_1440x576I_50Hz,

-    TVIN_SIG_FMT_HDMI_1440x288P_50Hz,

-    TVIN_SIG_FMT_HDMI_2880x576I_50Hz,

-    TVIN_SIG_FMT_HDMI_2880x288P_50Hz, // 150

-    TVIN_SIG_FMT_HDMI_1440x576P_50Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080P_50Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080P_24Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080P_25Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080P_30Hz,

-    TVIN_SIG_FMT_HDMI_2880x480P_60Hz,

-    TVIN_SIG_FMT_HDMI_2880x576P_60Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080I_50Hz_B,

-    TVIN_SIG_FMT_HDMI_1920x1080I_100Hz,

-    TVIN_SIG_FMT_HDMI_1280x720P_100Hz, // 160

-    TVIN_SIG_FMT_HDMI_720x576P_100Hz,

-    TVIN_SIG_FMT_HDMI_1440x576I_100Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080I_120Hz,

-    TVIN_SIG_FMT_HDMI_1280x720P_120Hz,

-    TVIN_SIG_FMT_HDMI_720x480P_120Hz,

-    TVIN_SIG_FMT_HDMI_1440x480I_120Hz,

-    TVIN_SIG_FMT_HDMI_720x576P_200Hz,

-    TVIN_SIG_FMT_HDMI_1440x576I_200Hz,

-    TVIN_SIG_FMT_HDMI_720x480P_240Hz,

-    TVIN_SIG_FMT_HDMI_1440x480I_240Hz, // 170

-    TVIN_SIG_FMT_HDMI_1280x720P_24Hz,

-    TVIN_SIG_FMT_HDMI_1280x720P_25Hz,

-    TVIN_SIG_FMT_HDMI_1280x720P_30Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080P_120Hz,

-    TVIN_SIG_FMT_HDMI_1920x1080P_100Hz,

-    TVIN_SIG_FMT_HDMI_MAX,

-    //Video Formats

-    TVIN_SIG_FMT_CVBS_NTSC_M,

-    TVIN_SIG_FMT_CVBS_NTSC_443,

-    TVIN_SIG_FMT_CVBS_PAL_I,

-    TVIN_SIG_FMT_CVBS_PAL_M, // 180

-    TVIN_SIG_FMT_CVBS_PAL_60,

-    TVIN_SIG_FMT_CVBS_PAL_CN,

-    TVIN_SIG_FMT_CVBS_SECAM,

-    //656 Formats

-    TVIN_SIG_FMT_BT656IN_576I,

-    TVIN_SIG_FMT_BT656IN_480I,

-    //601 Formats

-    TVIN_SIG_FMT_BT601IN_576I,

-    TVIN_SIG_FMT_BT601IN_480I,

-    //Camera Formats

-    TVIN_SIG_FMT_CAMERA_640X480P_30Hz,

-    TVIN_SIG_FMT_CAMERA_800X600P_30Hz,

-    TVIN_SIG_FMT_CAMERA_1024X768P_30Hz, // 190

-    TVIN_SIG_FMT_CAMERA_1920X1080P_30Hz,

-    TVIN_SIG_FMT_CAMERA_1280X720P_30Hz,

-    TVIN_SIG_FMT_MAX,

-} tvin_sig_fmt_t;

-

-//tvin signal status

-typedef enum tvin_sig_status_e {

-    TVIN_SIG_STATUS_NULL = 0, // processing status from init to the finding of the 1st confirmed status

-    TVIN_SIG_STATUS_NOSIG,    // no signal - physically no signal

-    TVIN_SIG_STATUS_UNSTABLE, // unstable - physically bad signal

-    TVIN_SIG_STATUS_NOTSUP,   // not supported - physically good signal & not supported

-    TVIN_SIG_STATUS_STABLE,   // stable - physically good signal & supported

-} tvin_sig_status_t;

-

-// tvin parameters

-#define TVIN_PARM_FLAG_CAP 0x00000001 //tvin_parm_t.flag[ 0]: 1/enable or 0/disable frame capture function

-

-

-typedef struct tvin_parm_s {

-    enum tvin_port_e        port;     // must set port in IOCTL

-    enum tvin_sig_fmt_e     fmt;      // signal format of format

-    enum tvin_sig_status_e  status;   // signal status of decoder

-    unsigned int            cap_addr; // start address of captured frame data [8 bits] in memory

-                                      // for Component input, frame data [8 bits] order is Y0Cb0Y1Cr0¡­Y2nCb2nY2n+1Cr2n¡­

-                                      // for VGA       input, frame data [8 bits] order is R0G0B0¡­RnGnBn¡­

-    unsigned int            cap_size;

-    unsigned int            flag;     // bit0 TVIN_PARM_FLAG_CAP

-                                      //bit31: TVIN_PARM_FLAG_WORK_ON

-    unsigned int            canvas_index; // reserved

-} tvin_parm_t;

-

-

-// ***************************************************************************

-// *** AFE module definition/enum/struct *************************************

-// ***************************************************************************

-

-typedef enum tvafe_cmd_status_e {

-    TVAFE_CMD_STATUS_IDLE = 0,   // idle, be ready for TVIN_IOC_S_AFE_VGA_AUTO command

-    TVAFE_CMD_STATUS_PROCESSING, // TVIN_IOC_S_AFE_VGA_AUTO command is in process

-    TVAFE_CMD_STATUS_SUCCESSFUL, // TVIN_IOC_S_AFE_VGA_AUTO command is done with success

-    TVAFE_CMD_STATUS_FAILED,     // TVIN_IOC_S_AFE_VGA_AUTO command is done with failure

-    TVAFE_CMD_STATUS_TERMINATED, // TVIN_IOC_S_AFE_VGA_AUTO command is terminated by others related

-} tvafe_cmd_status_t;

-

-typedef struct tvafe_vga_edid_s {

-    unsigned char value[256]; //256 byte EDID

-} tvafe_vga_edid_t;

-

-typedef struct tvafe_comp_wss_s {

-    unsigned int wss1[5];

-    unsigned int wss2[5];

-} tvafe_comp_wss_t;

-

-typedef struct tvafe_vga_parm_s {

-      signed short clk_step;  // clock < 0, tune down clock freq

-                              // clock > 0, tune up clock freq

-    unsigned short phase;     // phase is 0~31, it is absolute value

-      signed short hpos_step; // hpos_step < 0, shift display to left

-                              // hpos_step < 0, shift display to right

-      signed short vpos_step; // vpos_step < 0, shift display to top

-                              // vpos_step > 0, shift display to bottom

-    unsigned int   reserved;  // reserved

-} tvafe_vga_parm_t;

-

-typedef struct tvafe_adc_cal_s {

-    // ADC A

-    unsigned short a_analog_gain;     // 0x00~0xff, means 0dB~6dB

-    unsigned short a_digital_offset1; // offset for fine-tuning

-                                      // s11.0:   signed value, 11 integer bits,  0 fraction bits

-    unsigned short a_digital_gain;    // 0~3.999

-                                      // u2.10: unsigned value,  2 integer bits, 10 fraction bits

-    unsigned short a_digital_offset2; // offset for format

-                                      // s11.0:   signed value, 11 integer bits,  0 fraction bits

-    // ADC B

-    unsigned short b_analog_gain;     // ditto to ADC A

-    unsigned short b_digital_offset1;

-    unsigned short b_digital_gain;

-    unsigned short b_digital_offset2;

-    // ADC C

-    unsigned short c_analog_gain;     // ditto to ADC A

-    unsigned short c_digital_offset1;

-    unsigned short c_digital_gain;

-    unsigned short c_digital_offset2;

-    // ADC D

-    unsigned short d_analog_gain;     // ditto to ADC A

-    unsigned short d_digital_offset1;

-    unsigned short d_digital_gain;

-    unsigned short d_digital_offset2;

-    unsigned int   reserved;          // reserved

-} tvafe_adc_cal_t;

-

-typedef enum tvafe_cvbs_video_e {

-    TVAFE_CVBS_VIDEO_UNLOCKED = 0,

-    TVAFE_CVBS_VIDEO_LOCKED,

-} tvafe_cvbs_video_t;

-

-// ***************************************************************************

-// *** analog tuner module definition/enum/struct ****************************

-// ***************************************************************************

-

-typedef unsigned long long tuner_std_id;

-

-/* one bit for each */

-#define TUNER_STD_PAL_B     ((tuner_std_id)0x00000001)

-#define TUNER_STD_PAL_B1    ((tuner_std_id)0x00000002)

-#define TUNER_STD_PAL_G     ((tuner_std_id)0x00000004)

-#define TUNER_STD_PAL_H     ((tuner_std_id)0x00000008)

-#define TUNER_STD_PAL_I     ((tuner_std_id)0x00000010)

-#define TUNER_STD_PAL_D     ((tuner_std_id)0x00000020)

-#define TUNER_STD_PAL_D1    ((tuner_std_id)0x00000040)

-#define TUNER_STD_PAL_K     ((tuner_std_id)0x00000080)

-#define TUNER_STD_PAL_M     ((tuner_std_id)0x00000100)

-#define TUNER_STD_PAL_N     ((tuner_std_id)0x00000200)

-#define TUNER_STD_PAL_Nc    ((tuner_std_id)0x00000400)

-#define TUNER_STD_PAL_60    ((tuner_std_id)0x00000800)

-#define TUNER_STD_NTSC_M    ((tuner_std_id)0x00001000)

-#define TUNER_STD_NTSC_M_JP ((tuner_std_id)0x00002000)

-#define TUNER_STD_NTSC_443  ((tuner_std_id)0x00004000)

-#define TUNER_STD_NTSC_M_KR ((tuner_std_id)0x00008000)

-#define TUNER_STD_SECAM_B   ((tuner_std_id)0x00010000)

-#define TUNER_STD_SECAM_D   ((tuner_std_id)0x00020000)

-#define TUNER_STD_SECAM_G   ((tuner_std_id)0x00040000)

-#define TUNER_STD_SECAM_H   ((tuner_std_id)0x00080000)

-#define TUNER_STD_SECAM_K   ((tuner_std_id)0x00100000)

-#define TUNER_STD_SECAM_K1  ((tuner_std_id)0x00200000)

-#define TUNER_STD_SECAM_L   ((tuner_std_id)0x00400000)

-#define TUNER_STD_SECAM_LC  ((tuner_std_id)0x00800000)

-

-#define TUNER_DEMO_STAUS_PONR_BIT				0x01

-#define TUNER_DEMO_STAUS_AFC_BIT				0x1e    // Fc-Fo in the unit of Hz

-                                                        // Fc is the current freq

-                                                        // Fo is the target freq

-#define TUNER_DEMO_STAUS_FMIFL_BIT				0x20

-#define TUNER_DEMO_STAUS_VIFL_BIT				0x40

-#define TUNER_DEMO_STAUS_AFCWIN_BIT			    0x80

-

-/* some merged standards */

-#define TUNER_STD_MN       (TUNER_STD_PAL_M    |\

-                            TUNER_STD_PAL_N    |\

-                            TUNER_STD_PAL_Nc   |\

-                            TUNER_STD_NTSC)

-#define TUNER_STD_B        (TUNER_STD_PAL_B    |\

-                            TUNER_STD_PAL_B1   |\

-                            TUNER_STD_SECAM_B)

-#define TUNER_STD_GH       (TUNER_STD_PAL_G    |\

-                            TUNER_STD_PAL_H    |\

-                            TUNER_STD_SECAM_G  |\

-                            TUNER_STD_SECAM_H)

-#define TUNER_STD_DK       (TUNER_STD_PAL_DK   |\

-                            TUNER_STD_SECAM_DK)

-

-/* some common needed stuff */

-#define TUNER_STD_PAL_BG   (TUNER_STD_PAL_B     |\

-                            TUNER_STD_PAL_B1    |\

-                            TUNER_STD_PAL_G)

-#define TUNER_STD_PAL_DK   (TUNER_STD_PAL_D     |\

-                            TUNER_STD_PAL_D1    |\

-                            TUNER_STD_PAL_K)

-#define TUNER_STD_PAL      (TUNER_STD_PAL_BG    |\

-                            TUNER_STD_PAL_DK    |\

-                            TUNER_STD_PAL_H     |\

-                            TUNER_STD_PAL_I)

-#define TUNER_STD_NTSC     (TUNER_STD_NTSC_M    |\

-                            TUNER_STD_NTSC_M_JP |\

-                            TUNER_STD_NTSC_M_KR)

-#define TUNER_STD_SECAM_DK (TUNER_STD_SECAM_D   |\

-                            TUNER_STD_SECAM_K   |\

-                            TUNER_STD_SECAM_K1)

-#define TUNER_STD_SECAM    (TUNER_STD_SECAM_B   |\

-                            TUNER_STD_SECAM_G   |\

-                            TUNER_STD_SECAM_H   |\

-                            TUNER_STD_SECAM_DK  |\

-                            TUNER_STD_SECAM_L   |\

-                            TUNER_STD_SECAM_LC)

-#define TUNER_STD_525_60   (TUNER_STD_PAL_M     |\

-                            TUNER_STD_PAL_60    |\

-                            TUNER_STD_NTSC      |\

-                            TUNER_STD_NTSC_443)

-#define TUNER_STD_625_50   (TUNER_STD_PAL       |\

-                            TUNER_STD_PAL_N     |\

-                            TUNER_STD_PAL_Nc    |\

-                            TUNER_STD_SECAM)

-#define TUNER_STD_UNKNOWN   0

-#define TUNER_STD_ALL      (TUNER_STD_525_60    |\

-                            TUNER_STD_625_50)

-

-typedef enum tuner_signal_status_e {

-    TUNER_SIGNAL_STATUS_WEAK = 0, // RF PLL unlocked

-    TUNER_SIGNAL_STATUS_STRONG,   // RF PLL   locked

-}tuner_signal_status_t;

-

-typedef struct tuner_parm_s {

-    unsigned int               rangelow;  // tuner frequency is in the unit of Hz

-    unsigned int               rangehigh; // tuner frequency is in the unit of Hz

-    enum tuner_signal_status_e signal;

-             int               			if_status;

-    unsigned int               reserved;  // reserved

-} tuner_parm_t;

-

-typedef struct tuner_freq_s {

-    unsigned int freq;     // tuner frequency is in the unit of Hz

-    unsigned int reserved; // reserved

-} tuner_freq_s;

-

-// for pin selection

-typedef enum tvafe_adc_pin_e {

-    TVAFE_ADC_PIN_NULL = 0,

-    TVAFE_ADC_PIN_A_PGA_0,

-    TVAFE_ADC_PIN_A_PGA_1,

-    TVAFE_ADC_PIN_A_PGA_2,

-    TVAFE_ADC_PIN_A_PGA_3,

-    TVAFE_ADC_PIN_A_PGA_4,

-    TVAFE_ADC_PIN_A_PGA_5,

-    TVAFE_ADC_PIN_A_PGA_6,

-    TVAFE_ADC_PIN_A_PGA_7,

-    TVAFE_ADC_PIN_A_0,

-    TVAFE_ADC_PIN_A_1,

-    TVAFE_ADC_PIN_A_2,

-    TVAFE_ADC_PIN_A_3,

-    TVAFE_ADC_PIN_A_4,

-    TVAFE_ADC_PIN_A_5,

-    TVAFE_ADC_PIN_A_6,

-    TVAFE_ADC_PIN_A_7,

-    TVAFE_ADC_PIN_B_0,

-    TVAFE_ADC_PIN_B_1,

-    TVAFE_ADC_PIN_B_2,

-    TVAFE_ADC_PIN_B_3,

-    TVAFE_ADC_PIN_B_4,

-    TVAFE_ADC_PIN_B_5,

-    TVAFE_ADC_PIN_B_6,

-    TVAFE_ADC_PIN_B_7,

-    TVAFE_ADC_PIN_C_0,

-    TVAFE_ADC_PIN_C_1,

-    TVAFE_ADC_PIN_C_2,

-    TVAFE_ADC_PIN_C_3,

-    TVAFE_ADC_PIN_C_4,

-    TVAFE_ADC_PIN_C_5,

-    TVAFE_ADC_PIN_C_6,

-    TVAFE_ADC_PIN_C_7,

-    TVAFE_ADC_PIN_D_0,

-    TVAFE_ADC_PIN_D_1,

-    TVAFE_ADC_PIN_D_2,

-    TVAFE_ADC_PIN_D_3,

-    TVAFE_ADC_PIN_D_4,

-    TVAFE_ADC_PIN_D_5,

-    TVAFE_ADC_PIN_D_6,

-    TVAFE_ADC_PIN_D_7,

-    TVAFE_ADC_PIN_SOG_0,

-    TVAFE_ADC_PIN_SOG_1,

-    TVAFE_ADC_PIN_SOG_2,

-    TVAFE_ADC_PIN_SOG_3,

-    TVAFE_ADC_PIN_SOG_4,

-    TVAFE_ADC_PIN_SOG_5,

-    TVAFE_ADC_PIN_SOG_6,

-    TVAFE_ADC_PIN_SOG_7,

-    TVAFE_ADC_PIN_MAX,

-} tvafe_adc_pin_t;

-

-typedef enum tvafe_src_sig_e {

-    CVBS0_Y = 0,

-    CVBS1_Y,

-    CVBS2_Y,

-    CVBS3_Y,

-    CVBS4_Y,

-    CVBS5_Y,

-    CVBS6_Y,

-    CVBS7_Y,

-    S_VIDEO0_Y,

-    S_VIDEO0_C,

-    S_VIDEO1_Y,

-    S_VIDEO1_C,

-    S_VIDEO2_Y,

-    S_VIDEO2_C,

-    S_VIDEO3_Y,

-    S_VIDEO3_C,

-    S_VIDEO4_Y,

-    S_VIDEO4_C,

-    S_VIDEO5_Y,

-    S_VIDEO5_C,

-    S_VIDEO6_Y,

-    S_VIDEO6_C,

-    S_VIDEO7_Y,

-    S_VIDEO7_C,

-    VGA0_G,

-    VGA0_B,

-    VGA0_R,

-    VGA0_SOG,

-    VGA1_G,

-    VGA1_B,

-    VGA1_R,

-    VGA1_SOG,

-    VGA2_G,

-    VGA2_B,

-    VGA2_R,

-    VGA2_SOG,

-    VGA3_G,

-    VGA3_B,

-    VGA3_R,

-    VGA3_SOG,

-    VGA4_G,

-    VGA4_B,

-    VGA4_R,

-    VGA4_SOG,

-    VGA5_G,

-    VGA5_B,

-    VGA5_R,

-    VGA5_SOG,

-    VGA6_G,

-    VGA6_B,

-    VGA6_R,

-    VGA6_SOG,

-    VGA7_G,

-    VGA7_B,

-    VGA7_R,

-    VGA7_SOG,

-    COMP0_Y,

-    COMP0_PB,

-    COMP0_PR,

-    COMP0_SOG,

-    COMP1_Y,

-    COMP1_PB,

-    COMP1_PR,

-    COMP1_SOG,

-    COMP2_Y,

-    COMP2_PB,

-    COMP2_PR,

-    COMP2_SOG,

-    COMP3_Y,

-    COMP3_PB,

-    COMP3_PR,

-    COMP3_SOG,

-    COMP4_Y,

-    COMP4_PB,

-    COMP4_PR,

-    COMP4_SOG,

-    COMP5_Y,

-    COMP5_PB,

-    COMP5_PR,

-    COMP5_SOG,

-    COMP6_Y,

-    COMP6_PB,

-    COMP6_PR,

-    COMP6_SOG,

-    COMP7_Y,

-    COMP7_PB,

-    COMP7_PR,

-    COMP7_SOG,

-    SCART0_G,

-    SCART0_B,

-    SCART0_R,

-    SCART0_CVBS,

-    SCART1_G,

-    SCART1_B,

-    SCART1_R,

-    SCART1_CVBS,

-    SCART2_G,

-    SCART2_B,

-    SCART2_R,

-    SCART2_CVBS,

-    SCART3_G,

-    SCART3_B,

-    SCART3_R,

-    SCART3_CVBS,

-    SCART4_G,

-    SCART4_B,

-    SCART4_R,

-    SCART4_CVBS,

-    SCART5_G,

-    SCART5_B,

-    SCART5_R,

-    SCART5_CVBS,

-    SCART6_G,

-    SCART6_B,

-    SCART6_R,

-    SCART6_CVBS,

-    SCART7_G,

-    SCART7_B,

-    SCART7_R,

-    SCART7_CVBS,

-    TVAFE_SRC_SIG_MAX_NUM,

-} tvafe_src_sig_t;

-

-typedef struct tvafe_pin_mux_s {

-	enum tvafe_adc_pin_e pin[TVAFE_SRC_SIG_MAX_NUM];

-} tvafe_pin_mux_t;

-

-

-// ***************************************************************************

-// *** IOCTL command definition **********************************************

-// ***************************************************************************

-

-#define TVIN_IOC_MAGIC 'T'

-

-//GENERAL

-#define TVIN_IOC_START_DEC          _IOW(TVIN_IOC_MAGIC, 0x01, struct tvin_parm_s)

-#define TVIN_IOC_STOP_DEC           _IO( TVIN_IOC_MAGIC, 0x02)

-#define TVIN_IOC_G_PARM             _IOR(TVIN_IOC_MAGIC, 0x03, struct tvin_parm_s)

-#define TVIN_IOC_S_PARM             _IOW(TVIN_IOC_MAGIC, 0x04, struct tvin_parm_s)

-

-//TVAFE

-#define TVIN_IOC_S_AFE_ADC_CAL      _IOW(TVIN_IOC_MAGIC, 0x11, struct tvafe_adc_cal_s)

-#define TVIN_IOC_G_AFE_ADC_CAL      _IOR(TVIN_IOC_MAGIC, 0x12, struct tvafe_adc_cal_s)

-#define TVIN_IOC_G_AFE_COMP_WSS     _IOR(TVIN_IOC_MAGIC, 0x13, struct tvafe_comp_wss_s)

-#define TVIN_IOC_S_AFE_VGA_EDID     _IOW(TVIN_IOC_MAGIC, 0x14, struct tvafe_vga_edid_s)

-#define TVIN_IOC_G_AFE_VGA_EDID     _IOR(TVIN_IOC_MAGIC, 0x15, struct tvafe_vga_edid_s)

-#define TVIN_IOC_S_AFE_VGA_PARM     _IOW(TVIN_IOC_MAGIC, 0x16, struct tvafe_vga_parm_s)

-#define TVIN_IOC_G_AFE_VGA_PARM     _IOR(TVIN_IOC_MAGIC, 0x17, struct tvafe_vga_parm_s)

-#define TVIN_IOC_S_AFE_VGA_AUTO     _IO( TVIN_IOC_MAGIC, 0x18)

-#define TVIN_IOC_G_AFE_CMD_STATUS   _IOR(TVIN_IOC_MAGIC, 0x19, enum tvafe_cmd_status_e)

-#define TVIN_IOC_G_AFE_CVBS_LOCK    _IOR(TVIN_IOC_MAGIC, 0x1a, enum tvafe_cvbs_video_e)

-

-//TUNER

-#define TVIN_IOC_G_TUNER_STD        _IOR(TVIN_IOC_MAGIC, 0x21, tuner_std_id)

-#define TVIN_IOC_S_TUNER_STD        _IOW(TVIN_IOC_MAGIC, 0x22, tuner_std_id)

-#define TVIN_IOC_G_TUNER_FREQ       _IOR(TVIN_IOC_MAGIC, 0x23, struct tuner_freq_s)

-#define TVIN_IOC_S_TUNER_FREQ       _IOW(TVIN_IOC_MAGIC, 0x24, struct tuner_freq_s)

-#define TVIN_IOC_G_TUNER_PARM       _IOR(TVIN_IOC_MAGIC, 0x25, struct tuner_parm_s)

-

-

-

-/*

-    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;

-

-

-

-

-typedef struct camera_info_s {

-	#define AMLOGIC_CAMERA_OV5640_NAME     			"camera_ov5640"

-	#define AMLOGIC_CAMERA_GT2005_NAME     			"camera_gt2005"

-	#define AMLOGIC_CAMERA_GC0308_NAME     			"camera_gc0308"

-	const char * camera_name;

-    enum camera_saturation_e saturation;

-    enum camera_brightness_e brighrness;

-    enum camera_contrast_e contrast;

-    enum camera_hue_e hue;

-//  enum camera_special_effect_e special_effect;

-    enum camera_exposure_e exposure;

-    enum camera_sharpness_e sharpness;

-    enum camera_mirror_flip_e mirro_flip;

-    enum tvin_sig_fmt_e resolution;

-	enum camera_wb_flip_e white_balance;

-	enum camera_night_mode_flip_e night_mode;

-	enum camera_effect_flip_e effect;

-	int qulity;

-}camera_info_t;

-

-

-

-    // ***************************************************************************

-    // *** IOCTL command definitions *****************************************

-    // ***************************************************************************

-

-#define CAMERA_IOC_MAGIC 'C'

-

-

-#define CAMERA_IOC_START        _IOW(CAMERA_IOC_MAGIC, 0x01, struct camera_info_s)

-#define CAMERA_IOC_STOP         _IO(CAMERA_IOC_MAGIC, 0x02)

-#define CAMERA_IOC_SET_PARA     _IOW(CAMERA_IOC_MAGIC, 0x03, struct camera_info_s)

-#define CAMERA_IOC_GET_PARA     _IOR(CAMERA_IOC_MAGIC, 0x04, struct camera_info_s)

-#define CAMERA_IOC_START_CAPTURE_PARA     _IOR(CAMERA_IOC_MAGIC, 0x05, struct camera_info_s)

-#define CAMERA_IOC_STOP_CAPTURE_PARA     _IOR(CAMERA_IOC_MAGIC, 0x06, struct camera_info_s)

-

-

-/*

-    macro defined applied to camera driver is ending

-*/

-

-

-#endif

-

-