android/android_device_htc_click
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added camera

Browse Source
This commit is contained in:
calimochoazucarado 2011-01-12 08:42:14 +01:00
parent c76980ded8
commit 356bfa3ccb
8 changed files with 3279 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Android.mk
View File

@ -17,6 +17,7 @@ subdir_makefiles := \
$(LOCAL_PATH)/libcopybit/Android.mk \
$(LOCAL_PATH)/libgralloc/Android.mk \
$(LOCAL_PATH)/liblights/Android.mk \
$(LOCAL_PATH)/libcamera/Android.mk \
$(LOCAL_PATH)/libsensors/Android.mk
include $(subdir_makefiles)

41
libcamera/Android.mk Normal file
View File

@ -0,0 +1,41 @@
BOARD_USES_OLD_CAMERA_HACK:=true
ifeq ($(BOARD_USES_OLD_CAMERA_HACK),true)
BUILD_LIBCAMERA:= true
ifeq ($(BUILD_LIBCAMERA),true)
# When zero we link against libmmcamera; when 1, we dlopen libmmcamera.
DLOPEN_LIBMMCAMERA:=1
ifneq ($(BUILD_TINY_ANDROID),true)
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS:=optional
LOCAL_SRC_FILES:= QualcommCameraHardware.cpp exifwriter.c
LOCAL_CFLAGS:= -DDLOPEN_LIBMMCAMERA=$(DLOPEN_LIBMMCAMERA)
LOCAL_C_INCLUDES+= \
vendor/qcom/proprietary/mm-camera/common \
vendor/qcom/proprietary/mm-camera/apps/appslib \
external/jhead \
vendor/qcom/proprietary/mm-camera/jpeg/inc
LOCAL_SHARED_LIBRARIES:= libbinder libutils libcamera_client liblog
ifneq ($(DLOPEN_LIBMMCAMERA),1)
LOCAL_SHARED_LIBRARIES+= libmmcamera libmm-qcamera-tgt
else
LOCAL_SHARED_LIBRARIES+= libdl libexif
endif
LOCAL_MODULE:= libcamera
include $(BUILD_SHARED_LIBRARY)
endif # BUILD_TINY_ANDROID
endif # BUILD_LIBCAMERA
endif # BOARD_USES_OLD_CAMERA_HACK

2135
libcamera/QualcommCameraHardware.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

366
libcamera/QualcommCameraHardware.h Normal file
View File

