Commit: d5a403fef350592255cc99ee9b1db63973d6dc99 - frameworks-base (git)

frameworks/base

Commit MetaInfo

• Révision: d5a403fef350592255cc99ee9b1db63973d6dc99 (tree)
• l'heure: 2010-02-27 17:47:44
• Auteur: Jeremy Chang <jeremy@0xla...>
• Commiter: Chih-Wei Huang

Message de Log

bring up video recording function from 0xlab.org

Change Summary

• modified: camera/libcameraservice/Android.mk
• modified: camera/libcameraservice/CameraHardware.cpp
• modified: camera/libcameraservice/CameraHardware.h
• modified: camera/libcameraservice/V4L2Camera.cpp
• modified: camera/libcameraservice/V4L2Camera.h
• add: camera/libcameraservice/converter.cpp
• add: camera/libcameraservice/converter.h

Modification

--- a/camera/libcameraservice/Android.mk
+++ b/camera/libcameraservice/Android.mk
@@ -8,7 +8,8 @@ include $(CLEAR_VARS)
 
 LOCAL_SRC_FILES:=               \
     CameraHardware.cpp         \
-    V4L2Camera.cpp
+    V4L2Camera.cpp         \
+    converter.cpp
 
 LOCAL_CFLAGS += -Iexternal/jpeg
 

--- a/camera/libcameraservice/CameraHardware.cpp
+++ b/camera/libcameraservice/CameraHardware.cpp
@@ -1,5 +1,6 @@
 /*
 **
+** Copyright (C) 2009 0xlab.org - http://0xlab.org/
 ** Copyright 2008, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,15 +20,23 @@
 #include <utils/Log.h>
 
 #include "CameraHardware.h"
+#include "converter.h"
 #include <fcntl.h>
 #include <sys/mman.h>
 
 #define VIDEO_DEVICE        "/dev/video0"
-#define MIN_WIDTH           640
-
-#define MIN_HEIGHT          480
+#define PREVIEW_WIDTH           352
+#define PREVIEW_HEIGHT          288
+#define PICTURE_WIDTH       1600   /* 2MP */
+#define PICTURE_HEIGHT      1200   /* 2MP */
 #define PIXEL_FORMAT        V4L2_PIX_FMT_YUYV
 