@ -0,0 +1,366 @@
/*
** Copyright 2008, Google Inc.
**
** 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_QUALCOMM_CAMERA_HARDWARE_H
#define ANDROID_HARDWARE_QUALCOMM_CAMERA_HARDWARE_H
#include <camera/CameraHardwareInterface.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <utils/threads.h>
#include <stdint.h>
extern "C" {
#include <linux/android_pmem.h>
#include "msm_camera.h"
}
#define MSM_CAMERA_CONTROL "/dev/msm_camera/msm_camera0"
#define JPEG_EVENT_DONE 0 /* guess */
#define CAM_CTRL_SUCCESS 1
#define CAMERA_SET_PARM_DIMENSION 1
#define CAMERA_SET_PARM_WB 14
#define CAMERA_SET_PARM_EFFECT 15
#define CAMERA_SET_PARM_ANTIBANDING 21
#define CAMERA_STOP_PREVIEW 38
#define CAMERA_START_PREVIEW 39
#define CAMERA_EXIT 43
#define CAMERA_SET_PARM_AUTO_FOCUS 13
#define CAMERA_START_SNAPSHOT 40
#define CAMERA_STOP_SNAPSHOT 41 /* guess, but likely based on previos ording */
#define AF_MODE_AUTO 2
#define CAMERA_AUTO_FOCUS_CANCEL 1 //204
typedef enum
{
CAMERA_WB_MIN_MINUS_1,
CAMERA_WB_AUTO = 1, /* This list must match aeecamera.h */
CAMERA_WB_CUSTOM,
CAMERA_WB_INCANDESCENT,
CAMERA_WB_FLUORESCENT,
CAMERA_WB_DAYLIGHT,
CAMERA_WB_CLOUDY_DAYLIGHT,
CAMERA_WB_TWILIGHT,
CAMERA_WB_SHADE,
CAMERA_WB_MAX_PLUS_1
} camera_wb_type;
typedef enum
{
CAMERA_RSP_CB_SUCCESS, /* Function is accepted */
CAMERA_EXIT_CB_DONE, /* Function is executed */
CAMERA_EXIT_CB_FAILED, /* Execution failed or rejected */
CAMERA_EXIT_CB_DSP_IDLE, /* DSP is in idle state */
CAMERA_EXIT_CB_DSP_ABORT, /* Abort due to DSP failure */
CAMERA_EXIT_CB_ABORT, /* Function aborted */
CAMERA_EXIT_CB_ERROR, /* Failed due to resource */
CAMERA_EVT_CB_FRAME, /* Preview or video frame ready */
CAMERA_EVT_CB_PICTURE, /* Picture frame ready for multi-shot */
CAMERA_STATUS_CB, /* Status updated */
CAMERA_EXIT_CB_FILE_SIZE_EXCEEDED, /* Specified file size not achieved,
encoded file written & returned anyway */
CAMERA_EXIT_CB_BUFFER, /* A buffer is returned */
CAMERA_EVT_CB_SNAPSHOT_DONE,/* Snapshot updated */
CAMERA_CB_MAX
} camera_cb_type;
typedef enum
{
CAMERA_ANTIBANDING_OFF,
CAMERA_ANTIBANDING_60HZ,
CAMERA_ANTIBANDING_50HZ,
CAMERA_ANTIBANDING_AUTO,
CAMERA_MAX_ANTIBANDING,
} camera_antibanding_type;
//typedef struct
//{
// uint32_t timestamp; /* seconds since 1/6/1980 */
// double latitude; /* degrees, WGS ellipsoid */
// double longitude; /* degrees */
// int16_t altitude; /* meters */
//} camera_position_type;
typedef struct
{
unsigned int in1_w;
unsigned int in1_h;
unsigned int out1_w;
unsigned int out1_h;
unsigned int in2_w;
unsigned int in2_h;
unsigned int out2_w;
unsigned int out2_h;
uint8_t update_flag;
} common_crop_t;
typedef struct
{
unsigned short picture_width;
unsigned short picture_height;
unsigned short display_width;
unsigned short display_height;
unsigned short filler;
unsigned short filler2;
unsigned short ui_thumbnail_height;
unsigned short ui_thumbnail_width;
unsigned short filler3;
unsigned short filler4;
unsigned short filler5;
unsigned short filler6;
unsigned short filler7;
unsigned short filler8;
} cam_ctrl_dimension_t;
typedef uint8_t cam_ctrl_type;
typedef uint8_t jpeg_event_t;
typedef unsigned int isp3a_af_mode_t;
struct str_map {
const char *const desc;
int val;
};
namespace android {
class QualcommCameraHardware : 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,
void* user);
virtual void enableMsgType(int32_t msgType);
virtual void disableMsgType(int32_t msgType);
virtual bool msgTypeEnabled(int32_t msgType);
virtual status_t dump(int fd, const Vector<String16>& args) const;
virtual status_t startPreview();
virtual void stopPreview();
virtual bool previewEnabled();
virtual status_t startRecording();
virtual void stopRecording();
virtual bool recordingEnabled();
virtual void releaseRecordingFrame(const sp<IMemory>& mem);
virtual status_t autoFocus();
virtual status_t takePicture();
virtual status_t cancelPicture();
virtual status_t setParameters(const CameraParameters& params);
virtual CameraParameters getParameters() const;
virtual status_t sendCommand(int32_t command, int32_t arg1, int32_t arg2);
virtual void release();
virtual status_t cancelAutoFocus();
static sp<CameraHardwareInterface> createInstance();
static sp<QualcommCameraHardware> getInstance();
void receivePreviewFrame(struct msm_frame_t *frame);
void receiveJpegPicture(void);
void jpeg_set_location();
void receiveJpegPictureFragment(uint8_t *buf, uint32_t size);
void notifyShutter();
private:
QualcommCameraHardware();
virtual ~QualcommCameraHardware();
status_t startPreviewInternal();
void stopPreviewInternal();
friend void *auto_focus_thread(void *user);
void runAutoFocus();
bool native_set_dimension (int camfd);
bool native_jpeg_encode (void);
bool native_set_parm(cam_ctrl_type type, uint16_t length, void *value);
bool native_set_dimension(cam_ctrl_dimension_t *value);
int getParm(const char *parm_str, const str_map *parm_map);
static wp<QualcommCameraHardware> singleton;
/* These constants reflect the number of buffers that libmmcamera requires
for preview and raw, and need to be updated when libmmcamera
changes.
*/
static const int kPreviewBufferCount = 4;
static const int kRawBufferCount = 1;
static const int kJpegBufferCount = 1;
static const int kRawFrameHeaderSize = 0;
//TODO: put the picture dimensions in the CameraParameters object;
CameraParameters mParameters;
int mPreviewHeight;
int mPreviewWidth;
int mRawHeight;
int mRawWidth;
unsigned int frame_size;
bool mCameraRunning;
bool mPreviewInitialized;
bool mRawInitialized;
// This class represents a heap which maintains several contiguous
// buffers. The heap may be backed by pmem (when pmem_pool contains
// the name of a /dev/pmem* file), or by ashmem (when pmem_pool == NULL).
struct MemPool : public RefBase {
MemPool(int buffer_size, int num_buffers,
int frame_size,
int frame_offset,
const char *name);
virtual ~MemPool() = 0;
void completeInitialization();
bool initialized() const {
return mHeap != NULL && mHeap->base() != MAP_FAILED;
}
virtual status_t dump(int fd, const Vector<String16>& args) const;
int mBufferSize;
int mNumBuffers;
int mFrameSize;
int mFrameOffset;
sp<MemoryHeapBase> mHeap;
sp<MemoryBase> *mBuffers;
const char *mName;
};
struct AshmemPool : public MemPool {
AshmemPool(int buffer_size, int num_buffers,
int frame_size,
int frame_offset,
const char *name);
};
struct PmemPool : public MemPool {
PmemPool(const char *pmem_pool,
int control_camera_fd,
msm_pmem_t pmem_type,
int buffer_size, int num_buffers,
int frame_size, int frame_offset,
const char *name);
virtual ~PmemPool();
int mFd;
msm_pmem_t mPmemType;
int mCameraControlFd;
uint32_t mAlignedSize;
struct pmem_region mSize;
};
struct PreviewPmemPool : public PmemPool {
virtual ~PreviewPmemPool();
PreviewPmemPool(int control_fd,
int buffer_size,
int num_buffers,
int frame_size,
int frame_offset,
const char *name);
};
sp<PreviewPmemPool> mPreviewHeap;
sp<PmemPool> mThumbnailHeap;
sp<PmemPool> mRawHeap;
sp<AshmemPool> mJpegHeap;
void startCamera();
bool initPreview();
void deinitPreview();
bool initRaw(bool initJpegHeap);
void deinitRaw();
friend void *jpeg_encoder_thread( void *user );
void runJpegEncodeThread(void *data);
bool mFrameThreadRunning;
Mutex mFrameThreadWaitLock;
Condition mFrameThreadWait;
friend void *frame_thread(void *user);
void runFrameThread(void *data);
bool mShutterPending;
Mutex mShutterLock;
bool mSnapshotThreadRunning;
Mutex mSnapshotThreadWaitLock;
Condition mSnapshotThreadWait;
friend void *snapshot_thread(void *user);
void runSnapshotThread(void *data);
void initDefaultParameters();
void setAntibanding();
void setEffect();
void setWhiteBalance();
Mutex mLock;
bool mReleasedRecordingFrame;
void receiveRawPicture(void);
Mutex mRecordLock;
Mutex mRecordFrameLock;
Condition mRecordWait;
Condition mStateWait;
/* mJpegSize keeps track of the size of the accumulated JPEG. We clear it
when we are about to take a picture, so at any time it contains either
zero, or the size of the last JPEG picture taken.
*/
uint32_t mJpegSize;
notify_callback mNotifyCb;
data_callback mDataCb;
data_callback_timestamp mDataCbTimestamp;
void *mCallbackCookie;
int32_t mMsgEnabled;
unsigned int mPreviewFrameSize;
int mRawSize;
int mJpegMaxSize;
#if DLOPEN_LIBMMCAMERA
void *libmmcamera;
void *libmmcamera_target;
#endif
int mCameraControlFd;
cam_ctrl_dimension_t mDimension;
bool mAutoFocusThreadRunning;
Mutex mAutoFocusThreadLock;
int mAutoFocusFd;
pthread_t mCamConfigThread;
pthread_t mFrameThread;
pthread_t mSnapshotThread;
common_crop_t mCrop;
struct msm_frame_t frames[kPreviewBufferCount];
bool mInPreviewCallback;
bool mCameraRecording;
};
}; // namespace android
#endif

282
libcamera/exifwriter.c Normal file
View File

@ -0,0 +1,282 @@
#include "exifwriter.h"
#include "jhead.h"
#define LOG_TAG "ExifWriter"
#include <utils/Log.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#define TAG_ORIENTATION 0x0112
#define TAG_MAKE 0x010F
#define TAG_MODEL 0x0110
float *float2degminsec( float deg )
{
float *res = malloc( sizeof(float)*3 ) ;
res[0] = floorf( deg ) ;
float min = ( deg - res[0] ) * 60. ;
res[1] = floorf( min ) ;
res[2] = ( min - res[1] ) * 60. ;
return res ;
}
//
// original source from
// http://stackoverflow.com/questions/95727/how-to-convert-floats-to-human-readable-fractions
//
char * float2rationnal( float src )
{
long m[2][2] ;
float x, startx ;
long maxden = 1000 ;
long ai ;
startx = x = src ;
/* initialize matrix */
m[0][0] = m[1][1] = 1;
m[0][1] = m[1][0] = 0;
/* loop finding terms until denom gets too big */
while (m[1][0] * ( ai = (long)x ) + m[1][1] <= maxden) {
long t;
t = m[0][0] * ai + m[0][1];
m[0][1] = m[0][0];
m[0][0] = t;
t = m[1][0] * ai + m[1][1];
m[1][1] = m[1][0];
m[1][0] = t;
if(x==(float)ai) break; // AF: division by zero
x = 1/(x - (float) ai);
if(x>(float)0x7FFFFFFF) break; // AF: representation failure
}
/* now remaining x is between 0 and 1/ai */
/* approx as either 0 or 1/m where m is max that will fit in maxden */
/* first try zero */
LOGV("%ld/%ld, error = %e\n", m[0][0], m[1][0],
startx - ((float) m[0][0] / (float) m[1][0]));
/* now try other possibility */
ai = (maxden - m[1][1]) / m[1][0];
m[0][0] = m[0][0] * ai + m[0][1];
m[1][0] = m[1][0] * ai + m[1][1];
LOGV("%ld/%ld, error = %e\n", m[0][0], m[1][0],
startx - ((float) m[0][0] / (float) m[1][0]));
char *res = (char *)malloc( 256 * sizeof(char) ) ;
snprintf( res, 256, "%ld/%ld", m[0][0], m[1][0] ) ;
return res ;
}
char * coord2degminsec( float src )
{
char *res = (char *)malloc( 256 * sizeof(char) ) ;
float *dms = float2degminsec( fabs(src) ) ;
strcpy( res, float2rationnal(dms[0]) ) ;
strcat( res , "," ) ;
strcat( res , float2rationnal(dms[1]) ) ;
strcat( res , "," ) ;
strcat( res , float2rationnal(dms[2]) ) ;
free( dms ) ;
return res ;
}
static void dump_to_file(const char *fname,
uint8_t *buf, uint32_t size)
{
int nw, cnt = 0;
uint32_t written = 0;
LOGD("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;
}
LOGD("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++;
}
LOGD("done writing %d bytes to file [%s] in %d passes\n",
size, fname, cnt);
close(fd);
}
void writeExif( void *origData, void *destData , int origSize , uint32_t *resultSize, int orientation,camera_position_type *pt ) {
const char *filename = "/data/temp.jpg" ;
dump_to_file( filename, (uint8_t *)origData, origSize ) ;
chmod( filename, S_IRWXU ) ;
ResetJpgfile() ;
memset(&ImageInfo, 0, sizeof(ImageInfo));
ImageInfo.FlashUsed = -1;
ImageInfo.MeteringMode = -1;
ImageInfo.Whitebalance = -1;
int gpsTag = 0 ;
if( pt != NULL ) {
gpsTag = 6 ;
}
ExifElement_t *t = (ExifElement_t *)malloc( sizeof(ExifElement_t)*(3+gpsTag) ) ;
ExifElement_t *it = t ;
// Store file date/time.
(*it).Tag = TAG_ORIENTATION ;
(*it).Format = FMT_USHORT ;
(*it).DataLength = 1 ;
unsigned short v ;
if( orientation == 90 ) {
(*it).Value = "6" ;
} else if( orientation == 180 ) {
(*it).Value = "3" ;
} else {
(*it).Value = "1" ;
}
(*it).GpsTag = FALSE ;
it++;
(*it).Tag = TAG_MAKE ;
(*it).Format = FMT_STRING ;
(*it).Value = "Samsung" ;
(*it).DataLength = 8 ;
(*it).GpsTag = FALSE ;
it++ ;
(*it).Tag = TAG_MODEL ;
(*it).Format = FMT_STRING ;
(*it).Value = "Galaxy with GAOSP" ;
(*it).DataLength = 18 ;
(*it).GpsTag = FALSE ;
if( pt != NULL ) {
LOGD("pt->latitude == %f", pt->latitude ) ;
LOGD("pt->longitude == %f", pt->longitude ) ;
LOGD("pt->altitude == %d", pt->altitude ) ;
it++ ;
(*it).Tag = 0x01 ;
(*it).Format = FMT_STRING ;
if( pt->latitude > 0 ) {
(*it).Value = "N" ;
} else {
(*it).Value = "S" ;
}
(*it).DataLength = 2 ;
(*it).GpsTag = TRUE ;
it++ ;
char *mylat = coord2degminsec( pt->latitude ) ;
(*it).Tag = 0x02 ;
(*it).Format = FMT_URATIONAL ;
(*it).Value = mylat ;
(*it).DataLength = 3 ;
(*it).GpsTag = TRUE ;
free( mylat ) ;
it++ ;
(*it).Tag = 0x03 ;
(*it).Format = FMT_STRING ;
if( (*pt).longitude > 0 ) {
(*it).Value = "E" ;
} else {
(*it).Value = "W" ;
}
(*it).DataLength = 2 ;
(*it).GpsTag = TRUE ;
it++ ;
char *mylong = coord2degminsec( (*pt).longitude ) ;
(*it).Tag = 0x04 ;
(*it).Format = FMT_URATIONAL ;
(*it).Value = mylong ;
(*it).DataLength = 3 ;
(*it).GpsTag = TRUE ;
free( mylong ) ;
it++ ;
(*it).Tag = 0x05 ;
(*it).Format = FMT_USHORT ;
if( (*pt).altitude > 0 ) {
(*it).Value = "0" ;
} else {
(*it).Value = "1" ;
}
(*it).DataLength = 1 ;
(*it).GpsTag = TRUE ;
it++ ;
char *myalt = float2rationnal( fabs( (*pt).altitude ) ) ;
(*it).Tag = 0x06 ;
(*it).Format = FMT_SRATIONAL ;
(*it).Value = myalt ;
(*it).DataLength = 1 ;
(*it).GpsTag = TRUE ;
free( myalt ) ;
}
{
struct stat st;
if (stat(filename, &st) >= 0) {
ImageInfo.FileDateTime = st.st_mtime;
ImageInfo.FileSize = st.st_size;
}
}
strncpy(ImageInfo.FileName, filename, PATH_MAX);
ReadMode_t ReadMode;
ReadMode = READ_METADATA;
ReadMode |= READ_IMAGE;
int res = ReadJpegFile(filename, (ReadMode_t)ReadMode );
create_EXIF( t, 3, gpsTag);
WriteJpegFile(filename);
chmod( filename, S_IRWXU ) ;
DiscardData();
FILE *src ;
src = fopen( filename, "r") ;
fseek( src, 0L, SEEK_END ) ;
(*resultSize) = ftell(src) ;
fseek( src, 0L, SEEK_SET ) ;
int read = fread( destData, 1, (*resultSize), src ) ;
unlink( filename );
}