+#include <cutils/properties.h>
+#ifndef UNLIKELY
+#define UNLIKELY(exp) (__builtin_expect( (exp) != 0, false ))
+#endif
+static int mDebugFps = 0;
+
 namespace android {
 
 wp<CameraHardwareInterface> CameraHardware::singleton;
@@ -37,7 +46,10 @@ CameraHardware::CameraHardware()
                     mHeap(0),
                     mPreviewHeap(0),
                     mRawHeap(0),
-					mPreviewFrameSize(0),
+                    mPreviewFrameSize(0),
+                    mRecordingFrameSize(0),
+                    mRecordingCallback(0),
+                    mRecordingCallbackCookie(0),
                     mRawPictureCallback(0),
                     mJpegPictureCallback(0),
                     mPictureCallbackCookie(0),
@@ -45,24 +57,28 @@ CameraHardware::CameraHardware()
                     mPreviewCallbackCookie(0),
                     mAutoFocusCallback(0),
                     mAutoFocusCallbackCookie(0),
-                    mCurrentPreviewFrame(0),
-                    previewStopped(true),
-                    nQueued(0),
-                    nDequeued(0)
+                    previewStopped(true)
 {
     initDefaultParameters();
+    /* whether prop "debug.camera.showfps" is enabled or not */
+    char value[PROPERTY_VALUE_MAX];
+    property_get("debug.camera.showfps", value, "0");
+    mDebugFps = atoi(value);
+    LOGD_IF(mDebugFps, "showfps enabled");
 }
 
 void CameraHardware::initDefaultParameters()
 {
     CameraParameters p;
 
-    p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT);
-    p.setPreviewFrameRate(15);
+    p.setPreviewSize(PREVIEW_WIDTH, PREVIEW_HEIGHT);
+    p.setPreviewFrameRate(DEFAULT_FRAME_RATE);
     p.setPreviewFormat("yuv422sp");
-
-    p.setPictureSize(MIN_WIDTH, MIN_HEIGHT);
     p.setPictureFormat("jpeg");
+    p.setPictureSize(PREVIEW_WIDTH, PREVIEW_HEIGHT);
+
+    p.set("jpeg-quality", "100"); // maximum quality
+    p.set("picture-size-values", "1600x1200,1024x768,640x480,352x288");
 
     if (setParameters(p) != NO_ERROR) {
         LOGE("Failed to set default parameters?!");
@@ -76,7 +92,7 @@ CameraHardware::~CameraHardware()
 
 sp<IMemoryHeap> CameraHardware::getPreviewHeap() const
 {
-    return mHeap;
+    return mPreviewHeap;
 }
 
 sp<IMemoryHeap> CameraHardware::getRawHeap() const
@@ -85,13 +101,59 @@ sp<IMemoryHeap> CameraHardware::getRawHeap() const
 }
 
 // ---------------------------------------------------------------------------
+static void showFPS(const char *tag)
+{
+    static int mFrameCount = 0;
+    static int mLastFrameCount = 0;
+    static nsecs_t mLastFpsTime = 0;
+    static float mFps = 0;
+    mFrameCount++;
+    if (!(mFrameCount & 0x1F)) {
+        nsecs_t now = systemTime();
+        nsecs_t diff = now - mLastFpsTime;
+        mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
+        mLastFpsTime = now;
+        mLastFrameCount = mFrameCount;
+        LOGD("[%s] %d Frames, %f FPS", tag, mFrameCount, mFps);
+    }
+}
 
 int CameraHardware::previewThread()
 {
+    Mutex::Autolock lock(mPreviewLock);
     if (!previewStopped) {
-        // Get preview frame
-        camera.GrabPreviewFrame(mHeap->getBase());
-        mPreviewCallback(mBuffer, mPreviewCallbackCookie);
+
+        camera.GrabRawFrame(mRawHeap->getBase());
+
+        if (mRecordingCallback) {
+            yuyv422_to_yuv420sp((unsigned char *)mRawHeap->getBase(),
+                              (unsigned char *)mRecordingHeap->getBase(),
+                              PREVIEW_WIDTH, PREVIEW_HEIGHT);
+            nsecs_t timeStamp = systemTime(SYSTEM_TIME_MONOTONIC);
+            mRecordingCallback(timeStamp, mRecordingBuffer, mRecordingCallbackCookie);
+
+            camera.convert((unsigned char *) mRawHeap->getBase(),
+                           (unsigned char *) mPreviewHeap->getBase(),
+                           PREVIEW_WIDTH, PREVIEW_HEIGHT);
+
+            if (UNLIKELY(mDebugFps)) {
+                showFPS("Recording");
+            }
+        }
+        else {
+            camera.convert((unsigned char *) mRawHeap->getBase(),
+                           (unsigned char *) mPreviewHeap->getBase(),
+                           PREVIEW_WIDTH, PREVIEW_HEIGHT);
+
+            yuyv422_to_yuv420((unsigned char *)mRawHeap->getBase(),
+                              (unsigned char *)mHeap->getBase(),
+                              PREVIEW_WIDTH, PREVIEW_HEIGHT);
+            mPreviewCallback(mBuffer, mPreviewCallbackCookie);
+
+            if (UNLIKELY(mDebugFps)) {
+                showFPS("Preview");
+            }
+        }
     }
 
     return NO_ERROR;
@@ -104,16 +166,29 @@ status_t CameraHardware::startPreview(preview_callback cb, void* user)
     Mutex::Autolock lock(mLock);
     if (mPreviewThread != 0) {
         //already running
+        LOGD("startPreview:  but already running");
         return INVALID_OPERATION;
     }
 
-    camera.Open(VIDEO_DEVICE, MIN_WIDTH, MIN_HEIGHT, PIXEL_FORMAT);
+    if (camera.Open(VIDEO_DEVICE, PREVIEW_WIDTH, PREVIEW_HEIGHT, PIXEL_FORMAT) < 0) {
+	LOGE("startPreview failed: cannot open device.");
+        return UNKNOWN_ERROR;
+    }
 
-    mPreviewFrameSize = MIN_WIDTH * MIN_HEIGHT * 2;
+    mPreviewFrameSize = PREVIEW_WIDTH * PREVIEW_HEIGHT * 2;
 
     mHeap = new MemoryHeapBase(mPreviewFrameSize);
     mBuffer = new MemoryBase(mHeap, 0, mPreviewFrameSize);
 
+    mPreviewHeap = new MemoryHeapBase(mPreviewFrameSize);
+    mPreviewBuffer = new MemoryBase(mPreviewHeap, 0, mPreviewFrameSize);
+
+    mRecordingHeap = new MemoryHeapBase(mPreviewFrameSize);
+    mRecordingBuffer = new MemoryBase(mRecordingHeap, 0, mPreviewFrameSize);
+
+    mRawHeap = new MemoryHeapBase(mPreviewFrameSize);
+    mRawBuffer = new MemoryBase(mRawHeap, 0, mPreviewFrameSize);
+
     camera.Init();
     camera.StartStreaming();
 
@@ -161,20 +236,34 @@ bool CameraHardware::previewEnabled()
 
 status_t CameraHardware::startRecording(recording_callback cb, void* user)
 {
-    return UNKNOWN_ERROR;
+    LOGD("startRecording");
+    mRecordingLock.lock();
+    mRecordingCallback = cb;
+    mRecordingCallbackCookie = user;
+    mRecordingLock.unlock();
+    return NO_ERROR;
+
 }
 
 void CameraHardware::stopRecording()
 {
+    mRecordingLock.lock();
+    mRecordingCallback = NULL;
+    mRecordingCallbackCookie = NULL;
+    mRecordingLock.unlock();
 }
 
 bool CameraHardware::recordingEnabled()
 {
-    return false;
+    return mRecordingCallback !=0;
 }
 
 void CameraHardware::releaseRecordingFrame(const sp<IMemory>& mem)
 {
+    if (UNLIKELY(mDebugFps)) {
+        showFPS("Recording");
+    }
+    return;
 }
 
 // ---------------------------------------------------------------------------
@@ -219,44 +308,25 @@ status_t CameraHardware::autoFocus(autofocus_callback af_cb,
 
 int CameraHardware::pictureThread()
 {
-    unsigned char *frame;
-    int bufferSize;
-    int w,h;
     int ret;
-    struct v4l2_buffer buffer;
-    struct v4l2_format format;
-    struct v4l2_buffer cfilledbuffer;
-    struct v4l2_requestbuffers creqbuf;
-    struct v4l2_capability cap;
 
     if (mShutterCallback)
         mShutterCallback(mPictureCallbackCookie);
 
-    mParameters.getPictureSize(&w, &h);
-    LOGD("Picture Size: Width = %d \t Height = %d", w, h);
-
-    int width, height;
-    mParameters.getPictureSize(&width, &height);
-    camera.Open(VIDEO_DEVICE, MIN_WIDTH, MIN_HEIGHT, PIXEL_FORMAT);
-    camera.Init();
-    camera.StartStreaming();
-
-    if (mRawPictureCallback) {
-        LOGD("mRawPictureCallback");
-
-//    	mRawPictureCallback(camera.GrabRawFrame(), mPictureCallbackCookie);
+    sp<PreviewThread> previewThread;
+    Mutex::Autolock lock(mLock);
+    previewStopped = true;
+    previewThread = mPreviewThread;
+    if (previewThread != 0) {
+        previewThread->requestExitAndWait();
     }
-
+    mPreviewThread.clear();
+    // Grab the photo
     if (mJpegPictureCallback) {
-        LOGD ("mJpegPictureCallback");
-
         mJpegPictureCallback(camera.GrabJpegFrame(), mPictureCallbackCookie);
     }
-
-    camera.Uninit();
-    camera.StopStreaming();
-    camera.Close();
-
+    previewStopped = false;
+    mPreviewThread = new PreviewThread(this);
     return NO_ERROR;
 }
 
@@ -265,14 +335,10 @@ status_t CameraHardware::takePicture(shutter_callback shutter_cb,
                                          jpeg_callback jpeg_cb,
                                          void* user)
 {
-    stopPreview();
     mShutterCallback = shutter_cb;
     mRawPictureCallback = raw_cb;
     mJpegPictureCallback = jpeg_cb;
     mPictureCallbackCookie = user;
-    //if (createThread(beginPictureThread, this) == false)
-    //    return -1;
-
     pictureThread();
 
     return NO_ERROR;
@@ -316,11 +382,13 @@ status_t CameraHardware::setParameters(const CameraParameters& params)
     LOGD("PREVIEW SIZE: w=%d h=%d framerate=%d", w, h, framerate);
 
     params.getPictureSize(&w, &h);
+    LOGD("requested size %d x %d", w, h);
 
     mParameters = params;
 
     // Set to fixed sizes
-    mParameters.setPreviewSize(MIN_WIDTH,MIN_HEIGHT);
+    mParameters.setPreviewSize(PREVIEW_WIDTH, PREVIEW_HEIGHT);
+    mParameters.setPictureSize(PREVIEW_WIDTH, PREVIEW_HEIGHT);
 
     return NO_ERROR;
 }
@@ -330,7 +398,7 @@ CameraParameters CameraHardware::getParameters() const
     CameraParameters params;
 
     {
-    Mutex::Autolock lock(mLock);
+        Mutex::Autolock lock(mLock);
         params = mParameters;
     }
 
@@ -339,7 +407,6 @@ CameraParameters CameraHardware::getParameters() const
 
 void CameraHardware::release()
 {
-    close(camera_device);
 }
 
 sp<CameraHardwareInterface> CameraHardware::createInstance()

--- a/camera/libcameraservice/CameraHardware.h
+++ b/camera/libcameraservice/CameraHardware.h
@@ -1,5 +1,6 @@
 /*
 **
+** Copyright (C) 2009 0xlab.org - http://0xlab.org/
 ** Copyright 2008, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,7 +25,7 @@
 #include <utils/MemoryHeapBase.h>
 #include <utils/threads.h>
 
-#include <sys/ioctl.h>
+#include <jpeglib.h>
 #include "V4L2Camera.h"
 
 namespace android {
@@ -93,14 +94,17 @@ private:
     int pictureThread();
 
     mutable Mutex       mLock;
+    mutable Mutex       mPreviewLock;
 
     CameraParameters    mParameters;
 
-    sp<MemoryHeapBase>	mHeap;
-    sp<MemoryBase>		mBuffer;
+    sp<MemoryHeapBase>  mHeap;         // format: 420
+    sp<MemoryBase>      mBuffer;
 
-    sp<MemoryHeapBase>  mPreviewHeap;
-    sp<MemoryHeapBase>  mRawHeap;
+    sp<MemoryHeapBase>  mPreviewHeap;  // format: 565
+    sp<MemoryBase>      mPreviewBuffer;
+    sp<MemoryHeapBase>  mRawHeap;      // format: 422
+    sp<MemoryBase>      mRawBuffer;
 
     bool                mPreviewRunning;
     int                 mPreviewFrameSize;
@@ -110,7 +114,6 @@ private:
     jpeg_callback       mJpegPictureCallback;
     void                *mPictureCallbackCookie;
 
-    // protected by mLock
     sp<PreviewThread>   mPreviewThread;
     preview_callback    mPreviewCallback;
     void                *mPreviewCallbackCookie;
@@ -118,16 +121,16 @@ private:
     autofocus_callback  mAutoFocusCallback;
     void                *mAutoFocusCallbackCookie;
 
-    // only used from PreviewThread
-    int                 mCurrentPreviewFrame;
+    sp<MemoryHeapBase>  mRecordingHeap;
+    sp<MemoryBase>      mRecordingBuffer;
 
-    void *				framebuffer;
-    bool				previewStopped;
-    int					camera_device;
-    void* 				mem[4];
-    int					nQueued;
-    int 				nDequeued;
-    V4L2Camera			camera;
+    Mutex               mRecordingLock;
+    int                 mRecordingFrameSize;
+    recording_callback  mRecordingCallback;
+    void                *mRecordingCallbackCookie;
+
+    bool		previewStopped;
+    V4L2Camera		camera;
 };
 
 }; // namespace android

--- a/camera/libcameraservice/V4L2Camera.cpp
+++ b/camera/libcameraservice/V4L2Camera.cpp
@@ -1,11 +1,20 @@
 /*
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *      Author: Niels Keeman  [e-mail]
- *
- */
+**
+** Copyright (C) 2009 0xlab.org - http://0xlab.org/
+** 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 "V4L2Camera"
 #include <utils/Log.h>
@@ -22,12 +31,12 @@
 
 #include <linux/videodev.h>
 
-#include "V4L2Camera.h"
-
-extern "C" { /* Android jpeglib.h missed extern "C" */
-#include <jpeglib.h>
+extern "C" {
+    #include <jpeglib.h>
 }
 
+#include "V4L2Camera.h"
+
 namespace android {
 
 V4L2Camera::V4L2Camera ()
@@ -41,7 +50,7 @@ V4L2Camera::~V4L2Camera()
     free(videoIn);
 }
 
-int V4L2Camera::Open (const char *device, int width, int height, int pixelformat)
+int V4L2Camera::Open(const char *device, int width, int height, int pixelformat)
 {
     int ret;
 
@@ -82,6 +91,15 @@ int V4L2Camera::Open (const char *device, int width, int height, int pixelformat
         return ret;
     }
 
+    ret = init_parm();
+    if (ret < 0) {
+        LOGE("Init_parm Failed: %s", strerror(errno));
+        return ret;
+    }
+
+    videoIn->width = videoIn->format.fmt.pix.width;
+    videoIn->height = videoIn->format.fmt.pix.height;
+
     return 0;
 }
 
@@ -90,6 +108,8 @@ void V4L2Camera::Close ()
     close(fd);
 }
 
+
+//  Init mmap
 int V4L2Camera::Init()
 {
     int ret;
@@ -143,7 +163,34 @@ int V4L2Camera::Init()
     return 0;
 }
 
-void V4L2Camera::Uninit ()
+int V4L2Camera::init_parm()
+{
+    int ret;
+    int framerate;
+    struct v4l2_streamparm parm;
+
+    framerate = DEFAULT_FRAME_RATE;
+
+    parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+    ret = ioctl(fd, VIDIOC_G_PARM, &parm);
+    if(ret != 0) {
+        LOGE("VIDIOC_G_PARM fail....");
+        return ret;
+    }
+
+    parm.parm.capture.timeperframe.numerator = 1;
+    parm.parm.capture.timeperframe.denominator = framerate;
+    ret = ioctl(fd, VIDIOC_S_PARM, &parm);
+    if(ret != 0) {
+        LOGE("VIDIOC_S_PARM  Fail....");
+        return -1;
+    }
+
+    return 0;
+}
+
+void V4L2Camera::Uninit()
 {
     int ret;
 
@@ -220,16 +267,15 @@ void V4L2Camera::GrabPreviewFrame (void *previewBuffer)
     /* DQ */
     ret = ioctl(fd, VIDIOC_DQBUF, &videoIn->buf);
     if (ret < 0) {
-        //LOGE("GrabPreviewFrame: VIDIOC_DQBUF Failed");
-
+        LOGE("GrabPreviewFrame: VIDIOC_DQBUF Failed");
         return;
     }
     nDequeued++;
 
-    memcpy (tmpBuffer, videoIn->mem[videoIn->buf.index], (size_t) videoIn->buf.bytesused);
+    memcpy(tmpBuffer, videoIn->mem[videoIn->buf.index], (size_t) videoIn->buf.bytesused);
 
-    //convertYUYVtoYUV422SP((uint8_t *)tmpBuffer, (uint8_t *)previewBuffer, videoIn->width, videoIn->height);
-    convert((unsigned char *)tmpBuffer, (unsigned char *)previewBuffer, videoIn->width, videoIn->height);
+    convert((unsigned char *) tmpBuffer, (unsigned char *) previewBuffer,
+            videoIn->width, videoIn->height);
 
     ret = ioctl(fd, VIDIOC_QBUF, &videoIn->buf);
     if (ret < 0) {
@@ -242,14 +288,49 @@ void V4L2Camera::GrabPreviewFrame (void *previewBuffer)
     free(tmpBuffer);
 }
 
-sp<IMemory> V4L2Camera::GrabRawFrame ()
+void V4L2Camera::GrabRawFrame(void *previewBuffer)
+{
+    int ret;
+
+    videoIn->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    videoIn->buf.memory = V4L2_MEMORY_MMAP;
+
+    /* DQ */
+    ret = ioctl(fd, VIDIOC_DQBUF, &videoIn->buf);
+    if (ret < 0) {
+        LOGE("GrabRawFrame: VIDIOC_DQBUF Failed");
+        return;
+    }
+    nDequeued++;
+
+    memcpy(previewBuffer, videoIn->mem[videoIn->buf.index], (size_t) videoIn->buf.bytesused);
+
+    ret = ioctl(fd, VIDIOC_QBUF, &videoIn->buf);
+    if (ret < 0) {
+        LOGE("postGrabRawFrame: VIDIOC_QBUF Failed");
+        return;
+    }
+
+    nQueued++;
+}
+
+int
+V4L2Camera::savePicture(unsigned char *inputBuffer, const char * filename)
 {
-    sp<MemoryHeapBase> memHeap = new MemoryHeapBase(videoIn->width * videoIn->height * 2);
-    sp<MemoryBase> memBase = new MemoryBase(memHeap, 0, videoIn->width * videoIn->height * 2);
+    FILE *output;
+    int fileSize;
+    int ret;
+    output = fopen(filename, "wb");
+
+    if (output == NULL) {
+        LOGE("GrabJpegFrame: Ouput file == NULL");
+        return 0;
+    }
 
-    // Not yet implemented, do I have to?
+    fileSize = saveYUYVtoJPEG(inputBuffer, videoIn->width, videoIn->height, output, 100);
 
-    return memBase;
+    fclose(output);
+    return fileSize;
 }
 
 sp<IMemory> V4L2Camera::GrabJpegFrame ()
@@ -270,7 +351,7 @@ sp<IMemory> V4L2Camera::GrabJpegFrame ()
     }
     nDequeued++;
 
-    LOGI("GrabJpegFrame: Generated a frame from capture device");
+    fileSize = savePicture((unsigned char *)videoIn->mem[videoIn->buf.index], "/sdcard/tmp.jpg");
 
     /* Enqueue buffer */
     ret = ioctl(fd, VIDIOC_QBUF, &videoIn->buf);
@@ -280,17 +361,6 @@ sp<IMemory> V4L2Camera::GrabJpegFrame ()
     }
     nQueued++;
 
-    output = fopen("/sdcard/tmp.jpg", "wb");
-
-    if (output == NULL) {
-        LOGE("GrabJpegFrame: Ouput file == NULL");
-        return NULL;
-    }
-
-    fileSize = saveYUYVtoJPEG((unsigned char *)videoIn->mem[videoIn->buf.index], videoIn->width, videoIn->height, output, 85);
-
-    fclose(output);
-
     input = fopen("/sdcard/tmp.jpg", "rb");
 
     if (input == NULL)
@@ -324,8 +394,6 @@ int V4L2Camera::saveYUYVtoJPEG (unsigned char *inputBuffer, int width, int heigh
     jpeg_create_compress (&cinfo);
     jpeg_stdio_dest (&cinfo, file);
 
-    LOGI("JPEG PICTURE WIDTH AND HEIGHT: %dx%d", width, height);
-
     cinfo.image_width = width;
     cinfo.image_height = height;
     cinfo.input_components = 3;
@@ -380,6 +448,30 @@ int V4L2Camera::saveYUYVtoJPEG (unsigned char *inputBuffer, int width, int heigh
     return fileSize;
 }
 
+static inline void yuv_to_rgb16(unsigned char y,
+                                unsigned char u,
+                                unsigned char v,
+                                unsigned char *rgb)
+{
+    register int r,g,b;
+    int rgb16;
+
+    r = (1192 * (y - 16) + 1634 * (v - 128) ) >> 10;
+    g = (1192 * (y - 16) - 833 * (v - 128) - 400 * (u -128) ) >> 10;
+    b = (1192 * (y - 16) + 2066 * (u - 128) ) >> 10;
+
+    r = r > 255 ? 255 : r < 0 ? 0 : r;
+    g = g > 255 ? 255 : g < 0 ? 0 : g;
+    b = b > 255 ? 255 : b < 0 ? 0 : b;
+
+    rgb16 = (int)(((r >> 3)<<11) | ((g >> 2) << 5)| ((b >> 3) << 0));
+
+    *rgb = (unsigned char)(rgb16 & 0xFF);
+    rgb++;
+    *rgb = (unsigned char)((rgb16 & 0xFF00) >> 8);
+
+}
+
 void V4L2Camera::convert(unsigned char *buf, unsigned char *rgb, int width, int height)
 {
     int x,y,z=0;
@@ -398,36 +490,8 @@ void V4L2Camera::convert(unsigned char *buf, unsigned char *rgb, int width, int
         yuv_to_rgb16(Y1, U, V, &rgb[y]);
         yuv_to_rgb16(Y2, U, V, &rgb[y + 2]);
     }
-
 }
 
-void V4L2Camera::yuv_to_rgb16(unsigned char y, unsigned char u, unsigned char v, unsigned char *rgb)
-{
-    int r,g,b;
-    int z;
-    int rgb16;
-
-    z = 0;
-
-    r = 1.164 * (y - 16) + 1.596 * (v - 128);
-    g = 1.164 * (y - 16) - 0.813 * (v - 128) - 0.391 * (u -128);
-    b = 1.164 * (y - 16) + 2.018 * (u - 128);
-
-    if (r > 255) r = 255;
-    if (g > 255) g = 255;
-    if (b > 255) b = 255;
-
-    if (r < 0) r = 0;
-    if (g < 0) g = 0;
-    if (b < 0) b = 0;
-
-    rgb16 = (int)(((r >> 3)<<11) | ((g >> 2) << 5)| ((b >> 3) << 0));
-
-    *rgb = (unsigned char)(rgb16 & 0xFF);
-    rgb++;
-    *rgb = (unsigned char)((rgb16 & 0xFF00) >> 8);
-
-}
 
 
 }; // namespace android

--- a/camera/libcameraservice/V4L2Camera.h
+++ b/camera/libcameraservice/V4L2Camera.h
@@ -1,16 +1,26 @@
 /*
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *      Author: Niels Keeman  [e-mail]
- *
- */
+**
+** Copyright (C) 2009 0xlab.org - http://0xlab.org/
+** 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 _V4L2CAMERA_H
 #define _V4L2CAMERA_H
 
 #define NB_BUFFER 4
+#define DEFAULT_FRAME_RATE 30
 
 #include <utils/MemoryBase.h>
 #include <utils/MemoryHeapBase.h>
@@ -41,14 +51,17 @@ public:
     void Close ();
 
     int Init ();
+    int init_parm();
     void Uninit ();
 
     int StartStreaming ();
     int StopStreaming ();
 
     void GrabPreviewFrame (void *previewBuffer);
-    sp<IMemory> GrabRawFrame ();
+    void GrabRawFrame(void *previewBuffer);
     sp<IMemory> GrabJpegFrame ();
+    int savePicture(unsigned char *inputBuffer, const char * filename);
+    void convert(unsigned char *buf, unsigned char *rgb, int width, int height);
 
 private:
     struct vdIn *videoIn;
@@ -58,9 +71,6 @@ private:
     int nDequeued;
 
     int saveYUYVtoJPEG (unsigned char *inputBuffer, int width, int height, FILE *file, int quality);
-
-    void convert(unsigned char *buf, unsigned char *rgb, int width, int height);
-    void yuv_to_rgb16(unsigned char y, unsigned char u, unsigned char v, unsigned char *rgb);
 };
 
 }; // namespace android

--- /dev/null
+++ b/camera/libcameraservice/converter.cpp
@@ -0,0 +1,261 @@
+/*
+**
+** Copyright (C) 2009 0xlab.org - http://0xlab.org/
+** Copyright 2008, The Android Open Source Project
+**
+** This work is based on yuvconverter 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.
+*/
+
+#include "converter.h"
+
+void
+yuyv422_to_yuv420(unsigned char *bufsrc, unsigned char *bufdest, int width, int height)
+{
+    unsigned char *ptrsrcy1, *ptrsrcy2;
+    unsigned char *ptrsrcy3, *ptrsrcy4;
+    unsigned char *ptrsrccb1, *ptrsrccb2;
+    unsigned char *ptrsrccb3, *ptrsrccb4;
+    unsigned char *ptrsrccr1, *ptrsrccr2;
+    unsigned char *ptrsrccr3, *ptrsrccr4;
+    int srcystride, srcccstride;
+
+    ptrsrcy1  = bufsrc ;
+    ptrsrcy2  = bufsrc + (width<<1) ;
+    ptrsrcy3  = bufsrc + (width<<1)*2 ;
+    ptrsrcy4  = bufsrc + (width<<1)*3 ;
+
+    ptrsrccb1 = bufsrc + 1;
+    ptrsrccb2 = bufsrc + (width<<1) + 1;
+    ptrsrccb3 = bufsrc + (width<<1)*2 + 1;
+    ptrsrccb4 = bufsrc + (width<<1)*3 + 1;
+
+    ptrsrccr1 = bufsrc + 3;
+    ptrsrccr2 = bufsrc + (width<<1) + 3;
+    ptrsrccr3 = bufsrc + (width<<1)*2 + 3;
+    ptrsrccr4 = bufsrc + (width<<1)*3 + 3;
+
+    srcystride  = (width<<1)*3;
+    srcccstride = (width<<1)*3;
+
+    unsigned char *ptrdesty1, *ptrdesty2;
+    unsigned char *ptrdesty3, *ptrdesty4;
+    unsigned char *ptrdestcb1, *ptrdestcb2;
+    unsigned char *ptrdestcr1, *ptrdestcr2;
+    int destystride, destccstride;
+
+    ptrdesty1 = bufdest;
+    ptrdesty2 = bufdest + width;
+    ptrdesty3 = bufdest + width*2;
+    ptrdesty4 = bufdest + width*3;
+
+    ptrdestcb1 = bufdest + width*height;
+    ptrdestcb2 = bufdest + width*height + (width>>1);
+
+    ptrdestcr1 = bufdest + width*height + ((width*height) >> 2);
+    ptrdestcr2 = bufdest + width*height + ((width*height) >> 2) + (width>>1);
+
+    destystride  = (width)*3;
+    destccstride = (width>>1);
+
+    int i, j;
+
+    for(j=0; j<(height/4); j++)
+    {
+        for(i=0;i<(width/2);i++)
+        {
+            (*ptrdesty1++) = (*ptrsrcy1);
+            (*ptrdesty2++) = (*ptrsrcy2);
+            (*ptrdesty3++) = (*ptrsrcy3);
+            (*ptrdesty4++) = (*ptrsrcy4);
+
+            ptrsrcy1 += 2;
+            ptrsrcy2 += 2;
+            ptrsrcy3 += 2;
+            ptrsrcy4 += 2;
+
+            (*ptrdesty1++) = (*ptrsrcy1);
+            (*ptrdesty2++) = (*ptrsrcy2);
+            (*ptrdesty3++) = (*ptrsrcy3);
+            (*ptrdesty4++) = (*ptrsrcy4);
+
+            ptrsrcy1 += 2;
+            ptrsrcy2 += 2;
+            ptrsrcy3 += 2;
+            ptrsrcy4 += 2;
+
+            (*ptrdestcb1++) = (*ptrsrccb1);
+            (*ptrdestcb2++) = (*ptrsrccb3);
+
+            ptrsrccb1 += 4;
+            ptrsrccb3 += 4;
+
+            (*ptrdestcr1++) = (*ptrsrccr1);
+            (*ptrdestcr2++) = (*ptrsrccr3);
+
+            ptrsrccr1 += 4;
+            ptrsrccr3 += 4;
+
+        }
+
+
+        /* Update src pointers */
+        ptrsrcy1  += srcystride;
+        ptrsrcy2  += srcystride;
+        ptrsrcy3  += srcystride;
+        ptrsrcy4  += srcystride;
+
+        ptrsrccb1 += srcccstride;
+        ptrsrccb3 += srcccstride;
+
+        ptrsrccr1 += srcccstride;
+        ptrsrccr3 += srcccstride;
+
+
+        /* Update dest pointers */
+        ptrdesty1 += destystride;
+        ptrdesty2 += destystride;
+        ptrdesty3 += destystride;
+        ptrdesty4 += destystride;
+
+        ptrdestcb1 += destccstride;
+        ptrdestcb2 += destccstride;
+
+        ptrdestcr1 += destccstride;
+        ptrdestcr2 += destccstride;
+
+    }
+}
+
+void
+yuyv422_to_yuv420sp(unsigned char *bufsrc, unsigned char *bufdest, int width, int height)
+{
+    unsigned char *ptrsrcy1, *ptrsrcy2;
+    unsigned char *ptrsrcy3, *ptrsrcy4;
+    unsigned char *ptrsrccb1, *ptrsrccb2;
+    unsigned char *ptrsrccb3, *ptrsrccb4;
+    unsigned char *ptrsrccr1, *ptrsrccr2;
+    unsigned char *ptrsrccr3, *ptrsrccr4;
+    int srcystride, srcccstride;
+
+    ptrsrcy1  = bufsrc ;
+    ptrsrcy2  = bufsrc + (width<<1) ;
+    ptrsrcy3  = bufsrc + (width<<1)*2 ;
+    ptrsrcy4  = bufsrc + (width<<1)*3 ;
+
+    ptrsrccb1 = bufsrc + 1;
+    ptrsrccb2 = bufsrc + (width<<1) + 1;
+    ptrsrccb3 = bufsrc + (width<<1)*2 + 1;
+    ptrsrccb4 = bufsrc + (width<<1)*3 + 1;
+
+    ptrsrccr1 = bufsrc + 3;
+    ptrsrccr2 = bufsrc + (width<<1) + 3;
+    ptrsrccr3 = bufsrc + (width<<1)*2 + 3;
+    ptrsrccr4 = bufsrc + (width<<1)*3 + 3;
+
+    srcystride  = (width<<1)*3;
+    srcccstride = (width<<1)*3;
+
+    unsigned char *ptrdesty1, *ptrdesty2;
+    unsigned char *ptrdesty3, *ptrdesty4;
+    unsigned char *ptrdestcb1, *ptrdestcb2;
+    unsigned char *ptrdestcr1, *ptrdestcr2;
+    int destystride, destccstride;
+
+    ptrdesty1 = bufdest;
+    ptrdesty2 = bufdest + width;
+    ptrdesty3 = bufdest + width*2;
+    ptrdesty4 = bufdest + width*3;
+
+    ptrdestcb1 = bufdest + width*height;
+    ptrdestcb2 = bufdest + width*height + width;
+
+    ptrdestcr1 = bufdest + width*height + 1;
+    ptrdestcr2 = bufdest + width*height + width + 1;
+
+    destystride  = (width)*3;
+    destccstride = width;
+
+    int i, j;
+
+    for(j=0; j<(height/4); j++)
+    {
+        for(i=0;i<(width/2);i++)
+        {
+            (*ptrdesty1++) = (*ptrsrcy1);
+            (*ptrdesty2++) = (*ptrsrcy2);
+            (*ptrdesty3++) = (*ptrsrcy3);
+            (*ptrdesty4++) = (*ptrsrcy4);
+
+            ptrsrcy1 += 2;
+            ptrsrcy2 += 2;
+            ptrsrcy3 += 2;
+            ptrsrcy4 += 2;
+
+            (*ptrdesty1++) = (*ptrsrcy1);
+            (*ptrdesty2++) = (*ptrsrcy2);
+            (*ptrdesty3++) = (*ptrsrcy3);
+            (*ptrdesty4++) = (*ptrsrcy4);
+
+            ptrsrcy1 += 2;
+            ptrsrcy2 += 2;
+            ptrsrcy3 += 2;
+            ptrsrcy4 += 2;
+
+            (*ptrdestcb1) = (*ptrsrccb1);
+            (*ptrdestcb2) = (*ptrsrccb3);
+            ptrdestcb1 += 2;
+            ptrdestcb2 += 2;
+
+            ptrsrccb1 += 4;
+            ptrsrccb3 += 4;
+
+            (*ptrdestcr1) = (*ptrsrccr1);
+            (*ptrdestcr2) = (*ptrsrccr3);
+            ptrdestcr1 += 2;
+            ptrdestcr2 += 2;
+
+            ptrsrccr1 += 4;
+            ptrsrccr3 += 4;
+
+        }
+
+
+        /* Update src pointers */
+        ptrsrcy1  += srcystride;
+        ptrsrcy2  += srcystride;
+        ptrsrcy3  += srcystride;
+        ptrsrcy4  += srcystride;
+
+        ptrsrccb1 += srcccstride;
+        ptrsrccb3 += srcccstride;
+
+        ptrsrccr1 += srcccstride;
+        ptrsrccr3 += srcccstride;
+
+
+        /* Update dest pointers */
+        ptrdesty1 += destystride;
+        ptrdesty2 += destystride;
+        ptrdesty3 += destystride;
+        ptrdesty4 += destystride;
+
+        ptrdestcb1 += destccstride;
+        ptrdestcb2 += destccstride;
+
+        ptrdestcr1 += destccstride;
+        ptrdestcr2 += destccstride;
+
+    }
+}

--- /dev/null
+++ b/camera/libcameraservice/converter.h
@@ -0,0 +1,25 @@
+/*
+**
+** Copyright (C) 2009 0xlab.org - http://0xlab.org/
+** 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 CONVERTER_H
+#define CONVERTER_H
+
+void yuyv422_to_yuv420(unsigned char *bufsrc, unsigned char *bufdest, int width, int height);
+void yuyv422_to_yuv420sp(unsigned char *bufsrc, unsigned char *bufdest, int width, int height);
+
+#endif