18
libcamera/exifwriter.h Normal file
View File

@ -0,0 +1,18 @@
#ifndef ANDROID_HARDWARE_EXIFWRITER_H
#define ANDROID_HARDWARE_EXIFWRITER_H
#include <stdint.h>
typedef struct
{
uint32_t timestamp; /* seconds since 1/6/1980 */
double latitude; /* degrees, WGS ellipsoid */
double longitude; /* degrees */
int16_t altitude; /* meters */
} camera_position_type;
void writeExif( void *origData, void *destData , int origSize , uint32_t *resultSize, int orientation, camera_position_type *pt) ;
#endif

434
libcamera/msm_camera.h Normal file
View File

@ -0,0 +1,434 @@
/*
* Copyright (C) 2008-2009 QUALCOMM Incorporated.
*/
#ifndef __LINUX_MSM_CAMERA_H
#define __LINUX_MSM_CAMERA_H
#ifdef __KERNEL__
#include <linux/types.h>
#include <asm/sizes.h>
#include <linux/ioctl.h>
#else
#include <stdint.h>
#include <stdio.h>
#include <sys/ioctl.h>
#endif
#include <linux/msm_adsp.h>
#ifdef __KERNEL__
#define CDBG_INFO(fmt, args...) printk(KERN_INFO "msm_camera: " fmt, ##args)
#define CDBG_ERR(fmt, args...) printk(KERN_INFO "msm_camera error: " fmt, ##args)
#define CDBG_WARING(fmt, args...) printk(KERN_INFO "msm_camera waring: " fmt, ##args)
#endif
#define MSM_CAM_IOCTL_MAGIC 'm'
#define MSM_CAM_IOCTL_GET_SENSOR_INFO \
_IOR(MSM_CAM_IOCTL_MAGIC, 1, struct msm_camsensor_info_t *)
#define MSM_CAM_IOCTL_REGISTER_PMEM \
_IOW(MSM_CAM_IOCTL_MAGIC, 2, struct msm_pmem_info_t *)
#define MSM_CAM_IOCTL_UNREGISTER_PMEM \
_IOW(MSM_CAM_IOCTL_MAGIC, 3, unsigned)
#define MSM_CAM_IOCTL_CTRL_COMMAND \
_IOW(MSM_CAM_IOCTL_MAGIC, 4, struct msm_ctrl_cmd_t *)
#define MSM_CAM_IOCTL_CONFIG_VFE \
_IOW(MSM_CAM_IOCTL_MAGIC, 5, struct msm_camera_vfe_cfg_cmd_t *)
#define MSM_CAM_IOCTL_GET_STATS \
_IOR(MSM_CAM_IOCTL_MAGIC, 6, struct msm_camera_stats_event_ctrl_t *)
#define MSM_CAM_IOCTL_GETFRAME \
_IOR(MSM_CAM_IOCTL_MAGIC, 7, struct msm_camera_get_frame_t *)
#define MSM_CAM_IOCTL_ENABLE_VFE \
_IOW(MSM_CAM_IOCTL_MAGIC, 8, struct camera_enable_cmd_t *)
#define MSM_CAM_IOCTL_CTRL_CMD_DONE \
_IOW(MSM_CAM_IOCTL_MAGIC, 9, struct camera_cmd_t *)
#define MSM_CAM_IOCTL_CONFIG_CMD \
_IOW(MSM_CAM_IOCTL_MAGIC, 10, struct camera_cmd_t *)
#define MSM_CAM_IOCTL_DISABLE_VFE \
_IOW(MSM_CAM_IOCTL_MAGIC, 11, struct camera_enable_cmd_t *)
#define MSM_CAM_IOCTL_PAD_REG_RESET2 \
_IOW(MSM_CAM_IOCTL_MAGIC, 12, struct camera_enable_cmd_t *)
#define MSM_CAM_IOCTL_VFE_APPS_RESET \
_IOW(MSM_CAM_IOCTL_MAGIC, 13, struct camera_enable_cmd_t *)
#define MSM_CAM_IOCTL_RELEASE_FRAMEE_BUFFER \
_IOW(MSM_CAM_IOCTL_MAGIC, 14, struct camera_enable_cmd_t *)
#define MSM_CAM_IOCTL_RELEASE_STATS_BUFFER \
_IOW(MSM_CAM_IOCTL_MAGIC, 15, struct msm_stats_buf_t *)
#define MSM_CAM_IOCTL_AXI_CONFIG \
_IOW(MSM_CAM_IOCTL_MAGIC, 16, struct msm_camera_vfe_cfg_cmd_t *)
#define MSM_CAM_IOCTL_GET_PICTURE \
_IOW(MSM_CAM_IOCTL_MAGIC, 17, struct msm_camera_ctrl_cmd_t *)
#define MSM_CAM_IOCTL_SET_CROP \
_IOW(MSM_CAM_IOCTL_MAGIC, 18, struct crop_info_t *)
#define MSM_CAM_IOCTL_PICT_PP \
_IOW(MSM_CAM_IOCTL_MAGIC, 19, uint8_t *)
#define MSM_CAM_IOCTL_PICT_PP_DONE \
_IOW(MSM_CAM_IOCTL_MAGIC, 20, struct msm_snapshot_pp_status_t *)
#define MSM_CAM_IOCTL_SENSOR_IO_CFG \
_IOW(MSM_CAM_IOCTL_MAGIC, 21, struct sensor_cfg_data_t *)
#define MSM_CAM_IOCTL_FLASH_LED_CFG \
_IOW(MSM_CAM_IOCTL_MAGIC, 22, enum msm_camera_led_state_t *)
#define MAX_SENSOR_NUM 3
#define MAX_SENSOR_NAME 32
/*****************************************************
* enum
*****************************************************/
enum msm_camera_update_t {
MSM_CAM_CTRL_CMD_DONE,
MSM_CAM_SENSOR_VFE_CMD,
};
/*****************************************************
* structure
*****************************************************/
/* define five type of structures for userspace <==> kernel
* space communication:
* command 1 - 2 are from userspace ==> kernel
* command 3 - 4 are from kernel ==> userspace
*
* 1. control command: control command(from control thread),
* control status (from config thread);
*/
struct msm_ctrl_cmd_t {
int timeout_ms;
uint16_t type;
uint16_t length;
void *value;
uint16_t status;
};
struct msm_vfe_evt_msg_t {
unsigned short type; /* 1 == event (RPC), 0 == message (adsp) */
unsigned short msg_id;
unsigned int len; /* size in, number of bytes out */
unsigned char *data;
};
enum msm_camera_resp_t {
MSM_CAM_RESP_CTRL,
MSM_CAM_RESP_STAT_EVT_MSG,
MSM_CAM_RESP_V4L2,
MSM_CAM_RESP_MAX
};
/* this one is used to send ctrl/status up to config thread */
struct msm_stats_event_ctrl {
/* 0 - ctrl_cmd from control thread,
* 1 - stats/event kernel,
* 2 - V4L control or read request */
enum msm_camera_resp_t resptype;
int timeout_ms;
struct msm_ctrl_cmd_t ctrl_cmd;
/* struct vfe_event_t stats_event; */
struct msm_vfe_evt_msg_t stats_event;
};
/* 2. config command: config command(from config thread); */
struct msm_camera_cfg_cmd_t {
/* what to config:
* 1 - sensor config, 2 - vfe config */
uint16_t cfg_type;
/* sensor config type */
uint16_t cmd_type;
uint16_t queue;
uint16_t length;
void *value;
};
enum cfg_cmd_type_t {
CMD_GENERAL,
CMD_AXI_CFG_OUT1,
CMD_AXI_CFG_SNAP_O1_AND_O2,
CMD_AXI_CFG_OUT2,
CMD_PICT_T_AXI_CFG,
CMD_PICT_M_AXI_CFG,
CMD_RAW_PICT_AXI_CFG,
CMD_STATS_AXI_CFG,
CMD_STATS_AF_AXI_CFG,
CMD_FRAME_BUF_RELEASE,
CMD_PREV_BUF_CFG,
CMD_SNAP_BUF_RELEASE,
CMD_SNAP_BUF_CFG,
CMD_STATS_DISABLE,
CMD_STATS_ENABLE,
CMD_STATS_AF_ENABLE,
CMD_STATS_BUF_RELEASE,
CMD_STATS_AF_BUF_RELEASE,
UPDATE_STATS_INVALID
};
/* vfe config command: config command(from config thread)*/
struct msm_vfe_cfg_cmd_t {
enum cfg_cmd_type_t cmd_type;
uint16_t length;
void *value;
};
struct camera_enable_cmd_t {
char *name;
uint16_t length;
};
enum msm_pmem_t {
MSM_PMEM_OUTPUT1,
MSM_PMEM_OUTPUT2,
MSM_PMEM_OUTPUT1_OUTPUT2,
MSM_PMEM_THUMBNAIL,
MSM_PMEM_MAINIMG,
MSM_PMEM_RAW_MAINIMG,
MSM_PMEM_AEC_AWB,
MSM_PMEM_AF,
MSM_PMEM_MAX
};
enum msm_camera_out_frame_t {
FRAME_PREVIEW_OUTPUT1,
FRAME_PREVIEW_OUTPUT2,
FRAME_SNAPSHOT,
FRAME_THUMBAIL,
FRAME_RAW_SNAPSHOT,
FRAME_MAX
};
struct msm_pmem_info_t {
enum msm_pmem_t type;
int fd;
void *vaddr;
uint32_t y_off;
uint32_t cbcr_off;
uint8_t active;
};
struct outputCfg_t {
uint32_t height;
uint32_t width;
uint32_t window_height_firstline;
uint32_t window_height_lastline;
};
enum vfeoutput_mode_t {
OUTPUT_1,
OUTPUT_2,
OUTPUT_1_AND_2,
CAMIF_TO_AXI_VIA_OUTPUT_2,
OUTPUT_1_AND_CAMIF_TO_AXI_VIA_OUTPUT_2,
OUTPUT_2_AND_CAMIF_TO_AXI_VIA_OUTPUT_1,
LAST_AXI_OUTPUT_MODE_ENUM = OUTPUT_2_AND_CAMIF_TO_AXI_VIA_OUTPUT_1
};
enum msm_frame_path {
MSM_FRAME_PREV_1,
MSM_FRAME_PREV_2,
MSM_FRAME_ENC,
};
struct msm_frame_t {
enum msm_frame_path path;
unsigned long buffer;
uint32_t y_off;
uint32_t cbcr_off;
int fd;
void *cropinfo;
int croplen;
};
enum stat_type {
STAT_AEAW,
STAT_AF,
STAT_MAX,
};
struct msm_stats_buf_t {
enum stat_type type;
unsigned long buffer;
int fd;
};
enum msm_v4l2_ctrl_t {
MSM_V4L2_VID_CAP_TYPE,
MSM_V4L2_STREAM_ON,
MSM_V4L2_STREAM_OFF,
MSM_V4L2_SNAPSHOT,
MSM_V4L2_QUERY_CTRL,
MSM_V4L2_GET_CTRL,
MSM_V4L2_SET_CTRL,
MSM_V4L2_QUERY,
MSM_V4L2_MAX
};
struct crop_info_t {
void *info;
int len;
};
struct msm_postproc_t {
int ftnum;
struct msm_frame_t fthumnail;
int fmnum;
struct msm_frame_t fmain;
};
struct msm_snapshot_pp_status_t {
void *status;
};
enum sensor_cfg_t {
CFG_SET_MODE,
CFG_SET_EFFECT,
CFG_START,
CFG_PWR_UP,
CFG_PWR_DOWN,
CFG_WRITE_EXPOSURE_GAIN,
CFG_SET_DEFAULT_FOCUS,
CFG_MOVE_FOCUS,
CFG_REGISTER_TO_REAL_GAIN,
CFG_REAL_TO_REGISTER_GAIN,
CFG_SET_FPS,
CFG_SET_PICT_FPS,
CFG_SET_BRIGHTNESS,
CFG_SET_CONTRAST,
CFG_SET_ZOOM,
CFG_SET_EXPOSURE_MODE,
CFG_SET_WB,
CFG_SET_ANTIBANDING,
CFG_SET_EXP_GAIN,
CFG_SET_PICT_EXP_GAIN,
CFG_SET_LENS_SHADING,
CFG_GET_PICT_FPS,
CFG_GET_PREV_L_PF,
CFG_GET_PREV_P_PL,
CFG_GET_PICT_L_PF,
CFG_GET_PICT_P_PL,
CFG_GET_PICT_MAX_EXP_LC,
CFG_MAX
};
enum sensor_move_focus_t {
MOVE_NEAR,
MOVE_FAR
};
enum sensor_mode_t {
SENSOR_PREVIEW_MODE,
SENSOR_SNAPSHOT_MODE,
SENSOR_RAW_SNAPSHOT_MODE
};
enum sensor_resolution_t {
SENSOR_QTR_SIZE,
SENSOR_FULL_SIZE,
SENSOR_INVALID_SIZE,
};
enum camera_effect_t {
CAMERA_EFFECT_MIN_MINUS_1,
CAMERA_EFFECT_OFF = 1, /* This list must match aeecamera.h */
CAMERA_EFFECT_MONO,
CAMERA_EFFECT_NEGATIVE,
CAMERA_EFFECT_SOLARIZE,
CAMERA_EFFECT_PASTEL,
CAMERA_EFFECT_MOSAIC,
CAMERA_EFFECT_RESIZE,
CAMERA_EFFECT_SEPIA,
CAMERA_EFFECT_POSTERIZE,
CAMERA_EFFECT_WHITEBOARD,
CAMERA_EFFECT_BLACKBOARD,
CAMERA_EFFECT_AQUA,
CAMERA_EFFECT_MAX_PLUS_1
};
struct sensor_pict_fps {
uint16_t prevfps;
uint16_t pictfps;
};
struct exp_gain_cfg {
uint16_t gain;
uint32_t line;
};
struct focus_cfg {
int32_t steps;
enum sensor_move_focus_t dir;
};
struct fps_cfg {
uint16_t f_mult;
uint16_t fps_div;
uint32_t pict_fps_div;
};
enum msm_camera_led_state_t {
MSM_LED_OFF,
MSM_LED_LOW,
MSM_LED_HIGH
};
struct sensor_cfg_data_t {
enum sensor_cfg_t cfgtype;
enum sensor_mode_t mode;
enum sensor_resolution_t rs;
union {
int8_t effect;
uint8_t lens_shading;
uint16_t prevl_pf;
uint16_t prevp_pl;
uint16_t pictl_pf;
uint16_t pictp_pl;
uint32_t pict_max_exp_lc;
uint16_t p_fps;
struct sensor_pict_fps gfps;
struct exp_gain_cfg exp_gain;
struct focus_cfg focus;
struct fps_cfg fps;
} cfg;
};
enum sensor_get_info_t {
GET_NAME,
GET_PREVIEW_LINE_PER_FRAME,
GET_PREVIEW_PIXELS_PER_LINE,
GET_SNAPSHOT_LINE_PER_FRAME,
GET_SNAPSHOT_PIXELS_PER_LINE,
GET_SNAPSHOT_FPS,
GET_SNAPSHOT_MAX_EP_LINE_CNT,
};
struct msm_camsensor_info_t {
char name[MAX_SENSOR_NAME];
int8_t flash_enabled;
};
#endif /* __LINUX_MSM_CAMERA_H */

3
tattoo.mk
View File

@ -40,6 +40,7 @@ PRODUCT_PACKAGES += \
libmm-omxcore \
wlan_loader \
tiwlan.ini \
libcamera \
librpc \
dhcpcd.conf
@ -119,7 +120,7 @@ PRODUCT_PROPERTY_OVERRIDES += \
# Enable JIT by default
PRODUCT_PROPERTY_OVERRIDES += \
dalvik.vm.execution-mode=int:jit
dalvik.vm.execution-mode=int:fast
# VM heap size
PRODUCT_PROPERTY_OVERRIDES += \