camera: remove old HAL
Change-Id: Ie603ea384b96131492d5b9373782ef5248486e0e
Signed-off-by: Iliyan Malchev <malchev@google.com>
diff --git a/camera/QCamera/Android.mk b/camera/QCamera/Android.mk
deleted file mode 100755
index e45365e..0000000
--- a/camera/QCamera/Android.mk
+++ /dev/null
@@ -1,3 +0,0 @@
-ifeq ($(TARGET_ARCH),arm)
-# include $(call all-subdir-makefiles)
-endif
diff --git a/camera/QCamera/HAL/Android.mk b/camera/QCamera/HAL/Android.mk
deleted file mode 100755
index 5097dae..0000000
--- a/camera/QCamera/HAL/Android.mk
+++ /dev/null
@@ -1,3 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(LOCAL_PATH)/core/Android.mk
-#include $(LOCAL_PATH)/test/Android.mk
diff --git a/camera/QCamera/HAL/core/Android.mk b/camera/QCamera/HAL/core/Android.mk
deleted file mode 100755
index df81ed4..0000000
--- a/camera/QCamera/HAL/core/Android.mk
+++ /dev/null
@@ -1,118 +0,0 @@
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-DLOPEN_LIBMMCAMERA:=0
-
-LOCAL_CFLAGS:= -DDLOPEN_LIBMMCAMERA=$(DLOPEN_LIBMMCAMERA)
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
- LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_CFLAGS += -DCAMERA_ION_HEAP_ID=ION_CP_MM_HEAP_ID # 8660=SMI, Rest=EBI
-LOCAL_CFLAGS += -DCAMERA_ZSL_ION_HEAP_ID=ION_CP_MM_HEAP_ID
-
-LOCAL_CFLAGS+= -DHW_ENCODE
-LOCAL_CFLAGS+= -DUSE_NEON_CONVERSION
-
-ifeq ($(call is-board-platform,msm8974),true)
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_MM_HEAP
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP
- LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
- LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=9
-else ifeq ($(call is-board-platform,msm8226),true)
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_MM_HEAP
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP
- LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
- LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=9
-else ifeq ($(call is-board-platform,msm8960),true)
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_MM_HEAP
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP
- LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
- LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=5
-else ifeq ($(call is-chipset-prefix-in-board-platform,msm8660),true)
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP # Don't Care
- LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID # EBI
- LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
- LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=5
-else
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP # Don't Care
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=GRALLOC_USAGE_PRIVATE_UNCACHED #uncached
- LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_CAMERA_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_CAMERA_HEAP_ID
- LOCAL_CFLAGS += -DNUM_RECORDING_BUFFERS=5
-endif
-
-LOCAL_HAL_FILES := \
- src/QCameraHAL.cpp \
- src/QCameraHWI_Parm.cpp \
- src/QCameraHWI.cpp \
- src/QCameraHWI_Preview.cpp \
- src/QCameraHWI_Record.cpp \
- src/QCameraHWI_Still.cpp \
- src/QCameraHWI_Rdi.cpp \
- src/QCameraHWI_Mem.cpp \
- src/QCameraParameters.cpp\
- src/QCameraStream.cpp\
- ../usbcamcore/src/QualcommUsbCamera.cpp\
- ../usbcamcore/src/QCameraMjpegDecode.cpp\
- ../usbcamcore/src/QCameraUsbParm.cpp
-
-LOCAL_HAL_WRAPPER_FILES := ../wrapper/QualcommCamera.cpp
-
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/../wrapper \
- $(LOCAL_PATH)/inc \
- $(LOCAL_PATH)/../usbcamcore/inc\
- $(LOCAL_PATH)/../../stack/mm-camera-interface/inc \
- $(LOCAL_PATH)/../../stack/mm-jpeg-interface/inc \
- $(LOCAL_PATH)/../../../ \
- $(TARGET_OUT_INTERMEDIATES)/include/mm-camera-interface \
-# $(TARGET_OUT_INTERMEDIATES)/include/mm-jpeg-interface\
-
-# may need remove this includes
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-camera
-#LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-still
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-still/jpeg
-#end
-
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/media
-LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
-
-LOCAL_C_INCLUDES += hardware/qcom/display/libgralloc \
- hardware/qcom/display/libgenlock \
- hardware/qcom/media/libstagefrighthw
-
-# if debug service layer and up , use stub camera!
-LOCAL_C_INCLUDES += \
- frameworks/base/services/camera/libcameraservice
-
-LOCAL_SRC_FILES := \
- $(LOCAL_HAL_WRAPPER_FILES) \
- $(LOCAL_HAL_FILES)
-
-LOCAL_SHARED_LIBRARIES := libutils libui libcamera_client liblog libcutils libmmjpeg
-LOCAL_SHARED_LIBRARIES += libmmcamera_interface
-LOCAL_SHARED_LIBRARIES += libgenlock libbinder libmmjpeg_interface libhardware
-
-LOCAL_CFLAGS += -include bionic/libc/kernel/common/linux/socket.h
-
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-LOCAL_MODULE:= camera.$(TARGET_BOARD_PLATFORM)
-LOCAL_MODULE_TAGS := optional
-include $(BUILD_SHARED_LIBRARY)
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
-
diff --git a/camera/QCamera/HAL/core/inc/QCameraHAL.h b/camera/QCamera/HAL/core/inc/QCameraHAL.h
deleted file mode 100755
index 45cb084..0000000
--- a/camera/QCamera/HAL/core/inc/QCameraHAL.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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_QCAMERA_HAL_H
-#define ANDROID_HARDWARE_QCAMERA_HAL_H
-
-
-#include "QCameraHWI.h"
-
-extern "C" {
-#include <mm_camera_interface.h>
-}
-namespace android {
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" void *
- QCameraHAL_openCameraHardware(int cameraId, int mode);
-extern "C" int HAL_getNumberOfCameras();
-extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo);
-
-}; // namespace android
-
-#endif
-
diff --git a/camera/QCamera/HAL/core/inc/QCameraHWI.h b/camera/QCamera/HAL/core/inc/QCameraHWI.h
deleted file mode 100755
index ff43244..0000000
--- a/camera/QCamera/HAL/core/inc/QCameraHWI.h
+++ /dev/null
@@ -1,966 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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_QCAMERA_HARDWARE_INTERFACE_H
-#define ANDROID_HARDWARE_QCAMERA_HARDWARE_INTERFACE_H
-
-
-#include <utils/threads.h>
-#include <hardware/camera.h>
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <camera/Camera.h>
-#include <camera/QCameraParameters.h>
-#include <system/window.h>
-#include <system/camera.h>
-#include <hardware/camera.h>
-#include <gralloc_priv.h>
-#include <QComOMXMetadata.h>
-#include <hardware/power.h>
-
-extern "C" {
-#include <linux/android_pmem.h>
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include <camera_defs_i.h>
-#include <mm_camera_interface.h>
-#include "mm_jpeg_interface.h"
-} //extern C
-
-#include "QCameraHWI_Mem.h"
-#include "QCameraStream.h"
-
-//Error codes
-#define NOT_FOUND -1
-#define MAX_ZOOM_RATIOS 62
-
-#ifdef Q12
-#undef Q12
-#endif
-
-#define Q12 4096
-#define QCAMERA_PARM_ENABLE 1
-#define QCAMERA_PARM_DISABLE 0
-#define PREVIEW_TBL_MAX_SIZE 14
-#define VIDEO_TBL_MAX_SIZE 14
-#define THUMB_TBL_MAX_SIZE 16
-#define HFR_TBL_MAX_SIZE 2
-
-#define DEFAULT_STREAM_WIDTH 320
-#define DEFAULT_STREAM_HEIGHT 240
-#define DEFAULT_LIVESHOT_WIDTH 2592
-#define DEFAULT_LIVESHOT_HEIGHT 1944
-
-//for histogram stats
-#define HISTOGRAM_STATS_SIZE 257
-#define NUM_HISTOGRAM_BUFFERS 3
-
-struct str_map {
- const char *const desc;
- int val;
-};
-
-struct preview_format_info_t {
- int Hal_format;
- cam_format_t mm_cam_format;
- cam_pad_format_t padding;
- int num_planar;
-};
-
-
-typedef enum {
- CAMERA_STATE_UNINITED,
- CAMERA_STATE_READY,
- CAMERA_STATE_MAX
-} HAL_camera_state_type_t;
-
-enum {
- BUFFER_NOT_OWNED,
- BUFFER_UNLOCKED,
- BUFFER_LOCKED,
-};
-
-typedef enum {
- HAL_DUMP_FRM_PREVIEW = 1,
- HAL_DUMP_FRM_VIDEO = 1<<1,
- HAL_DUMP_FRM_MAIN = 1<<2,
- HAL_DUMP_FRM_THUMBNAIL = 1<<3,
- HAL_DUMP_FRM_RDI = 1<<4,
-
- /*8 bits mask*/
- HAL_DUMP_FRM_MAX = 1 << 8
-} HAL_cam_dump_frm_type_t;
-
-
-typedef enum {
- HAL_CAM_MODE_ZSL = 1,
-
- /*add new entry before and update the max entry*/
- HAL_CAM_MODE_MAX = HAL_CAM_MODE_ZSL << 1,
-} qQamera_mode_t;
-
-
-typedef enum {
- MM_CAMERA_OK,
- MM_CAMERA_E_GENERAL,
- MM_CAMERA_E_NO_MEMORY,
- MM_CAMERA_E_NOT_SUPPORTED,
- MM_CAMERA_E_INVALID_INPUT,
- MM_CAMERA_E_INVALID_OPERATION, /* 5 */
- MM_CAMERA_E_ENCODE,
- MM_CAMERA_E_BUFFER_REG,
- MM_CAMERA_E_PMEM_ALLOC,
- MM_CAMERA_E_CAPTURE_FAILED,
- MM_CAMERA_E_CAPTURE_TIMEOUT, /* 10 */
-}mm_camera_status_type_t;
-
-
-
-#define HAL_DUMP_FRM_MASK_ALL ( HAL_DUMP_FRM_PREVIEW + HAL_DUMP_FRM_VIDEO + \
- HAL_DUMP_FRM_MAIN + HAL_DUMP_FRM_THUMBNAIL)
-#define QCAMERA_HAL_PREVIEW_STOPPED 0
-#define QCAMERA_HAL_PREVIEW_START 1
-#define QCAMERA_HAL_PREVIEW_STARTED 2
-#define QCAMERA_HAL_RECORDING_STARTED 3
-#define QCAMERA_HAL_TAKE_PICTURE 4
-
-typedef struct {
- int fd;
- int main_ion_fd;
- struct ion_handle * handle;
- uint32_t size;
-} QCameraHalMemInfo_t;
-
-typedef struct {
- int buffer_count;
- buffer_handle_t *buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
- struct private_handle_t *private_buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
- int stride[MM_CAMERA_MAX_NUM_FRAMES];
- uint32_t addr_offset[MM_CAMERA_MAX_NUM_FRAMES];
- uint8_t local_flag[MM_CAMERA_MAX_NUM_FRAMES];
- camera_memory_t *camera_memory[MM_CAMERA_MAX_NUM_FRAMES];
- QCameraHalMemInfo_t mem_info[MM_CAMERA_MAX_NUM_FRAMES];
-} QCameraHalMemory_t;
-
-
-typedef struct {
- int buffer_count;
- int local_flag[MM_CAMERA_MAX_NUM_FRAMES];
- camera_memory_t * camera_memory[MM_CAMERA_MAX_NUM_FRAMES];
- camera_memory_t * metadata_memory[MM_CAMERA_MAX_NUM_FRAMES];
- QCameraHalMemInfo_t mem_info[MM_CAMERA_MAX_NUM_FRAMES];
-} QCameraHalHeap_t;
-
-typedef struct {
- camera_memory_t * camera_memory[NUM_HISTOGRAM_BUFFERS];
- QCameraHalMemInfo_t mem_info[NUM_HISTOGRAM_BUFFERS];
- int active;
-} QCameraStatHeap_t;
-
-typedef struct {
- int32_t msg_type;
- int32_t ext1;
- int32_t ext2;
- void *cookie;
-} argm_notify_t;
-
-typedef struct {
- int32_t msg_type;
- camera_memory_t *data;
- unsigned int index;
- camera_frame_metadata_t *metadata;
- void *cookie;
- void *user_data;
-} argm_data_cb_t;
-
-typedef struct {
- camera_notify_callback notifyCb;
- camera_data_callback dataCb;
- argm_notify_t argm_notify;
- argm_data_cb_t argm_data_cb;
-} app_notify_cb_t;
-
-/* camera_area_t
- * rectangle with weight to store the focus and metering areas.
- * x1, y1, x2, y2: from -1000 to 1000
- * weight: 0 to 1000
- */
-typedef struct {
- int x1, y1, x2, y2;
- int weight;
-} camera_area_t;
-
-//EXIF globals
-static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 }; // "ASCII\0\0\0"
-static const char ExifUndefinedPrefix[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // "\0\0\0\0\0\0\0\0"
-
-//EXIF detfines
-#define MAX_EXIF_TABLE_ENTRIES 14
-#define GPS_PROCESSING_METHOD_SIZE 101
-#define FOCAL_LENGTH_DECIMAL_PRECISION 100
-#define EXIF_ASCII_PREFIX_SIZE 8 //(sizeof(ExifAsciiPrefix))
-
-typedef struct{
- //GPS tags
- rat_t latitude[3];
- rat_t longitude[3];
- char lonRef[2];
- char latRef[2];
- rat_t altitude;
- rat_t gpsTimeStamp[3];
- char gpsDateStamp[20];
- char gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE+GPS_PROCESSING_METHOD_SIZE];
- //Other tags
- char dateTime[20];
- rat_t focalLength;
- uint16_t flashMode;
- uint16_t isoSpeed;
-
- bool mAltitude;
- bool mLongitude;
- bool mLatitude;
- bool mTimeStamp;
- bool mGpsProcess;
-
- int mAltitude_ref;
- long mGPSTimestamp;
-
-} exif_values_t;
-
-typedef struct {
- jpeg_job_status_t status;
- uint8_t thumbnailDroppedFlag;
- uint32_t client_hdl;
- uint32_t jobId;
- uint8_t* out_data;
- uint32_t data_size;
- mm_camera_super_buf_t* src_frame;
-} camera_jpeg_data_t;
-
-typedef struct {
- mm_camera_super_buf_t* src_frame;
- void* userdata;
-} camera_jpeg_encode_cookie_t;
-
-namespace android {
-
-class QCameraStream;
-
-typedef void (*release_data_fn)(void* data, void *user_data);
-
-class QCameraQueue {
-public:
- QCameraQueue();
- QCameraQueue(release_data_fn data_rel_fn, void *user_data);
- virtual ~QCameraQueue();
- bool enqueue(void *data);
- bool pri_enqueue(void *data);
- void flush();
- void* dequeue();
- bool is_empty();
-private:
- typedef struct {
- struct cam_list list;
- void* data;
- } camera_q_node;
-
- camera_q_node mhead; /* dummy head */
- uint32_t msize;
- pthread_mutex_t mlock;
- release_data_fn mdata_rel_fn;
- void * muser_data;
-};
-
-typedef enum
-{
- CAMERA_CMD_TYPE_NONE,
- CAMERA_CMD_TYPE_START_DATA_PROC,
- CAMERA_CMD_TYPE_STOP_DATA_PROC,
- CAMERA_CMD_TYPE_DO_NEXT_JOB,
- CAMERA_CMD_TYPE_EXIT,
- CAMERA_CMD_TYPE_MAX
-} camera_cmd_type_t;
-
-typedef struct snap_hdr_record_t_ {
- bool hdr_on;
- int num_frame;
- int num_raw_received;
- /*in terms of 2^*(n/6), e.g 6 means (1/2)x, whole 12 means 4x*/
- int exp[MAX_HDR_EXP_FRAME_NUM];
- mm_camera_super_buf_t *recvd_frame[MAX_HDR_EXP_FRAME_NUM];
-} snap_hdr_record_t;
-
-typedef struct {
- camera_cmd_type_t cmd;
-} camera_cmd_t;
-
-class QCameraCmdThread {
-public:
- QCameraCmdThread();
- ~QCameraCmdThread();
-
- int32_t launch(void *(*start_routine)(void *), void* user_data);
- int32_t exit();
- int32_t sendCmd(camera_cmd_type_t cmd, uint8_t sync_cmd, uint8_t priority);
- camera_cmd_type_t getCmd();
-
- QCameraQueue cmd_queue; /* cmd queue */
- pthread_t cmd_pid; /* cmd thread ID */
- sem_t cmd_sem; /* semaphore for cmd thread */
- sem_t sync_sem; /* semaphore for synchronized call signal */
-};
-
-class QCameraHardwareInterface : public virtual RefBase {
-public:
-
- QCameraHardwareInterface(int cameraId, int mode);
-
- /** Set the ANativeWindow to which preview frames are sent */
- int setPreviewWindow(preview_stream_ops_t* window);
-
- /** Set the notification and data callbacks */
- void setCallbacks(camera_notify_callback notify_cb,
- camera_data_callback data_cb,
- camera_data_timestamp_callback data_cb_timestamp,
- camera_request_memory get_memory,
- void *user);
-
- /**
- * The following three functions all take a msg_type, which is a bitmask of
- * the messages defined in include/ui/Camera.h
- */
-
- /**
- * Enable a message, or set of messages.
- */
- void enableMsgType(int32_t msg_type);
-
- /**
- * Disable a message, or a set of messages.
- *
- * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
- * HAL should not rely on its client to call releaseRecordingFrame() to
- * release video recording frames sent out by the cameral HAL before and
- * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
- * clients must not modify/access any video recording frame after calling
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
- */
- void disableMsgType(int32_t msg_type);
-
- /**
- * Query whether a message, or a set of messages, is enabled. Note that
- * this is operates as an AND, if any of the messages queried are off, this
- * will return false.
- */
- int msgTypeEnabled(int32_t msg_type);
-
- /**
- * Start preview mode.
- */
- int startPreview();
- int startPreview2();
-
- /**
- * Stop a previously started preview.
- */
- void stopPreview();
-
- /**
- * Returns true if preview is enabled.
- */
- int previewEnabled();
-
-
- /**
- * Request the camera HAL to store meta data or real YUV data in the video
- * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
- * it is not called, the default camera HAL behavior is to store real YUV
- * data in the video buffers.
- *
- * This method should be called before startRecording() in order to be
- * effective.
- *
- * If meta data is stored in the video buffers, it is up to the receiver of
- * the video buffers to interpret the contents and to find the actual frame
- * data with the help of the meta data in the buffer. How this is done is
- * outside of the scope of this method.
- *
- * Some camera HALs may not support storing meta data in the video buffers,
- * but all camera HALs should support storing real YUV data in the video
- * buffers. If the camera HAL does not support storing the meta data in the
- * video buffers when it is requested to do do, INVALID_OPERATION must be
- * returned. It is very useful for the camera HAL to pass meta data rather
- * than the actual frame data directly to the video encoder, since the
- * amount of the uncompressed frame data can be very large if video size is
- * large.
- *
- * @param enable if true to instruct the camera HAL to store
- * meta data in the video buffers; false to instruct
- * the camera HAL to store real YUV data in the video
- * buffers.
- *
- * @return OK on success.
- */
- int storeMetaDataInBuffers(int enable);
-
- /**
- * Start record mode. When a record image is available, a
- * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding
- * frame. Every record frame must be released by a camera HAL client via
- * releaseRecordingFrame() before the client calls
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
- * responsibility to manage the life-cycle of the video recording frames,
- * and the client must not modify/access any video recording frames.
- */
- int startRecording();
-
- /**
- * Stop a previously started recording.
- */
- void stopRecording();
-
- /**
- * Returns true if recording is enabled.
- */
- int recordingEnabled();
-
- /**
- * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
- *
- * It is camera HAL client's responsibility to release video recording
- * frames sent out by the camera HAL before the camera HAL receives a call
- * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
- * responsibility to manage the life-cycle of the video recording frames.
- */
- void releaseRecordingFrame(const void *opaque);
-
- /**
- * Start auto focus, the notification callback routine is called with
- * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be
- * called again if another auto focus is needed.
- */
- int autoFocus();
-
- /**
- * Cancels auto-focus function. If the auto-focus is still in progress,
- * this function will cancel it. Whether the auto-focus is in progress or
- * not, this function will return the focus position to the default. If
- * the camera does not support auto-focus, this is a no-op.
- */
- int cancelAutoFocus();
-
- /**
- * Take a picture.
- */
- int takePicture();
-
- /**
- * Cancel a picture that was started with takePicture. Calling this method
- * when no picture is being taken is a no-op.
- */
- int cancelPicture();
-
- /**
- * Set the camera parameters. This returns BAD_VALUE if any parameter is
- * invalid or not supported.
- */
- int setParameters(const char *parms);
-
- //status_t setParameters(const QCameraParameters& params);
- /** Retrieve the camera parameters. The buffer returned by the camera HAL
- must be returned back to it with put_parameters, if put_parameters
- is not NULL.
- */
- int getParameters(char **parms);
-
- /** The camera HAL uses its own memory to pass us the parameters when we
- call get_parameters. Use this function to return the memory back to
- the camera HAL, if put_parameters is not NULL. If put_parameters
- is NULL, then you have to use free() to release the memory.
- */
- void putParameters(char *);
-
- /**
- * Send command to camera driver.
- */
- int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
-
- /**
- * Release the hardware resources owned by this object. Note that this is
- * *not* done in the destructor.
- */
- void release();
-
- /**
- * Dump state of the camera hardware
- */
- int dump(int fd);
- void getPictureSize(int *picture_width, int *picture_height) const;
- void getPreviewSize(int *preview_width, int *preview_height) const;
- void getVideoSize(int *video_width,int *video_height) const;
- void getThumbnailSize(int *thumb_width, int *thumb_height) const;
- cam_format_t getPreviewFormat() const;
- cam_pad_format_t getPreviewPadding() const;
- void processEvent(mm_camera_event_t *);
- int getJpegQuality() const;
- int getNumOfSnapshots(void) const;
- int getNumOfSnapshots(const QCameraParameters& params);
- int getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
- int *picture_width,
- int *picture_height);
- bool isRawSnapshot();
- bool mShutterSoundPlayed;
- void dumpFrameToFile(mm_camera_buf_def_t*, HAL_cam_dump_frm_type_t);
-
- static QCameraHardwareInterface *createInstance(int, int);
- status_t setZSLBurstLookBack(const QCameraParameters& params);
- status_t setZSLBurstInterval(const QCameraParameters& params);
- int getZSLBurstInterval(void);
- int getZSLQueueDepth(void) const;
- int getZSLBackLookCount(void) const;
-
- ~QCameraHardwareInterface();
- int initHeapMem(QCameraHalHeap_t *heap,
- int num_of_buf,
- uint32_t buf_len,
- int pmem_type,
- mm_camera_frame_len_offset* offset,
- mm_camera_buf_def_t *buf_def);
- int releaseHeapMem( QCameraHalHeap_t *heap);
- int allocate_ion_memory(QCameraHalMemInfo_t * mem_info, int ion_type);
- int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info);
-
- int cache_ops(QCameraHalMemInfo_t *mem_info,
- void *buf_ptr,
- unsigned int cmd);
-
- void dumpFrameToFile(const void * data, uint32_t size, char* name,
- char* ext, int index);
- preview_format_info_t getPreviewFormatInfo( );
- bool isCameraReady();
- bool isNoDisplayMode();
-
- int getBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int putBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
-
- mm_camera_vtbl_t *mCameraHandle;
- uint32_t mChannelId;
-
-private:
- int16_t zoomRatios[MAX_ZOOM_RATIOS];
- struct camera_size_type default_preview_sizes[PREVIEW_TBL_MAX_SIZE];
- struct camera_size_type default_video_sizes[VIDEO_TBL_MAX_SIZE];
- struct camera_size_type default_hfr_sizes[HFR_TBL_MAX_SIZE];
- struct camera_size_type default_thumbnail_sizes[THUMB_TBL_MAX_SIZE];
- unsigned int preview_sizes_count;
- unsigned int video_sizes_count;
- unsigned int thumbnail_sizes_count;
- unsigned int hfr_sizes_count;
-
-
- bool mUseOverlay;
-
- void loadTables();
- void initDefaultParameters();
- bool getMaxPictureDimension(mm_camera_dimension_t *dim);
-
- status_t updateFocusDistances();
-
- bool native_set_parms(mm_camera_parm_type_t type, uint16_t length, void *value);
- bool native_set_parms( mm_camera_parm_type_t type, uint16_t length, void *value, int *result);
-
- void hasAutoFocusSupport();
- void debugShowPreviewFPS() const;
- //void prepareSnapshotAndWait();
-
- bool isPreviewRunning();
- bool isRecordingRunning();
- bool isSnapshotRunning();
-
- void processChannelEvent(mm_camera_ch_event_t *, app_notify_cb_t *);
- void processRdiChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
- void processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
- void processRecordChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
- void processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
- void processCtrlEvent(mm_camera_ctrl_event_t *, app_notify_cb_t *);
- void processStatsEvent(mm_camera_stats_event_t *, app_notify_cb_t *);
- void processInfoEvent(mm_camera_info_event_t *event, app_notify_cb_t *);
- void processprepareSnapshotEvent(cam_ctrl_status_t *);
- void roiEvent(fd_roi_t roi, app_notify_cb_t *);
- void zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *);
- void autofocusevent(cam_ctrl_status_t *status, app_notify_cb_t *);
- void handleZoomEventForPreview(app_notify_cb_t *);
- void handleZoomEventForSnapshot(void);
- status_t autoFocusEvent(cam_ctrl_status_t *, app_notify_cb_t *);
-
- void filterPictureSizes();
- bool supportsSceneDetection();
- bool supportsSelectableZoneAf();
- bool supportsFaceDetection();
- bool supportsRedEyeReduction();
-
- void stopPreviewInternal();
- void stopRecordingInternal();
- status_t cancelPictureInternal();
- void pausePreviewForSnapshot();
- void restartPreview();
-
- status_t runFaceDetection();
-
- status_t setParameters(const QCameraParameters& params);
- QCameraParameters& getParameters() ;
-
- status_t setCameraMode(const QCameraParameters& params);
- status_t setPictureSizeTable(void);
- status_t setPreviewSizeTable(void);
- status_t setVideoSizeTable(void);
- status_t setPreviewSize(const QCameraParameters& params);
- status_t setJpegThumbnailSize(const QCameraParameters& params);
- status_t setPreviewFpsRange(const QCameraParameters& params);
- status_t setPreviewFrameRate(const QCameraParameters& params);
- status_t setPreviewFrameRateMode(const QCameraParameters& params);
- status_t setVideoSize(const QCameraParameters& params);
- status_t setPictureSize(const QCameraParameters& params);
- status_t setJpegQuality(const QCameraParameters& params);
- status_t setNumOfSnapshot(const QCameraParameters& params);
- status_t setJpegRotation(int isZSL);
- int getJpegRotation(void);
- int getISOSpeedValue();
- int getAutoFlickerMode();
- status_t setAntibanding(const QCameraParameters& params);
- status_t setEffect(const QCameraParameters& params);
- status_t setExposureCompensation(const QCameraParameters ¶ms);
- status_t setAutoExposure(const QCameraParameters& params);
- status_t setWhiteBalance(const QCameraParameters& params);
- status_t setFlash(const QCameraParameters& params);
- status_t setGpsLocation(const QCameraParameters& params);
- status_t setRotation(const QCameraParameters& params);
- status_t setZoom(const QCameraParameters& params);
- status_t setFocusMode(const QCameraParameters& params);
- status_t setBrightness(const QCameraParameters& params);
- status_t setSkinToneEnhancement(const QCameraParameters& params);
- status_t setOrientation(const QCameraParameters& params);
- status_t setLensshadeValue(const QCameraParameters& params);
- status_t setMCEValue(const QCameraParameters& params);
- status_t setISOValue(const QCameraParameters& params);
- status_t setPictureFormat(const QCameraParameters& params);
- status_t setSharpness(const QCameraParameters& params);
- status_t setContrast(const QCameraParameters& params);
- status_t setSaturation(const QCameraParameters& params);
- status_t setWaveletDenoise(const QCameraParameters& params);
- status_t setSceneMode(const QCameraParameters& params);
- status_t setContinuousAf(const QCameraParameters& params);
- status_t setFaceDetection(const char *str);
- status_t setSceneDetect(const QCameraParameters& params);
- status_t setStrTextures(const QCameraParameters& params);
- status_t setPreviewFormat(const QCameraParameters& params);
- status_t setSelectableZoneAf(const QCameraParameters& params);
- status_t setOverlayFormats(const QCameraParameters& params);
- status_t setHighFrameRate(const QCameraParameters& params);
- status_t setRedeyeReduction(const QCameraParameters& params);
- status_t setAEBracket(const QCameraParameters& params);
- status_t setFaceDetect(const QCameraParameters& params);
- status_t setDenoise(const QCameraParameters& params);
- status_t setAecAwbLock(const QCameraParameters & params);
- status_t setHistogram(int histogram_en);
- status_t setRecordingHint(const QCameraParameters& params);
- status_t setRecordingHintValue(const int32_t value);
- status_t setFocusAreas(const QCameraParameters& params);
- status_t setMeteringAreas(const QCameraParameters& params);
- status_t setFullLiveshot(void);
- status_t setDISMode(void);
- status_t setCaptureBurstExp(void);
- status_t setPowerMode(const QCameraParameters& params);
- void takePicturePrepareHardware( );
- status_t setNoDisplayMode(const QCameraParameters& params);
- status_t setDimension();
- status_t setRDIMode(const QCameraParameters& params);
- status_t setMobiCat(const QCameraParameters& params);
-
- isp3a_af_mode_t getAutoFocusMode(const QCameraParameters& params);
- bool isValidDimension(int w, int h);
-
- String8 create_values_str(const str_map *values, int len);
-
- void setMyMode(int mode);
- bool isZSLMode();
- bool isWDenoiseEnabled();
- void wdenoiseEvent(cam_ctrl_status_t status, void *cookie);
- bool isLowPowerCamcorder();
- void freePictureTable(void);
- void freeVideoSizeTable(void);
-
- int32_t createPreview();
- int32_t createRecord();
- int32_t createSnapshot();
- int32_t createRdi();
-
- int getHDRMode();
- //EXIF
- void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
- uint32_t count, uint8_t copy, void *data);
- void setExifTags();
- void initExifData();
- void deinitExifData();
- void setExifTagsGPS();
- exif_tags_info_t* getExifData(){ return mExifData; }
- int getExifTableNumEntries() { return mExifTableNumEntries; }
- void parseGPSCoordinate(const char *latlonString, rat_t* coord);
- //added to support hdr
- bool getHdrInfoAndSetExp(int max_num_frm, int *num_frame, int *exp);
- status_t initHistogramBuffers();
- status_t deInitHistogramBuffers();
- mm_jpeg_color_format getColorfmtFromImgFmt(uint32_t img_fmt);
-
- void notifyHdrEvent(cam_ctrl_status_t status, void * cookie);
- void initHdrInfoForSnapshot(bool Hdr_on, int number_frames, int *exp );
- void doHdrProcessing();
-
- int mCameraId;
- camera_mode_t myMode;
-
- mm_camear_mem_vtbl_t mem_hooks;
-
- QCameraParameters mParameters;
- int32_t mMsgEnabled;
-
- camera_notify_callback mNotifyCb;
- camera_data_callback mDataCb;
- camera_data_timestamp_callback mDataCbTimestamp;
- camera_request_memory mGetMemory;
- void *mCallbackCookie;
-
- mutable Mutex mLock;
- Mutex mPreviewMemoryLock;
- Mutex mAutofocusLock;
- Mutex mRecordFrameLock;
- Condition mRecordWait;
- pthread_mutex_t mAsyncCmdMutex;
- pthread_cond_t mAsyncCmdWait;
-
- QCameraStream * mStreams[MM_CAMERA_IMG_MODE_MAX];
- cam_ctrl_dimension_t mDimension;
- int mPreviewWidth, mPreviewHeight;
- int mPictureWidth, mPictureHeight;
- int videoWidth, videoHeight;
- int thumbnailWidth, thumbnailHeight;
- int maxSnapshotWidth, maxSnapshotHeight;
- int mRdiWidth,mRdiHeight;
- int mPreviewFormat;
- int mFps;
- int mDebugFps;
- int mBrightness;
- int mContrast;
- int mBestShotMode;
- int mEffects;
- int mColorEffects;
- int mSkinToneEnhancement;
- int mDenoiseValue;
- int mHJR;
- int mRotation;
- int mJpegQuality;
- int mThumbnailQuality;
- int mTargetSmoothZoom;
- int mSmoothZoomStep;
- int mMaxZoom;
- int mCurrentZoom;
- int mSupportedPictureSizesCount;
- int mFaceDetectOn;
- int mDumpFrmCnt;
- int mDumpSkipCnt;
- int mFocusMode;
- int rdiMode;
-
- unsigned int mPictureSizeCount;
- unsigned int mPreviewSizeCount;
- int mPowerMode;
- unsigned int mVideoSizeCount;
-
- bool mAutoFocusRunning;
- bool mNeedToUnlockCaf;
- bool mMultiTouch;
- bool mHasAutoFocusSupport;
- bool mInitialized;
- bool mDisEnabled;
- bool strTexturesOn;
- bool mIs3DModeOn;
- bool mSmoothZoomRunning;
- bool mPreparingSnapshot;
- bool mParamStringInitialized;
- bool mZoomSupported;
- bool mSendMetaData;
- bool mFullLiveshotEnabled;
- bool mRecordingHint;
- bool mStartRecording;
- bool mReleasedRecordingFrame;
- int mHdrMode;
- int mSnapshotFormat;
- int mZslInterval;
- bool mRestartPreview;
- bool mMobiCatEnabled;
- /*for histogram*/
- int mStatsOn;
- int mCurrentHisto;
- bool mSendData;
- sp<AshmemPool> mStatHeap;
- camera_memory_t *mStatsMapped[3];
- QCameraStatHeap_t mHistServer;
- int32_t mStatSize;
-
- bool mZslLookBackMode;
- int mZslLookBackValue;
- int mHFRLevel;
- bool mZslEmptyQueueFlag;
- String8 mEffectValues;
- String8 mIsoValues;
- String8 mSceneModeValues;
- String8 mSceneDetectValues;
- String8 mFocusModeValues;
- String8 mSelectableZoneAfValues;
- String8 mAutoExposureValues;
- String8 mWhitebalanceValues;
- String8 mAntibandingValues;
- String8 mFrameRateModeValues;
- String8 mTouchAfAecValues;
- String8 mPreviewSizeValues;
- String8 mPictureSizeValues;
- String8 mVideoSizeValues;
- String8 mFlashValues;
- String8 mLensShadeValues;
- String8 mMceValues;
- String8 mHistogramValues;
- String8 mSkinToneEnhancementValues;
- String8 mPictureFormatValues;
- String8 mDenoiseValues;
- String8 mZoomRatioValues;
- String8 mPreviewFrameRateValues;
- String8 mPreviewFormatValues;
- String8 mFaceDetectionValues;
- String8 mHfrValues;
- String8 mHfrSizeValues;
- String8 mRedeyeReductionValues;
- String8 denoise_value;
- String8 mFpsRangesSupportedValues;
- String8 mZslValues;
- String8 mFocusDistance;
-
- friend class QCameraStream;
- friend class QCameraStream_record;
- friend class QCameraStream_preview;
- friend class QCameraStream_SnapshotMain;
- friend class QCameraStream_SnapshotThumbnail;
- friend class QCameraStream_Rdi;
-
- android :: FPSRange* mSupportedFpsRanges;
- int mSupportedFpsRangesCount;
-
- camera_size_type* mPictureSizes;
- camera_size_type* mPreviewSizes;
- camera_size_type* mVideoSizes;
- const camera_size_type * mPictureSizesPtr;
- HAL_camera_state_type_t mCameraState;
-
- int mStoreMetaDataInFrame;
- preview_stream_ops_t *mPreviewWindow;
- Mutex mStateLock;
- int mPreviewState;
- /*preview memory with display case: memory is allocated and freed via
- gralloc */
- QCameraHalMemory_t mPreviewMemory;
-
- /*preview memory without display case: memory is allocated
- directly by camera */
- QCameraHalHeap_t mNoDispPreviewMemory;
- QCameraHalHeap_t mRdiMemory;
- QCameraHalHeap_t mSnapshotMemory;
- QCameraHalHeap_t mThumbnailMemory;
- QCameraHalHeap_t mRecordingMemory;
- QCameraHalHeap_t mJpegMemory;
- QCameraHalHeap_t mRawMemory;
- camera_frame_metadata_t mMetadata;
- camera_face_t mFace[MAX_ROI];
- preview_format_info_t mPreviewFormatInfo;
- friend void stream_cb_routine(mm_camera_super_buf_t *bufs, void *userdata);
- //EXIF
- exif_tags_info_t mExifData[MAX_EXIF_TABLE_ENTRIES]; //Exif tags for JPEG encoder
- exif_values_t mExifValues; //Exif values in usable format
- int mExifTableNumEntries; //NUmber of entries in mExifData
- int mNoDisplayMode;
- QCameraQueue mSuperBufQueue; /* queue for raw super buf */
- QCameraQueue mNotifyDataQueue; /* queue for data notify */
- QCameraCmdThread *mNotifyTh; /* thread for data notify */
- QCameraCmdThread *mDataProcTh; /* thread for data process (jpeg encoding) */
- mm_jpeg_ops_t mJpegHandle;
- uint32_t mJpegClientHandle;
- snap_hdr_record_t mHdrInfo;
- power_module_t* mPowerModule;
- cam_sensor_fps_range_t mSensorFpsRange;
-
- static void *dataNotifyRoutine(void *data);
- static void *dataProcessRoutine(void *data);
- static void snapshot_jpeg_cb(jpeg_job_status_t status,
- uint8_t thumbnailDroppedFlag,
- uint32_t client_hdl,
- uint32_t jobId,
- uint8_t* out_data,
- uint32_t data_size,
- void *userdata);
- static void receiveCompleteJpegPicture(jpeg_job_status_t status,
- uint8_t thumbnailDroppedFlag,
- uint32_t client_hdl,
- uint32_t jobId,
- uint8_t* out_data,
- uint32_t data_size,
- QCameraHardwareInterface* pme);
- static void superbuf_cb_routine(mm_camera_super_buf_t *recvd_frame,
- void *userdata);
- static void receiveRawPicture(mm_camera_super_buf_t* recvd_frame,
- QCameraHardwareInterface *pme);
- status_t encodeData(mm_camera_super_buf_t* recvd_frame,
- uint32_t *jobId);
- void notifyShutter(bool play_shutter_sound);
- status_t sendDataNotify(int32_t msg_type,
- camera_memory_t *data,
- uint8_t index,
- camera_frame_metadata_t *metadata,
- QCameraHalHeap_t *heap);
-
- void releaseSuperBuf(mm_camera_super_buf_t *super_buf);
- void releaseAppCBData(app_notify_cb_t *app_cb);
- static void releaseNofityData(void *data, void *user_data);
- static void releaseProcData(void *data, void *user_data);
- uint8_t canTakeFullSizeLiveshot();
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL/core/inc/QCameraHWI_Mem.h b/camera/QCamera/HAL/core/inc/QCameraHWI_Mem.h
deleted file mode 100755
index 11e4416..0000000
--- a/camera/QCamera/HAL/core/inc/QCameraHWI_Mem.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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 __QCAMERAHWI_MEM_H
-#define __QCAMERAHWI_MEM_H
-
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-#include <stdint.h>
-
-extern "C" {
-#include <linux/android_pmem.h>
-#include <linux/msm_ion.h>
-}
-
-#define VIDEO_BUFFER_COUNT NUM_RECORDING_BUFFERS
-#define VIDEO_BUFFER_COUNT_LOW_POWER_CAMCORDER 9
-
-#define PREVIEW_BUFFER_COUNT 5
-
-namespace android {
-
-// 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,
- 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 mAlignedBufferSize;
- int mNumBuffers;
- int mFrameSize;
- sp<MemoryHeapBase> mHeap;
- sp<MemoryBase> *mBuffers;
-
- const char *mName;
-};
-
-class AshmemPool : public MemPool {
-public:
- AshmemPool(int buffer_size, int num_buffers,
- int frame_size,
- const char *name);
-};
-
-class PmemPool : public MemPool {
-public:
- PmemPool(const char *pmem_pool,
- int flags, int pmem_type,
- int buffer_size, int num_buffers,
- int frame_size, int cbcr_offset,
- int yoffset, const char *name);
- virtual ~PmemPool();
- int mFd;
- int mPmemType;
- int mCbCrOffset;
- int myOffset;
- int mCameraControlFd;
- uint32_t mAlignedSize;
- struct pmem_region mSize;
-};
-
-class IonPool : public MemPool {
-public:
- IonPool( int flags,
- int buffer_size, int num_buffers,
- int frame_size, int cbcr_offset,
- int yoffset, const char *name);
- virtual ~IonPool();
- int mFd;
- int mCbCrOffset;
- int myOffset;
- int mCameraControlFd;
- uint32_t mAlignedSize;
-private:
- static const char mIonDevName[];
-};
-
-};
-#endif
diff --git a/camera/QCamera/HAL/core/inc/QCameraStream.h b/camera/QCamera/HAL/core/inc/QCameraStream.h
deleted file mode 100755
index 74afc8f..0000000
--- a/camera/QCamera/HAL/core/inc/QCameraStream.h
+++ /dev/null
@@ -1,316 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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_QCAMERA_STREAM_H
-#define ANDROID_HARDWARE_QCAMERA_STREAM_H
-
-
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <pthread.h>
-#include <semaphore.h>
-
-
-#include "QCameraHWI.h"
-#include "QCameraHWI_Mem.h"
-#include "mm_camera_interface.h"
-#include "mm_jpeg_interface.h"
-
-extern "C" {
-#define DEFAULT_STREAM_WIDTH 320
-#define DEFAULT_STREAM_HEIGHT 240
-#define DEFAULT_LIVESHOT_WIDTH 2592
-#define DEFAULT_LIVESHOT_HEIGHT 1944
-
-#define MM_CAMERA_CH_PREVIEW_MASK (0x01 << MM_CAMERA_CH_PREVIEW)
-#define MM_CAMERA_CH_VIDEO_MASK (0x01 << MM_CAMERA_CH_VIDEO)
-#define MM_CAMERA_CH_SNAPSHOT_MASK (0x01 << MM_CAMERA_CH_SNAPSHOT)
-#define MM_CAMERA_CH_RDI_MASK (0x01 << MM_CAMERA_CH_RDI)
-
-} /* extern C*/
-
-namespace android {
-
-class QCameraHardwareInterface;
-
-class QCameraStream { //: public virtual RefBase
-
-public:
- bool mInit;
- bool mActive;
-
- uint32_t mCameraHandle;
- uint32_t mChannelId;
- uint32_t mStreamId;
- uint32_t mWidth;
- uint32_t mHeight;
- uint32_t mFormat;
- uint8_t mNumBuffers;
- mm_camera_frame_len_offset mFrameOffsetInfo;
- mm_camera_vtbl_t *p_mm_ops;
- mm_camera_img_mode mExtImgMode;
- uint8_t m_flag_no_cb;
- uint8_t m_flag_stream_on;
- image_crop_t mCrop;
- QCameraHardwareInterface* mHalCamCtrl;
-
- void setResolution(mm_camera_dimension_t *res);
- bool isResolutionSame(mm_camera_dimension_t *res);
- void getResolution(mm_camera_dimension_t *res);
- virtual void release();
-
- status_t setFormat();
-
- //static status_t openChannel(mm_camera_t *, mm_camera_channel_type_t ch_type);
- void dataCallback(mm_camera_super_buf_t *bufs);
- virtual int32_t streamOn();
- virtual int32_t streamOff(bool aSync);
- virtual status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
- virtual status_t deinitStream();
- virtual void releaseRecordingFrame(const void *opaque)
- {
- ;
- }
- virtual sp<IMemoryHeap> getHeap() const{return NULL;}
- virtual sp<IMemoryHeap> getRawHeap() const {return NULL;}
- virtual void *getLastQueuedFrame(void){return NULL;}
- virtual void notifyROIEvent(fd_roi_t roi) {;}
- virtual void notifyWDenoiseEvent(cam_ctrl_status_t status, void * cookie) {;}
- virtual void notifyHdrEvent(cam_ctrl_status_t status, void * cookie){};
- virtual int32_t setCrop();
- virtual int getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs) = 0;
- virtual int putBuf(uint8_t num_bufs,
- mm_camera_buf_def_t *bufs) = 0;
-
- QCameraStream();
- QCameraStream(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl);
- virtual ~QCameraStream();
-
-};
-/*
-* Record Class
-*/
-class QCameraStream_record : public QCameraStream {
-public:
- void release() ;
-
- QCameraStream_record(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl);
- virtual ~QCameraStream_record();
-
- status_t processRecordFrame(mm_camera_super_buf_t *data);
- status_t initEncodeBuffers();
- status_t getBufferInfo(sp<IMemory>& Frame, size_t *alignedSize);
-
- void releaseRecordingFrame(const void *opaque);
- void debugShowVideoFPS() const;
-
- void releaseEncodeBuffer();
-
- int getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int putBuf(uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
- status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
-
-private:
- bool mDebugFps;
- mm_camera_super_buf_t mRecordedFrames[MM_CAMERA_MAX_NUM_FRAMES];
- mm_camera_buf_def_t mRecordBuf[2*VIDEO_BUFFER_COUNT];
- int mJpegMaxSize;
- QCameraStream *mStreamSnap;
-};
-
-class QCameraStream_preview : public QCameraStream {
-public:
- QCameraStream_preview(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl);
- virtual ~QCameraStream_preview();
- void release() ;
- void *getLastQueuedFrame(void);
- /*init preview buffers with display case*/
- status_t initDisplayBuffers();
- /*init preview buffers without display case*/
- status_t initPreviewOnlyBuffers();
- status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
- status_t processPreviewFrame(mm_camera_super_buf_t *frame);
- /*init preview buffers with display case*/
- status_t processPreviewFrameWithDisplay(mm_camera_super_buf_t *frame);
- /*init preview buffers without display case*/
- status_t processPreviewFrameWithOutDisplay(mm_camera_super_buf_t *frame);
-
- void notifyROIEvent(fd_roi_t roi);
- int32_t setCrop();
- int getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int putBuf(uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
-
- friend class QCameraHardwareInterface;
-
-private:
- /*allocate and free buffers with display case*/
- status_t getBufferFromSurface();
- status_t putBufferToSurface();
-
- /*allocate and free buffers without display case*/
- status_t getBufferNoDisplay();
- status_t freeBufferNoDisplay();
-
- void dumpFrameToFile(mm_camera_buf_def_t* newFrame);
- bool mFirstFrameRcvd;
-
- int8_t my_id;
- mm_camera_op_mode_type_t op_mode;
- mm_camera_buf_def_t *mLastQueuedFrame;
- mm_camera_buf_def_t mDisplayBuf[2*PREVIEW_BUFFER_COUNT];
- Mutex mDisplayLock;
- preview_stream_ops_t *mPreviewWindow;
- mm_camera_super_buf_t mNotifyBuffer[2*PREVIEW_BUFFER_COUNT];
- int8_t mNumFDRcvd;
- int mVFEOutputs;
- int mHFRFrameCnt;
- int mHFRFrameSkip;
-};
-
-class QCameraStream_SnapshotMain : public QCameraStream {
-public:
- void release();
- status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
- status_t initMainBuffers();
- void deInitMainBuffers();
- mm_camera_buf_def_t mSnapshotStreamBuf[MM_CAMERA_MAX_NUM_FRAMES];
- QCameraStream_SnapshotMain(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl);
- ~QCameraStream_SnapshotMain();
- int getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int putBuf(uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
-
-private:
- /*Member variables*/
- int mSnapshotState;
-};
-
-class QCameraStream_SnapshotThumbnail : public QCameraStream {
-public:
- void release();
- QCameraStream_SnapshotThumbnail(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl);
- ~QCameraStream_SnapshotThumbnail();
- int getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int putBuf(uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
- status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
-
-private:
- mm_camera_buf_def_t mPostviewStreamBuf[MM_CAMERA_MAX_NUM_FRAMES];
-};
-
-class QCameraStream_Rdi : public QCameraStream {
-public:
- void release() ;
-
- QCameraStream_Rdi(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl);
- virtual ~QCameraStream_Rdi();
- status_t processRdiFrame (mm_camera_super_buf_t *data);
- int getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int putBuf(uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
- status_t initStream(uint8_t no_cb_needed, uint8_t stream_on);
-
- friend class QCameraHardwareInterface;
-
-private:
- void dumpFrameToFile(mm_camera_buf_def_t* newFrame);
-
- int8_t my_id;
- mm_camera_op_mode_type_t op_mode;
- mm_camera_buf_def_t mRdiBuf[PREVIEW_BUFFER_COUNT];
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL/core/src/QCameraHAL.cpp b/camera/QCamera/HAL/core/src/QCameraHAL.cpp
deleted file mode 100755
index 858385b..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHAL.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHAL"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-
-/* include QCamera Hardware Interface Header*/
-#include "QCameraHAL.h"
-
-int HAL_numOfCameras = 0;
-mm_camera_info_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS];
-int HAL_currentCameraMode;
-
-namespace android {
-/* HAL function implementation goes here*/
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-extern "C" int HAL_getNumberOfCameras()
-{
- /* try to query every time we get the call!*/
- uint8_t num_camera = 0;
- mm_camera_info_t * handle_base = 0;
- ALOGV("%s: E", __func__);
-
- handle_base= camera_query(&num_camera);
-
- if (!handle_base) {
- HAL_numOfCameras = 0;
- }
- else
- {
- camera_info_t* p_camera_info = NULL;
- HAL_numOfCameras=num_camera;
-
- ALOGI("Handle base =0x%p",handle_base);
- ALOGI("getCameraInfo: numOfCameras = %d", HAL_numOfCameras);
- for(int i = 0; i < HAL_numOfCameras; i++) {
- ALOGI("Handle [%d]=0x%p",i,handle_base+i);
- HAL_camerahandle[i]=handle_base + i;
- p_camera_info = &(HAL_camerahandle[i]->camera_info);
- if (p_camera_info) {
- ALOGI("Camera sensor %d info:", i);
- ALOGI("camera_id: %d", p_camera_info->camera_id);
- ALOGI("modes_supported: %x", p_camera_info->modes_supported);
- ALOGI("position: %d", p_camera_info->position);
- ALOGI("sensor_mount_angle: %d", p_camera_info->sensor_mount_angle);
- }
- }
- }
-
- ALOGV("%s: X", __func__);
-
- return HAL_numOfCameras;
-}
-
-extern "C" int HAL_isIn3DMode()
-{
- return HAL_currentCameraMode == CAMERA_MODE_3D;
-}
-
-extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo)
-{
- mm_camera_info_t *mm_camer_obj = 0;
- ALOGV("%s: E", __func__);
-
- if (!HAL_numOfCameras || HAL_numOfCameras < cameraId || !cameraInfo)
- return;
- else
- mm_camer_obj = HAL_camerahandle[cameraId];
-
- if (!mm_camer_obj)
- return;
- else {
- cameraInfo->facing =
- (FRONT_CAMERA == mm_camer_obj->camera_info.position)?
- CAMERA_FACING_FRONT : CAMERA_FACING_BACK;
- cameraInfo->orientation = mm_camer_obj->camera_info.sensor_mount_angle;
- }
- ALOGV("%s: X", __func__);
- return;
-}
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" void * HAL_openCameraHardware(int cameraId, int mode)
-{
- ALOGV("%s: E", __func__);
- if (!HAL_numOfCameras || HAL_numOfCameras < cameraId ||cameraId < 0) {
- return NULL;
- }
- return QCameraHAL_openCameraHardware(cameraId, mode);
-}
-
-
-}; // namespace android
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI.cpp b/camera/QCamera/HAL/core/src/QCameraHWI.cpp
deleted file mode 100755
index e3fb369..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI.cpp
+++ /dev/null
@@ -1,3619 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_NIDEBUG 0
-
-#define LOG_TAG "QCameraHWI"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-
-/* QCameraHardwareInterface class implementation goes here*/
-/* following code implement the contol logic of this class*/
-
-namespace android {
-
-extern void stream_cb_routine(mm_camera_super_buf_t *bufs,
- void *userdata);
-
-void QCameraHardwareInterface::superbuf_cb_routine(mm_camera_super_buf_t *recvd_frame, void *userdata)
-{
- ALOGE("%s: E",__func__);
- QCameraHardwareInterface *pme = (QCameraHardwareInterface *)userdata;
- if(pme == NULL){
- ALOGE("%s: pme is null", __func__);
- return;
- }
-
- mm_camera_super_buf_t* frame =
- (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
- if (frame == NULL) {
- ALOGE("%s: Error allocating memory to save received_frame structure.", __func__);
- for (int i=0; i<recvd_frame->num_bufs; i++) {
- if (recvd_frame->bufs[i] != NULL) {
- if (recvd_frame->bufs[i]->p_mobicat_info) {
- free(recvd_frame->bufs[i]->p_mobicat_info);
- recvd_frame->bufs[i]->p_mobicat_info = NULL;
- }
- pme->mCameraHandle->ops->qbuf(recvd_frame->camera_handle,
- recvd_frame->ch_id,
- recvd_frame->bufs[i]);
- pme->cache_ops((QCameraHalMemInfo_t *)(recvd_frame->bufs[i]->mem_info),
- recvd_frame->bufs[i]->buffer,
- ION_IOC_INV_CACHES);
- }
- }
- return;
- }
- memcpy(frame, recvd_frame, sizeof(mm_camera_super_buf_t));
- if(pme->mHdrInfo.hdr_on) {
- pme->mHdrInfo.recvd_frame[pme->mHdrInfo.num_raw_received] = frame;
-
- ALOGE("hdl %d, ch_id %d, buf_num %d, bufidx0 %d, bufidx1 %d",
- pme->mHdrInfo.recvd_frame[pme->mHdrInfo.num_raw_received]->
- camera_handle, pme->mHdrInfo.recvd_frame[pme->mHdrInfo.
- num_raw_received]->ch_id, pme->mHdrInfo.recvd_frame[pme->
- mHdrInfo.num_raw_received]->num_bufs, pme->mHdrInfo.
- recvd_frame[pme->mHdrInfo.num_raw_received]->bufs[0]->buf_idx,
- pme->mHdrInfo.recvd_frame[pme->mHdrInfo.num_raw_received]->
- bufs[1]->buf_idx);
-
- pme->mHdrInfo.num_raw_received++;
-
- ALOGE("%s Total %d Received %d frames, still need to receive %d frames",
- __func__, pme->mHdrInfo.num_frame, pme->mHdrInfo.num_raw_received,
- (pme->mHdrInfo.num_frame - pme->mHdrInfo.num_raw_received));
-
- if (pme->mHdrInfo.num_raw_received == pme->mHdrInfo.num_frame) {
- ALOGE(" Received all %d YUV frames, Invoke HDR",
- pme->mHdrInfo.num_raw_received);
- pme->doHdrProcessing();
- }
- } else {
- /* enqueu to superbuf queue */
- pme->mSuperBufQueue.enqueue(frame);
-
- /* notify dataNotify thread that new super buf is avail
- * check if it's done with current JPEG notification and
- * a new encoding job could be conducted*/
- pme->mNotifyTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
- }
- ALOGE("%s: X", __func__);
-
-}
-
-void QCameraHardwareInterface::snapshot_jpeg_cb(jpeg_job_status_t status,
- uint8_t thumbnailDroppedFlag,
- uint32_t client_hdl,
- uint32_t jobId,
- uint8_t* out_data,
- uint32_t data_size,
- void *userdata)
-{
- ALOGE("%s: E", __func__);
- camera_jpeg_encode_cookie_t *cookie =
- (camera_jpeg_encode_cookie_t *)userdata;
- if(cookie == NULL){
- ALOGE("%s: userdata is null", __func__);
- return;
- }
- QCameraHardwareInterface *pme = (QCameraHardwareInterface *)cookie->userdata;
- if(pme == NULL){
- ALOGE("%s: pme is null", __func__);
- return;
- }
-
- /* no use of src frames, return them to kernel */
- for(int i = 0; i< cookie->src_frame->num_bufs; i++) {
- if (cookie->src_frame->bufs[i]->p_mobicat_info) {
- free(cookie->src_frame->bufs[i]->p_mobicat_info);
- cookie->src_frame->bufs[i]->p_mobicat_info = NULL;
- }
- pme->mCameraHandle->ops->qbuf(cookie->src_frame->camera_handle,
- cookie->src_frame->ch_id,
- cookie->src_frame->bufs[i]);
- pme->cache_ops((QCameraHalMemInfo_t *)(cookie->src_frame->bufs[i]->mem_info),
- cookie->src_frame->bufs[i]->buffer,
- ION_IOC_INV_CACHES);
- }
- free(cookie->src_frame);
- cookie->src_frame = NULL;
-
- receiveCompleteJpegPicture(status,
- thumbnailDroppedFlag,
- client_hdl,
- jobId,
- out_data,
- data_size,
- pme);
-
- /* free sink frame */
- free(out_data);
- /* free cookie */
- free(cookie);
-
- ALOGE("%s: X", __func__);
-}
-
-void QCameraHardwareInterface::releaseAppCBData(app_notify_cb_t *app_cb)
-{
- if (app_cb->argm_data_cb.user_data != NULL) {
- QCameraHalHeap_t *heap = (QCameraHalHeap_t *)app_cb->argm_data_cb.user_data;
- releaseHeapMem(heap);
- }
-}
-
-void QCameraHardwareInterface::releaseNofityData(void *data, void *user_data)
-{
- QCameraHardwareInterface *pme = (QCameraHardwareInterface *)user_data;
- if (NULL != pme) {
- pme->releaseAppCBData((app_notify_cb_t *)data);
- }
-}
-
-void QCameraHardwareInterface::releaseSuperBuf(mm_camera_super_buf_t *super_buf)
-{
- if (NULL != super_buf) {
- for(int i = 0; i< super_buf->num_bufs; i++) {
- if (super_buf->bufs[i]->p_mobicat_info) {
- free(super_buf->bufs[i]->p_mobicat_info);
- super_buf->bufs[i]->p_mobicat_info = NULL;
- }
- mCameraHandle->ops->qbuf(super_buf->camera_handle,
- super_buf->ch_id,
- super_buf->bufs[i]);
- cache_ops((QCameraHalMemInfo_t *)(super_buf->bufs[i]->mem_info),
- super_buf->bufs[i]->buffer,
- ION_IOC_INV_CACHES);
- }
- }
-}
-
-void QCameraHardwareInterface::releaseProcData(void *data, void *user_data)
-{
- QCameraHardwareInterface *pme = (QCameraHardwareInterface *)user_data;
- if (NULL != pme) {
- pme->releaseSuperBuf((mm_camera_super_buf_t *)data);
- }
-}
-
-void *QCameraHardwareInterface::dataNotifyRoutine(void *data)
-{
- int running = 1;
- int ret;
- QCameraHardwareInterface *pme = (QCameraHardwareInterface *)data;
- QCameraCmdThread *cmdThread = pme->mNotifyTh;
- uint8_t isEncoding = FALSE;
- uint8_t isActive = FALSE;
- uint32_t numOfSnapshotExpected = 0;
- uint32_t numOfSnapshotRcvd = 0;
-
- ALOGD("%s: E", __func__);
- do {
- do {
- ret = sem_wait(&cmdThread->cmd_sem);
- if (ret != 0 && errno != EINVAL) {
- ALOGE("%s: sem_wait error (%s)",
- __func__, strerror(errno));
- return NULL;
- }
- } while (ret != 0);
-
- /* we got notified about new cmd avail in cmd queue */
- camera_cmd_type_t cmd = cmdThread->getCmd();
- ALOGD("%s: get cmd %d", __func__, cmd);
- switch (cmd) {
- case CAMERA_CMD_TYPE_START_DATA_PROC:
- isActive = TRUE;
- /* init flag to FALSE */
- isEncoding = FALSE;
- numOfSnapshotExpected = pme->getNumOfSnapshots();
- numOfSnapshotRcvd = 0;
- break;
- case CAMERA_CMD_TYPE_STOP_DATA_PROC:
- /* flush jpeg data queue */
- pme->mNotifyDataQueue.flush();
-
- isActive = FALSE;
- /* set flag to FALSE */
- isEncoding = FALSE;
- numOfSnapshotExpected = 0;
- numOfSnapshotRcvd = 0;
- break;
- case CAMERA_CMD_TYPE_DO_NEXT_JOB:
- {
- if (TRUE == isActive) {
- /* first check if there is any pending jpeg notify */
- app_notify_cb_t *app_cb =
- (app_notify_cb_t *)pme->mNotifyDataQueue.dequeue();
- if (NULL != app_cb) {
- /* send notify to upper layer */
- if (app_cb->notifyCb) {
- ALOGE("%s: evt notify cb", __func__);
- app_cb->notifyCb(app_cb->argm_notify.msg_type,
- app_cb->argm_notify.ext1,
- app_cb->argm_notify.ext2,
- app_cb->argm_notify.cookie);
- }
- if (app_cb->dataCb) {
- ALOGE("%s: data notify cb", __func__);
- app_cb->dataCb(app_cb->argm_data_cb.msg_type,
- app_cb->argm_data_cb.data,
- app_cb->argm_data_cb.index,
- app_cb->argm_data_cb.metadata,
- app_cb->argm_data_cb.cookie);
- if (CAMERA_MSG_COMPRESSED_IMAGE == app_cb->argm_data_cb.msg_type) {
- numOfSnapshotRcvd++;
- isEncoding = FALSE;
- }
- }
-
- /* free app_cb */
- pme->releaseAppCBData(app_cb);
- free(app_cb);
- }
-
- if ((FALSE == isEncoding) && !pme->mSuperBufQueue.is_empty()) {
- isEncoding = TRUE;
- /* notify processData thread to do next encoding job */
- pme->mDataProcTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
- }
-
- if (numOfSnapshotExpected > 0 &&
- numOfSnapshotExpected == numOfSnapshotRcvd) {
- pme->cancelPictureInternal();
- }
- } else {
- /* do no op if not active */
- app_notify_cb_t *app_cb =
- (app_notify_cb_t *)pme->mNotifyDataQueue.dequeue();
- if (NULL != app_cb) {
- /* free app_cb */
- pme->releaseAppCBData(app_cb);
- free(app_cb);
- }
- }
- }
- break;
- case CAMERA_CMD_TYPE_EXIT:
- {
- /* flush jpeg data queue */
- pme->mNotifyDataQueue.flush();
- running = 0;
- }
- break;
- default:
- break;
- }
- } while (running);
- ALOGD("%s: X", __func__);
- return NULL;
-}
-
-void *QCameraHardwareInterface::dataProcessRoutine(void *data)
-{
- int running = 1;
- int ret;
- uint8_t is_active = FALSE;
- QCameraHardwareInterface *pme = (QCameraHardwareInterface *)data;
- QCameraCmdThread *cmdThread = pme->mDataProcTh;
- uint32_t current_jobId = 0;
-
- ALOGD("%s: E", __func__);
- do {
- do {
- ret = sem_wait(&cmdThread->cmd_sem);
- if (ret != 0 && errno != EINVAL) {
- ALOGE("%s: sem_wait error (%s)",
- __func__, strerror(errno));
- return NULL;
- }
- } while (ret != 0);
-
- /* we got notified about new cmd avail in cmd queue */
- camera_cmd_type_t cmd = cmdThread->getCmd();
- ALOGD("%s: get cmd %d", __func__, cmd);
- switch (cmd) {
- case CAMERA_CMD_TYPE_START_DATA_PROC:
- is_active = TRUE;
- break;
- case CAMERA_CMD_TYPE_STOP_DATA_PROC:
- {
- is_active = FALSE;
- /* abort current job if it's running */
- if (current_jobId > 0) {
- pme->mJpegHandle.abort_job(pme->mJpegClientHandle, current_jobId);
- current_jobId = 0;
- }
- /* flush superBufQueue */
- pme->mSuperBufQueue.flush();
- /* signal cmd is completed */
- sem_post(&cmdThread->sync_sem);
- }
- break;
- case CAMERA_CMD_TYPE_DO_NEXT_JOB:
- {
- ALOGD("%s: active is %d", __func__, is_active);
- if (is_active == TRUE) {
- /* first check if there is any pending jpeg notify */
- mm_camera_super_buf_t *super_buf =
- (mm_camera_super_buf_t *)pme->mSuperBufQueue.dequeue();
- if (NULL != super_buf) {
- //play shutter sound
- if(!pme->mShutterSoundPlayed){
- pme->notifyShutter(true);
- }
- pme->notifyShutter(false);
- pme->mShutterSoundPlayed = false;
-
- if (pme->isRawSnapshot()) {
- receiveRawPicture(super_buf, pme);
-
- /*free superbuf*/
- pme->releaseSuperBuf(super_buf);
- free(super_buf);
- } else{
- ret = pme->encodeData(super_buf, ¤t_jobId);
-
- if (NO_ERROR != ret) {
- pme->releaseSuperBuf(super_buf);
- free(super_buf);
- pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
- NULL,
- 0,
- NULL,
- NULL);
- }
- }
- }
- } else {
- /* not active, simply return buf and do no op */
- mm_camera_super_buf_t *super_buf =
- (mm_camera_super_buf_t *)pme->mSuperBufQueue.dequeue();
- if (NULL != super_buf) {
- pme->releaseSuperBuf(super_buf);
- free(super_buf);
- }
- }
- }
- break;
- case CAMERA_CMD_TYPE_EXIT:
- /* abort current job if it's running */
- if (current_jobId > 0) {
- pme->mJpegHandle.abort_job(pme->mJpegClientHandle, current_jobId);
- current_jobId = 0;
- }
- /* flush super buf queue */
- pme->mSuperBufQueue.flush();
- running = 0;
- break;
- default:
- break;
- }
- } while (running);
- ALOGD("%s: X", __func__);
- return NULL;
-}
-
-void QCameraHardwareInterface::notifyShutter(bool play_shutter_sound){
- ALOGV("%s : E", __func__);
- if(mNotifyCb){
- mNotifyCb(CAMERA_MSG_SHUTTER, 0, play_shutter_sound, mCallbackCookie);
- }
- ALOGV("%s : X", __func__);
-}
-
-status_t QCameraHardwareInterface::encodeData(mm_camera_super_buf_t* recvd_frame,
- uint32_t *jobId)
-{
- ALOGV("%s : E", __func__);
- int32_t ret = NO_ERROR;
- mm_jpeg_job jpg_job;
- mm_camera_buf_def_t *main_frame = NULL;
- mm_camera_buf_def_t *thumb_frame = NULL;
- src_image_buffer_info *main_buf_info = NULL;
- src_image_buffer_info *thumb_buf_info = NULL;
- QCameraHalMemInfo_t *main_mem_info = NULL;
- QCameraHalMemInfo_t *thumb_mem_info = NULL;
-
- uint8_t src_img_num = recvd_frame->num_bufs;
- int i;
-
- *jobId = 0;
-
- QCameraStream *main_stream = mStreams[MM_CAMERA_SNAPSHOT_MAIN];
- for (i = 0; i < recvd_frame->num_bufs; i++) {
- if (main_stream->mStreamId == recvd_frame->bufs[i]->stream_id) {
- main_frame = recvd_frame->bufs[i];
- break;
- }
- }
- if(main_frame == NULL){
- ALOGE("%s : Main frame is NULL", __func__);
- return ret;
- }
- main_mem_info = &mSnapshotMemory.mem_info[main_frame->buf_idx];
-
- // send upperlayer callback for raw image (data or notify, not both)
- app_notify_cb_t *app_cb = (app_notify_cb_t *)malloc(sizeof(app_notify_cb_t));
- if (app_cb != NULL) {
- memset(app_cb, 0, sizeof(app_notify_cb_t));
-
- if((mDataCb) && (mMsgEnabled & CAMERA_MSG_RAW_IMAGE)){
- app_cb->dataCb = mDataCb;
- app_cb->argm_data_cb.msg_type = CAMERA_MSG_RAW_IMAGE;
- app_cb->argm_data_cb.cookie = mCallbackCookie;
- app_cb->argm_data_cb.data = mSnapshotMemory.camera_memory[main_frame->buf_idx];
- app_cb->argm_data_cb.index = 1;
- app_cb->argm_data_cb.metadata = NULL;
- app_cb->argm_data_cb.user_data = NULL;
- }
- if((mNotifyCb) && (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY)){
- app_cb->notifyCb = mNotifyCb;
- app_cb->argm_notify.msg_type = CAMERA_MSG_RAW_IMAGE_NOTIFY;
- app_cb->argm_notify.cookie = mCallbackCookie;
- app_cb->argm_notify.ext1 = 0;
- app_cb->argm_notify.ext2 = 0;
- }
-
- /* enqueue jpeg_data into jpeg data queue */
- if ((app_cb->dataCb || app_cb->notifyCb) && mNotifyDataQueue.enqueue((void *)app_cb)) {
- mNotifyTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
- } else {
- free(app_cb);
- }
- } else {
- ALOGE("%s: No mem for app_notify_cb_t", __func__);
- }
-
- camera_jpeg_encode_cookie_t *cookie =
- (camera_jpeg_encode_cookie_t *)malloc(sizeof(camera_jpeg_encode_cookie_t));
- if (NULL == cookie) {
- ALOGE("%s : no mem for cookie", __func__);
- return -1;
- }
- cookie->src_frame = recvd_frame;
- cookie->userdata = this;
-
- dumpFrameToFile(main_frame, HAL_DUMP_FRM_MAIN);
-
- QCameraStream *thumb_stream = NULL;
- if (recvd_frame->num_bufs > 1) {
- /* has thumbnail */
- if(!isZSLMode()) {
- thumb_stream = mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]; //mStreamSnapThumb;
- } else {
- thumb_stream = mStreams[MM_CAMERA_PREVIEW]; //mStreamDisplay;
- }
- for (i = 0; i < recvd_frame->num_bufs; i++) {
- if (thumb_stream->mStreamId == recvd_frame->bufs[i]->stream_id) {
- thumb_frame = recvd_frame->bufs[i];
- break;
- }
- }
- if (NULL != thumb_frame) {
- if(thumb_stream == mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]) {
- thumb_mem_info = &mThumbnailMemory.mem_info[thumb_frame->buf_idx];
- } else {
- if (isNoDisplayMode()) {
- thumb_mem_info = &mNoDispPreviewMemory.mem_info[thumb_frame->buf_idx];
- } else {
- thumb_mem_info = &mPreviewMemory.mem_info[thumb_frame->buf_idx];
- }
- }
- }
- } else if(mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mWidth &&
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mHeight) {
- /*thumbnail is required, not YUV thumbnail, borrow main image*/
- thumb_stream = main_stream;
- thumb_frame = main_frame;
- src_img_num++;
- }
-
- if (thumb_stream) {
- dumpFrameToFile(thumb_frame, HAL_DUMP_FRM_THUMBNAIL);
- }
-
- int jpeg_quality = getJpegQuality();
- if (jpeg_quality <= 0) {
- jpeg_quality = 85;
- }
-
- memset(&jpg_job, 0, sizeof(mm_jpeg_job));
- jpg_job.job_type = JPEG_JOB_TYPE_ENCODE;
- jpg_job.encode_job.userdata = cookie;
- jpg_job.encode_job.jpeg_cb = QCameraHardwareInterface::snapshot_jpeg_cb;
- jpg_job.encode_job.encode_parm.exif_data = getExifData();
- jpg_job.encode_job.encode_parm.exif_numEntries = getExifTableNumEntries();
- jpg_job.encode_job.encode_parm.rotation = getJpegRotation();
- ALOGV("%s: jpeg rotation is set to %d", __func__, jpg_job.encode_job.encode_parm.rotation);
- jpg_job.encode_job.encode_parm.buf_info.src_imgs.src_img_num = src_img_num;
- jpg_job.encode_job.encode_parm.buf_info.src_imgs.is_video_frame = FALSE;
-
- if (mMobiCatEnabled) {
- main_frame->p_mobicat_info = (cam_exif_tags_t*)malloc(sizeof(cam_exif_tags_t));
- if ((main_frame->p_mobicat_info != NULL) &&
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_MOBICAT,
- main_frame->p_mobicat_info)
- == MM_CAMERA_OK) {
- ALOGV("%s:%d] Mobicat enabled %p %d", __func__, __LINE__,
- main_frame->p_mobicat_info->tags,
- main_frame->p_mobicat_info->data_len);
- } else {
- ALOGE("MM_CAMERA_PARM_MOBICAT get failed");
- }
- }
- if (mMobiCatEnabled && main_frame->p_mobicat_info) {
- jpg_job.encode_job.encode_parm.hasmobicat = 1;
- jpg_job.encode_job.encode_parm.mobicat_data = (uint8_t *)main_frame->p_mobicat_info->tags;
- jpg_job.encode_job.encode_parm.mobicat_data_length = main_frame->p_mobicat_info->data_len;
- } else {
- jpg_job.encode_job.encode_parm.hasmobicat = 0;
- }
-
- // fill in the src_img info
- //main img
- main_buf_info = &jpg_job.encode_job.encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN];
- main_buf_info->type = JPEG_SRC_IMAGE_TYPE_MAIN;
- main_buf_info->color_format = getColorfmtFromImgFmt(main_stream->mFormat);
- main_buf_info->quality = jpeg_quality;
- main_buf_info->src_image[0].fd = main_frame->fd;
- main_buf_info->src_image[0].buf_vaddr = (uint8_t*) main_frame->buffer;
- main_buf_info->src_dim.width = main_stream->mWidth;
- main_buf_info->src_dim.height = main_stream->mHeight;
- main_buf_info->out_dim.width = mPictureWidth;
- main_buf_info->out_dim.height = mPictureHeight;
- memcpy(&main_buf_info->crop, &main_stream->mCrop, sizeof(image_crop_t));
-
- ALOGD("%s : Main Image :Input Dimension %d x %d output Dimension = %d X %d",
- __func__, main_buf_info->src_dim.width, main_buf_info->src_dim.height,
- main_buf_info->out_dim.width, main_buf_info->out_dim.height);
- ALOGD("%s : Main Image :Crop %d x %d, offset = (%d, %d)",
- __func__, main_buf_info->crop.width, main_buf_info->crop.height,
- main_buf_info->crop.offset_x, main_buf_info->crop.offset_y);
- main_buf_info->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
- main_buf_info->num_bufs = 1;
- main_buf_info->src_image[0].offset = main_stream->mFrameOffsetInfo;
- ALOGD("%s : setting main image offset info, len = %d, offset = %d",
- __func__, main_stream->mFrameOffsetInfo.mp[0].len,
- main_stream->mFrameOffsetInfo.mp[0].offset);
-
- cache_ops(main_mem_info, main_frame->buffer, ION_IOC_CLEAN_INV_CACHES);
-
- if (thumb_frame && thumb_stream) {
- /* fill in thumbnail src img encode param */
- thumb_buf_info = &jpg_job.encode_job.encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB];
- thumb_buf_info->type = JPEG_SRC_IMAGE_TYPE_THUMB;
- thumb_buf_info->color_format = getColorfmtFromImgFmt(thumb_stream->mFormat);
- //thumb_buf_info->quality = jpeg_quality;
- thumb_buf_info->quality = 75; //hardcoded for now, will be calculated in encoder code later
- thumb_buf_info->src_dim.width = thumb_stream->mWidth;
- thumb_buf_info->src_dim.height = thumb_stream->mHeight;
- thumb_buf_info->out_dim.width = thumbnailWidth;
- thumb_buf_info->out_dim.height = thumbnailHeight;
- memcpy(&thumb_buf_info->crop, &thumb_stream->mCrop, sizeof(image_crop_t));
- ALOGD("%s : Thumanail :Input Dimension %d x %d output Dimension = %d X %d",
- __func__, thumb_buf_info->src_dim.width, thumb_buf_info->src_dim.height,
- thumb_buf_info->out_dim.width,thumb_buf_info->out_dim.height);
- thumb_buf_info->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
- thumb_buf_info->num_bufs = 1;
- thumb_buf_info->src_image[0].fd = thumb_frame->fd;
- thumb_buf_info->src_image[0].buf_vaddr = (uint8_t*) thumb_frame->buffer;
- thumb_buf_info->src_image[0].offset = thumb_stream->mFrameOffsetInfo;
- ALOGD("%s : setting thumb image offset info, len = %d, offset = %d",
- __func__, thumb_stream->mFrameOffsetInfo.mp[0].len, thumb_stream->mFrameOffsetInfo.mp[0].offset);
-
- cache_ops(thumb_mem_info, thumb_frame->buffer, ION_IOC_CLEAN_INV_CACHES);
- }
-
- uint32_t buf_len = main_stream->mFrameOffsetInfo.frame_len;
- if (main_stream->m_flag_stream_on == FALSE) {
- //if video-sized livesnapshot
- jpg_job.encode_job.encode_parm.buf_info.src_imgs.is_video_frame = TRUE;
-
- //use the same output resolution as input
- main_buf_info->out_dim.width = main_buf_info->src_dim.width;
- main_buf_info->out_dim.height = main_buf_info->src_dim.height;
-
- if (thumb_buf_info->out_dim.width > thumb_buf_info->src_dim.width ||
- thumb_buf_info->out_dim.height > thumb_buf_info->src_dim.height ) {
- thumb_buf_info->out_dim.width = thumb_buf_info->src_dim.width;
- thumb_buf_info->out_dim.height = thumb_buf_info->src_dim.height;
- }
-
- uint32_t len = main_buf_info->out_dim.width * main_buf_info->out_dim.height * 1.5;
- if (len > buf_len) {
- buf_len = len;
- }
- }
-
- //fill in the sink img info
- jpg_job.encode_job.encode_parm.buf_info.sink_img.buf_len = buf_len;
- jpg_job.encode_job.encode_parm.buf_info.sink_img.buf_vaddr = (uint8_t *)malloc(buf_len);
- if (NULL == jpg_job.encode_job.encode_parm.buf_info.sink_img.buf_vaddr) {
- ALOGE("%s: ERROR: no memory for sink_img buf", __func__);
- free(cookie);
- cookie = NULL;
- return -1;
- }
-
- if (mJpegClientHandle > 0) {
- ret = mJpegHandle.start_job(mJpegClientHandle, &jpg_job, jobId);
- } else {
- ALOGE("%s: Error: bug here, mJpegClientHandle is 0", __func__);
- free(cookie);
- cookie = NULL;
- return -1;
- }
-
- ALOGV("%s : X", __func__);
- return ret;
-
-}
-
-status_t QCameraHardwareInterface::sendDataNotify(int32_t msg_type,
- camera_memory_t *data,
- uint8_t index,
- camera_frame_metadata_t *metadata,
- QCameraHalHeap_t *heap)
-{
- app_notify_cb_t *app_cb = (app_notify_cb_t *)malloc(sizeof(app_notify_cb_t));
- if (NULL == app_cb) {
- ALOGE("%s: no mem for app_notify_cb_t", __func__);
- return BAD_VALUE;
- }
- memset(app_cb, 0, sizeof(app_notify_cb_t));
- app_cb->dataCb = mDataCb;
- app_cb->argm_data_cb.msg_type = msg_type;
- app_cb->argm_data_cb.cookie = mCallbackCookie;
- app_cb->argm_data_cb.data = data;
- app_cb->argm_data_cb.index = index;
- app_cb->argm_data_cb.metadata = metadata;
- app_cb->argm_data_cb.user_data = (void *)heap;
-
- /* enqueue jpeg_data into jpeg data queue */
- if (mNotifyDataQueue.enqueue((void *)app_cb)) {
- mNotifyTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
- } else {
- free(app_cb);
- return BAD_VALUE;
- }
- return NO_ERROR;
-}
-
-void QCameraHardwareInterface::receiveRawPicture(mm_camera_super_buf_t* recvd_frame,
- QCameraHardwareInterface *pme)
-{
- ALOGV("%s : E", __func__);
- status_t rc = NO_ERROR;
- int buf_index = 0;
-
- ALOGV("%s: is a raw snapshot", __func__);
- /*RAW snapshot*/
- if (recvd_frame->bufs[0] == NULL) {
- ALOGE("%s: The main frame buffer is null", __func__);
- return;
- }
-
- if (pme->mDataCb && (pme->mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)) {
- if (pme->initHeapMem(&pme->mRawMemory,
- 1,
- recvd_frame->bufs[0]->frame_len,
- MSM_PMEM_RAW_MAINIMG,
- NULL,
- NULL) < 0) {
- ALOGE("%s : initHeapMem for raw, ret = NO_MEMORY", __func__);
- return;
- }
-
- buf_index = recvd_frame->bufs[0]->buf_idx;
- memcpy(pme->mRawMemory.camera_memory[0]->data,
- pme->mSnapshotMemory.camera_memory[buf_index]->data,
- recvd_frame->bufs[0]->frame_len);
-
- rc = pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
- pme->mRawMemory.camera_memory[0],
- 0,
- NULL,
- &pme->mRawMemory);
- if (rc != NO_ERROR) {
- pme->releaseHeapMem(&pme->mRawMemory);
- }
- }
- ALOGV("%s : X", __func__);
-}
-
-void QCameraHardwareInterface::receiveCompleteJpegPicture(jpeg_job_status_t status,
- uint8_t thumbnailDroppedFlag,
- uint32_t client_hdl,
- uint32_t jobId,
- uint8_t* out_data,
- uint32_t data_size,
- QCameraHardwareInterface *pme)
-{
- status_t rc = NO_ERROR;
- ALOGE("%s: E", __func__);
-
- pme->deinitExifData();
-
- if(status == JPEG_JOB_STATUS_ERROR) {
- ALOGE("Error event handled from jpeg");
- if(pme->mDataCb && (pme->mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)){
- pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
- NULL,
- 0,
- NULL,
- NULL);
- }
- return;
- }
-
- if(thumbnailDroppedFlag) {
- ALOGE("%s : Error in thumbnail encoding, no ops here", __func__);
- }
-
- pme->dumpFrameToFile(out_data,
- data_size,
- (char *)"debug",
- (char *)"jpg",
- jobId);
-
- ALOGE("%s: jpeg_size=%d", __func__, data_size);
-
- if(pme->mDataCb && (pme->mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)){
- if (pme->initHeapMem(&pme->mJpegMemory,
- 1,
- data_size,
- MSM_PMEM_MAX,
- NULL,
- NULL) < 0) {
- ALOGE("%s : initHeapMem for jpeg, ret = NO_MEMORY", __func__);
- if(pme->mDataCb && (pme->mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE)){
- pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
- NULL,
- 0,
- NULL,
- NULL);
- }
- return;
- }
-
- memcpy(pme->mJpegMemory.camera_memory[0]->data, out_data, data_size);
-
- ALOGE("%s : Calling upperlayer callback to store JPEG image", __func__);
- rc = pme->sendDataNotify(CAMERA_MSG_COMPRESSED_IMAGE,
- pme->mJpegMemory.camera_memory[0],
- 0,
- NULL,
- &pme->mJpegMemory);
- if (rc != NO_ERROR) {
- pme->releaseHeapMem(&pme->mJpegMemory);
- }
- }
-
- ALOGE("%s: X", __func__);
-}
-
-static void HAL_event_cb(uint32_t camera_handle, mm_camera_event_t *evt, void *user_data)
-{
- QCameraHardwareInterface *obj = (QCameraHardwareInterface *)user_data;
- if (obj) {
- obj->processEvent(evt);
- } else {
- ALOGE("%s: NULL user_data", __func__);
- }
-}
-
-int32_t QCameraHardwareInterface::createRdi()
-{
- int32_t ret = MM_CAMERA_OK;
- ALOGV("%s : BEGIN",__func__);
- mStreams[MM_CAMERA_RDI] = new QCameraStream_Rdi(mCameraHandle->camera_handle,
- mChannelId,
- 640/*Width*/,
- 480/*Height*/,
- CAMERA_BAYER_SBGGR10/*Format*/,
- PREVIEW_BUFFER_COUNT/*NumBuffers*/,
- mCameraHandle,
- MM_CAMERA_RDI,
- myMode,
- this);
- if (!mStreams[MM_CAMERA_RDI]) {
- ALOGE("%s: error - can't creat RDI stream!", __func__);
- return BAD_VALUE;
- }
-
- ALOGV("%s : END",__func__);
- return ret;
-}
-
-int32_t QCameraHardwareInterface::createRecord()
-{
- int32_t ret = MM_CAMERA_OK;
- ALOGV("%s : BEGIN",__func__);
-
- /*
- * Creating Instance of record stream.
- */
- ALOGE("Mymode Record = %d",myMode);
- mStreams[MM_CAMERA_VIDEO] = new QCameraStream_record(
- mCameraHandle->camera_handle,
- mChannelId,
- 640/*Width*/,
- 480/*Height*/,
- 0/*Format*/,
- VIDEO_BUFFER_COUNT/*NumBuffers*/,
- mCameraHandle,
- MM_CAMERA_VIDEO,
- myMode,
- this);
-
- if (!mStreams[MM_CAMERA_VIDEO]) {
- ALOGE("%s: error - can't creat record stream!", __func__);
- return BAD_VALUE;
- }
-
- /*Init Channel */
- ALOGV("%s : END",__func__);
- return ret;
-}
-int32_t QCameraHardwareInterface::createSnapshot()
-{
- int32_t ret = MM_CAMERA_OK;
- ALOGE("%s : BEGIN",__func__);
- uint8_t NumBuffers = 1;
-
- if(mHdrMode) {
- ALOGE("%s mHdrMode = %d, setting NumBuffers to 3", __func__, mHdrMode);
- NumBuffers = 3;
- }
-
- /*
- * Creating Instance of Snapshot Main stream.
- */
- ALOGE("Mymode Snap = %d",myMode);
- ALOGE("%s : before creating an instance of SnapshotMain, num buffers = %d", __func__, NumBuffers);
- mStreams[MM_CAMERA_SNAPSHOT_MAIN] = new QCameraStream_SnapshotMain(
- mCameraHandle->camera_handle,
- mChannelId,
- 640,
- 480,
- CAMERA_YUV_420_NV21,
- NumBuffers,
- mCameraHandle,
- MM_CAMERA_SNAPSHOT_MAIN,
- myMode,
- this);
- if (!mStreams[MM_CAMERA_SNAPSHOT_MAIN]) {
- ALOGE("%s: error - can't creat snapshot stream!", __func__);
- return BAD_VALUE;
- }
-
- /*
- * Creating Instance of Snapshot Thumb stream.
- */
- ALOGE("Mymode Snap = %d",myMode);
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL] = new QCameraStream_SnapshotThumbnail(
- mCameraHandle->camera_handle,
- mChannelId,
- 512,
- 384,
- CAMERA_YUV_420_NV21,
- NumBuffers,
- mCameraHandle,
- MM_CAMERA_SNAPSHOT_THUMBNAIL,
- myMode,
- this);
- if (!mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]) {
- ALOGE("%s: error - can't creat snapshot stream!", __func__);
- return BAD_VALUE;
- }
-
- ALOGV("%s : END",__func__);
- return ret;
-}
-int32_t QCameraHardwareInterface::createPreview()
-{
- int32_t ret = MM_CAMERA_OK;
- ALOGV("%s : BEGIN",__func__);
-
- ALOGE("Mymode Preview = %d",myMode);
- mStreams[MM_CAMERA_PREVIEW] = new QCameraStream_preview(
- mCameraHandle->camera_handle,
- mChannelId,
- 640/*Width*/,
- 480/*Height*/,
- 0/*Format*/,
- 7/*NumBuffers*/,
- mCameraHandle,
- MM_CAMERA_PREVIEW,
- myMode,
- this);
- if (!mStreams[MM_CAMERA_PREVIEW]) {
- ALOGE("%s: error - can't creat preview stream!", __func__);
- return BAD_VALUE;
- }
-
- ALOGV("%s : END",__func__);
- return ret;
-}
-
-/*Mem Hooks*/
-int32_t get_buffer_hook(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- QCameraHardwareInterface *pme=(QCameraHardwareInterface *)user_data;
- pme->getBuf(camera_handle, ch_id, stream_id,
- user_data, frame_offset_info,
- num_bufs,initial_reg_flag,
- bufs);
-
- return 0;
-}
-
-int32_t put_buffer_hook(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs)
-{
- QCameraHardwareInterface *pme=(QCameraHardwareInterface *)user_data;
- pme->putBuf(camera_handle, ch_id, stream_id,
- user_data, num_bufs, bufs);
-
- return 0;
-}
-
-int QCameraHardwareInterface::getBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- int ret = BAD_VALUE;
- ALOGE("%s: len:%d, y_off:%d, cbcr:%d num buffers: %d planes:%d streamid:%d",
- __func__,
- frame_offset_info->frame_len,
- frame_offset_info->mp[0].len,
- frame_offset_info->mp[1].len,
- num_bufs,frame_offset_info->num_planes,
- stream_id);
-
- for (int i = 0; i < MM_CAMERA_IMG_MODE_MAX; i++) {
- if (mStreams[i] != NULL && mStreams[i]->mStreamId == stream_id) {
- ret = mStreams[i]->getBuf(frame_offset_info, num_bufs, initial_reg_flag, bufs);
- break;
- }
- }
-
- return ret;
-}
-
-int QCameraHardwareInterface::putBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs)
-{
- int ret = BAD_VALUE;
- ALOGE("%s:E",__func__);
- for (int i = 0; i < MM_CAMERA_IMG_MODE_MAX; i++) {
- if (mStreams[i] && (mStreams[i]->mStreamId == stream_id)) {
- ret = mStreams[i]->putBuf(num_bufs, bufs);
- break;
- }
- }
- return ret;
-}
-
-
-/* constructor */
-QCameraHardwareInterface::
-QCameraHardwareInterface(int cameraId, int mode)
- : mCameraId(cameraId),
- mParameters(),
- mMsgEnabled(0),
- mNotifyCb(0),
- mDataCb(0),
- mDataCbTimestamp(0),
- mCallbackCookie(0),
- mPreviewFormat(CAMERA_YUV_420_NV21),
- mFps(0),
- mDebugFps(0),
- mBrightness(0),
- mContrast(0),
- mBestShotMode(0),
- mEffects(0),
- mSkinToneEnhancement(0),
- mDenoiseValue(0),
- mHJR(0),
- mRotation(0),
- mMaxZoom(0),
- mCurrentZoom(0),
- mSupportedPictureSizesCount(15),
- mFaceDetectOn(0),
- mDumpFrmCnt(0), mDumpSkipCnt(0),
- mFocusMode(AF_MODE_MAX),
- mPictureSizeCount(15),
- mPreviewSizeCount(13),
- mVideoSizeCount(0),
- mAutoFocusRunning(false),
- mHasAutoFocusSupport(false),
- mInitialized(false),
- mDisEnabled(0),
- mIs3DModeOn(0),
- mSmoothZoomRunning(false),
- mParamStringInitialized(false),
- mZoomSupported(false),
- mFullLiveshotEnabled(true),
- mRecordingHint(0),
- mStartRecording(0),
- mReleasedRecordingFrame(false),
- mHdrMode(HDR_BRACKETING_OFF),
- mSnapshotFormat(0),
- mZslInterval(1),
- mRestartPreview(false),
- mStatsOn(0), mCurrentHisto(-1), mSendData(false), mStatHeap(NULL),
- mZslLookBackMode(0),
- mZslLookBackValue(0),
- mZslEmptyQueueFlag(FALSE),
- mPictureSizes(NULL),
- mVideoSizes(NULL),
- mCameraState(CAMERA_STATE_UNINITED),
- mExifTableNumEntries(0),
- mNoDisplayMode(0),
- rdiMode(STREAM_IMAGE),
- mSupportedFpsRanges(NULL),
- mSupportedFpsRangesCount(0),
- mPowerModule(0),
- mNeedToUnlockCaf(false),
- mSuperBufQueue(releaseProcData, this),
- mNotifyDataQueue(releaseNofityData, this)
-{
- ALOGI("QCameraHardwareInterface: E");
- int32_t result = MM_CAMERA_E_GENERAL;
- mMobiCatEnabled = false;
- char value[PROPERTY_VALUE_MAX];
-
- pthread_mutex_init(&mAsyncCmdMutex, NULL);
- pthread_cond_init(&mAsyncCmdWait, NULL);
-
- property_get("persist.debug.sf.showfps", value, "0");
- mDebugFps = atoi(value);
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- mPreviewWindow = NULL;
- property_get("camera.hal.fps", value, "0");
- mFps = atoi(value);
-
- ALOGI("Init mPreviewState = %d", mPreviewState);
-
- property_get("persist.camera.hal.multitouchaf", value, "0");
- mMultiTouch = atoi(value);
-
- property_get("persist.camera.full.liveshot", value, "1");
- mFullLiveshotEnabled = atoi(value);
-
- property_get("persist.camera.hal.dis", value, "0");
- mDisEnabled = atoi(value);
-
- memset(&mem_hooks,0,sizeof(mm_camear_mem_vtbl_t));
-
- mem_hooks.user_data=this;
- mem_hooks.get_buf=get_buffer_hook;
- mem_hooks.put_buf=put_buffer_hook;
-
- /* Open camera stack! */
- mCameraHandle=camera_open(mCameraId, &mem_hooks);
- ALOGV("Cam open returned %p",mCameraHandle);
- if(mCameraHandle == NULL) {
- ALOGE("startCamera: cam_ops_open failed: id = %d", mCameraId);
- return;
- }
- //sync API for mm-camera-interface
- mCameraHandle->ops->sync(mCameraHandle->camera_handle);
-
- mChannelId=mCameraHandle->ops->ch_acquire(mCameraHandle->camera_handle);
- if(mChannelId<=0)
- {
- mCameraHandle->ops->camera_close(mCameraHandle->camera_handle);
- return;
- }
- mm_camera_event_type_t evt;
- for (int i = 0; i < MM_CAMERA_EVT_TYPE_MAX; i++) {
- if(mCameraHandle->ops->is_event_supported(mCameraHandle->camera_handle,
- (mm_camera_event_type_t )i )){
- mCameraHandle->ops->register_event_notify(mCameraHandle->camera_handle,
- HAL_event_cb,
- (void *) this,
- (mm_camera_event_type_t) i);
- }
- }
-
- loadTables();
- /* Setup Picture Size and Preview size tables */
- setPictureSizeTable();
- ALOGD("%s: Picture table size: %d", __func__, mPictureSizeCount);
- ALOGD("%s: Picture table: ", __func__);
- for(unsigned int i=0; i < mPictureSizeCount;i++) {
- ALOGD(" %d %d", mPictureSizes[i].width, mPictureSizes[i].height);
- }
-
- setPreviewSizeTable();
- ALOGD("%s: Preview table size: %d", __func__, mPreviewSizeCount);
- ALOGD("%s: Preview table: ", __func__);
- for(unsigned int i=0; i < mPreviewSizeCount;i++) {
- ALOGD(" %d %d", mPreviewSizes[i].width, mPreviewSizes[i].height);
- }
-
- setVideoSizeTable();
- ALOGD("%s: Video table size: %d", __func__, mVideoSizeCount);
- ALOGD("%s: Video table: ", __func__);
- for(unsigned int i=0; i < mVideoSizeCount;i++) {
- ALOGD(" %d %d", mVideoSizes[i].width, mVideoSizes[i].height);
- }
- memset(&mHistServer, 0, sizeof(mHistServer));
-
- /* set my mode - update myMode member variable due to difference in
- enum definition between upper and lower layer*/
- setMyMode(mode);
- initDefaultParameters();
-
- //Create Stream Objects
- memset(mStreams, 0, sizeof(mStreams));
-
- //Preview
- result = createPreview();
- if(result != MM_CAMERA_OK) {
- ALOGE("%s X: Failed to create Preview Object",__func__);
- return;
- }
-
- //Record
- result = createRecord();
- if(result != MM_CAMERA_OK) {
- ALOGE("%s X: Failed to create Record Object",__func__);
- return;
- }
- //Snapshot
- result = createSnapshot();
- if(result != MM_CAMERA_OK) {
- ALOGE("%s X: Failed to create Record Object",__func__);
- return;
- }
-
- memset(&mJpegHandle, 0, sizeof(mJpegHandle));
- mJpegClientHandle = jpeg_open(&mJpegHandle);
- if(!mJpegClientHandle) {
- ALOGE("%s : jpeg_open did not work", __func__);
- return;
- }
-
- /* launch jpeg notify thread and raw data proc thread */
- mNotifyTh = new QCameraCmdThread();
- if (mNotifyTh != NULL) {
- mNotifyTh->launch(dataNotifyRoutine, this);
- } else {
- ALOGE("%s : no mem for mNotifyTh", __func__);
- return;
- }
- mDataProcTh = new QCameraCmdThread();
- if (mDataProcTh != NULL) {
- mDataProcTh->launch(dataProcessRoutine, this);
- } else {
- ALOGE("%s : no mem for mDataProcTh", __func__);
- return;
- }
-
- memset(&mHdrInfo, 0, sizeof(snap_hdr_record_t));
- // initialize the mMetadata to set num_of_faces to 0
- memset(&mMetadata, 0, sizeof(mMetadata));
-
- if (hw_get_module(POWER_HARDWARE_MODULE_ID, (const hw_module_t **)&mPowerModule)) {
- ALOGE("%s module not found", POWER_HARDWARE_MODULE_ID);
- }
-
- mCameraState = CAMERA_STATE_READY;
- ALOGI("QCameraHardwareInterface: X");
-}
-
-QCameraHardwareInterface::~QCameraHardwareInterface()
-{
- ALOGI("~QCameraHardwareInterface: E");
-
- if (CAMERA_STATE_READY == mCameraState) {
- stopPreview();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- }
-
- if(mSupportedFpsRanges != NULL) {
- delete mSupportedFpsRanges;
- mSupportedFpsRanges = NULL;
- }
-
- freePictureTable();
- freeVideoSizeTable();
-
- deInitHistogramBuffers();
- if(mStatHeap != NULL) {
- mStatHeap.clear( );
- mStatHeap = NULL;
- }
-
- for (int i = 0; i < MM_CAMERA_IMG_MODE_MAX; i++) {
- if (mStreams[i] != NULL) {
- delete mStreams[i];
- mStreams[i] = NULL;
- }
- }
-
- for (int i = 0; i < MAX_HDR_EXP_FRAME_NUM; i++) {
- if (mHdrInfo.recvd_frame[i] != NULL) {
- free(mHdrInfo.recvd_frame[i]);
- mHdrInfo.recvd_frame[i] = NULL;
- }
- }
-
- if (mNotifyTh != NULL) {
- mNotifyTh->exit();
- delete mNotifyTh;
- mNotifyTh = NULL;
- }
- if (mDataProcTh != NULL) {
- mDataProcTh->exit();
- delete mDataProcTh;
- mDataProcTh = NULL;
- }
- if(mJpegClientHandle > 0) {
- int rc = mJpegHandle.close(mJpegClientHandle);
- ALOGE("%s: Jpeg closed, rc = %d, mJpegClientHandle = %x",
- __func__, rc, mJpegClientHandle);
- mJpegClientHandle = 0;
- memset(&mJpegHandle, 0, sizeof(mJpegHandle));
- }
-
- if (NULL != mCameraHandle) {
- mCameraHandle->ops->ch_release(mCameraHandle->camera_handle,
- mChannelId);
-
- mCameraHandle->ops->camera_close(mCameraHandle->camera_handle);
- }
-
- pthread_mutex_destroy(&mAsyncCmdMutex);
- pthread_cond_destroy(&mAsyncCmdWait);
-
- ALOGE("~QCameraHardwareInterface: X");
-}
-
-bool QCameraHardwareInterface::isCameraReady()
-{
- ALOGE("isCameraReady mCameraState %d", mCameraState);
- return (mCameraState == CAMERA_STATE_READY);
-}
-
-void QCameraHardwareInterface::release()
-{
- ALOGI("release: E");
- Mutex::Autolock l(&mLock);
-
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STOPPED:
- break;
- case QCAMERA_HAL_PREVIEW_START:
- break;
- case QCAMERA_HAL_PREVIEW_STARTED:
- stopPreviewInternal();
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- stopRecordingInternal();
- stopPreviewInternal();
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- cancelPictureInternal();
- break;
- default:
- break;
- }
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- ALOGI("release: X");
-}
-
-void QCameraHardwareInterface::setCallbacks(
- camera_notify_callback notify_cb,
- camera_data_callback data_cb,
- camera_data_timestamp_callback data_cb_timestamp,
- camera_request_memory get_memory,
- void *user)
-{
- ALOGE("setCallbacks: E");
- Mutex::Autolock lock(mLock);
- mNotifyCb = notify_cb;
- mDataCb = data_cb;
- mDataCbTimestamp = data_cb_timestamp;
- mGetMemory = get_memory;
- mCallbackCookie = user;
- ALOGI("setCallbacks: X");
-}
-
-void QCameraHardwareInterface::enableMsgType(int32_t msgType)
-{
- ALOGI("enableMsgType: E, msgType =0x%x", msgType);
- Mutex::Autolock lock(mLock);
- mMsgEnabled |= msgType;
- ALOGI("enableMsgType: X, msgType =0x%x, mMsgEnabled=0x%x", msgType, mMsgEnabled);
-}
-
-void QCameraHardwareInterface::disableMsgType(int32_t msgType)
-{
- ALOGI("disableMsgType: E");
- Mutex::Autolock lock(mLock);
- mMsgEnabled &= ~msgType;
- ALOGI("disableMsgType: X, msgType =0x%x, mMsgEnabled=0x%x", msgType, mMsgEnabled);
-}
-
-int QCameraHardwareInterface::msgTypeEnabled(int32_t msgType)
-{
- ALOGI("msgTypeEnabled: E");
- Mutex::Autolock lock(mLock);
- return (mMsgEnabled & msgType);
- ALOGI("msgTypeEnabled: X");
-}
-
-int QCameraHardwareInterface::dump(int fd)
-{
- ALOGE("%s: not supported yet", __func__);
- return -1;
-}
-
-status_t QCameraHardwareInterface::sendCommand(int32_t command, int32_t arg1,
- int32_t arg2)
-{
- ALOGI("sendCommand: E");
- status_t rc = NO_ERROR;
- Mutex::Autolock l(&mLock);
-
- switch (command) {
- case CAMERA_CMD_HISTOGRAM_ON:
- ALOGE("histogram set to on");
- rc = setHistogram(1);
- break;
- case CAMERA_CMD_HISTOGRAM_OFF:
- ALOGE("histogram set to off");
- rc = setHistogram(0);
- break;
- case CAMERA_CMD_HISTOGRAM_SEND_DATA:
- ALOGE("histogram send data");
- mSendData = true;
- rc = NO_ERROR;
- break;
- case CAMERA_CMD_START_FACE_DETECTION:
- if(supportsFaceDetection() == false){
- ALOGE("Face detection support is not available");
- return NO_ERROR;
- }
- setFaceDetection("on");
- return runFaceDetection();
- case CAMERA_CMD_STOP_FACE_DETECTION:
- if(supportsFaceDetection() == false){
- ALOGE("Face detection support is not available");
- return NO_ERROR;
- }
- setFaceDetection("off");
- return runFaceDetection();
- default:
- break;
- }
- ALOGI("sendCommand: X");
- return rc;
-}
-
-void QCameraHardwareInterface::setMyMode(int mode)
-{
- ALOGI("setMyMode: E");
- if (mode & CAMERA_SUPPORT_MODE_3D) {
- myMode = CAMERA_MODE_3D;
- }else {
- /* default mode is 2D */
- myMode = CAMERA_MODE_2D;
- }
-
- if (mode & CAMERA_SUPPORT_MODE_ZSL) {
- myMode = (camera_mode_t)(myMode |CAMERA_ZSL_MODE);
- }else {
- myMode = (camera_mode_t) (myMode | CAMERA_NONZSL_MODE);
- }
- ALOGI("setMyMode: Set mode to %d (passed mode: %d)", myMode, mode);
- ALOGI("setMyMode: X");
-}
-/* static factory function */
-QCameraHardwareInterface *QCameraHardwareInterface::createInstance(int cameraId, int mode)
-{
- ALOGI("createInstance: E");
- QCameraHardwareInterface *cam = new QCameraHardwareInterface(cameraId, mode);
- if (cam ) {
- if (cam->mCameraState != CAMERA_STATE_READY) {
- ALOGE("createInstance: Failed");
- delete cam;
- cam = NULL;
- }
- }
-
- if (cam) {
- ALOGI("createInstance: X");
- return cam;
- } else {
- return NULL;
- }
-}
-/* external plug in function */
-extern "C" void *
-QCameraHAL_openCameraHardware(int cameraId, int mode)
-{
- ALOGI("QCameraHAL_openCameraHardware: E");
- return (void *) QCameraHardwareInterface::createInstance(cameraId, mode);
-}
-
-bool QCameraHardwareInterface::isPreviewRunning() {
- ALOGI("isPreviewRunning: E");
- bool ret = false;
-
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_START:
- case QCAMERA_HAL_PREVIEW_STARTED:
- case QCAMERA_HAL_RECORDING_STARTED:
- ret = true;
- break;
- default:
- break;
- }
- ALOGI("isPreviewRunning: X");
- return ret;
-}
-
-bool QCameraHardwareInterface::isRecordingRunning() {
- ALOGE("isRecordingRunning: E");
- bool ret = false;
- if(QCAMERA_HAL_RECORDING_STARTED == mPreviewState)
- ret = true;
- ALOGE("isRecordingRunning: X");
- return ret;
-}
-
-bool QCameraHardwareInterface::isSnapshotRunning() {
- ALOGE("isSnapshotRunning: E");
- bool ret = false;
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STOPPED:
- case QCAMERA_HAL_PREVIEW_START:
- case QCAMERA_HAL_PREVIEW_STARTED:
- case QCAMERA_HAL_RECORDING_STARTED:
- default:
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- ret = true;
- break;
- }
- ALOGI("isSnapshotRunning: X");
- return ret;
-}
-
-bool QCameraHardwareInterface::isZSLMode() {
- return (myMode & CAMERA_ZSL_MODE);
-}
-
-int QCameraHardwareInterface::getHDRMode() {
- ALOGE("%s, mHdrMode = %d", __func__, mHdrMode);
- return mHdrMode;
-}
-
-void QCameraHardwareInterface::debugShowPreviewFPS() const
-{
- static int mFrameCount;
- static int mLastFrameCount = 0;
- static nsecs_t mLastFpsTime = 0;
- static float mFps = 0;
- mFrameCount++;
- nsecs_t now = systemTime();
- nsecs_t diff = now - mLastFpsTime;
- if (diff > ms2ns(250)) {
- mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
- ALOGE("Preview Frames Per Second: %.4f", mFps);
- mLastFpsTime = now;
- mLastFrameCount = mFrameCount;
- }
-}
-
-
-void QCameraHardwareInterface::
-processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) {
- ALOGI("processPreviewChannelEvent: E");
- switch(channelEvent) {
- case MM_CAMERA_CH_EVT_STREAMING_ON:
- break;
- case MM_CAMERA_CH_EVT_STREAMING_OFF:
- break;
- case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE:
- break;
- default:
- break;
- }
- ALOGI("processPreviewChannelEvent: X");
- return;
-}
-
-void QCameraHardwareInterface::processRecordChannelEvent(
- mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) {
- ALOGI("processRecordChannelEvent: E");
- switch(channelEvent) {
- case MM_CAMERA_CH_EVT_STREAMING_ON:
- break;
- case MM_CAMERA_CH_EVT_STREAMING_OFF:
- break;
- case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE:
- break;
- default:
- break;
- }
- ALOGI("processRecordChannelEvent: X");
- return;
-}
-
-void QCameraHardwareInterface::
-processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) {
- ALOGI("processSnapshotChannelEvent: E evt=%d state=%d", channelEvent,
- mCameraState);
- switch(channelEvent) {
- case MM_CAMERA_CH_EVT_STREAMING_ON:
- break;
- case MM_CAMERA_CH_EVT_STREAMING_OFF:
- break;
- case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE:
- break;
- case MM_CAMERA_CH_EVT_DATA_REQUEST_MORE:
- break;
- default:
- break;
- }
- ALOGI("processSnapshotChannelEvent: X");
- return;
-}
-
-void QCameraHardwareInterface::
-processRdiChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) {
- ALOGI("processRdiChannelEvent: E evt=%d state=%d", channelEvent,
- mCameraState);
- switch(channelEvent) {
- case MM_CAMERA_CH_EVT_STREAMING_ON:
- break;
- case MM_CAMERA_CH_EVT_STREAMING_OFF:
- break;
- case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE:
- break;
- case MM_CAMERA_CH_EVT_DATA_REQUEST_MORE:
- break;
- default:
- break;
- }
- ALOGI("processRdiChannelEvent: X");
- return;
-}
-
-void QCameraHardwareInterface::processChannelEvent(
- mm_camera_ch_event_t *event, app_notify_cb_t *app_cb)
-{
- ALOGI("processChannelEvent: E");
- Mutex::Autolock lock(mLock);
- switch(event->ch) {
- case MM_CAMERA_PREVIEW:
- processPreviewChannelEvent(event->evt, app_cb);
- break;
- case MM_CAMERA_RDI:
- processRdiChannelEvent(event->evt, app_cb);
- break;
- case MM_CAMERA_VIDEO:
- processRecordChannelEvent(event->evt, app_cb);
- break;
- case MM_CAMERA_SNAPSHOT_MAIN:
- case MM_CAMERA_SNAPSHOT_THUMBNAIL:
- processSnapshotChannelEvent(event->evt, app_cb);
- break;
- default:
- break;
- }
- ALOGI("processChannelEvent: X");
- return;
-}
-
-void QCameraHardwareInterface::processCtrlEvent(mm_camera_ctrl_event_t *event, app_notify_cb_t *app_cb)
-{
- ALOGI("processCtrlEvent: %d, E",event->evt);
- ALOGE("processCtrlEvent: MM_CAMERA_CTRL_EVT_HDR_DONE is %d", MM_CAMERA_CTRL_EVT_HDR_DONE);
- if(rdiMode == STREAM_RAW) {
- return;
- }
- Mutex::Autolock lock(mLock);
- switch(event->evt)
- {
- case MM_CAMERA_CTRL_EVT_ZOOM_DONE:
- ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_ZOOM_DONE");
- zoomEvent(&event->status, app_cb);
- break;
- case MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE:
- ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE");
- autoFocusEvent(&event->status, app_cb);
- break;
- case MM_CAMERA_CTRL_EVT_PREP_SNAPSHOT:
- ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_ZOOM_DONE");
- break;
- case MM_CAMERA_CTRL_EVT_WDN_DONE:
- ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_WDN_DONE");
- wdenoiseEvent(event->status, (void *)(event->cookie));
- break;
- case MM_CAMERA_CTRL_EVT_HDR_DONE:
- ALOGI("processCtrlEvent:MM_CAMERA_CTRL_EVT_HDR_DONE");
- notifyHdrEvent(event->status, (void*)(event->cookie));
- break;
- case MM_CAMERA_CTRL_EVT_ERROR:
- ALOGI("processCtrlEvent: MM_CAMERA_CTRL_EVT_ERROR");
- app_cb->notifyCb = mNotifyCb;
- app_cb->argm_notify.msg_type = CAMERA_MSG_ERROR;
- app_cb->argm_notify.ext1 = CAMERA_ERROR_UNKNOWN;
- app_cb->argm_notify.cookie = mCallbackCookie;
- break;
- case MM_CAMERA_CTRL_EVT_SNAPSHOT_CONFIG_DONE:
- ALOGV("%s: MM_CAMERA_CTRL_EVT_SNAPSHOT_CONFIG_DONE", __func__);
- app_cb->notifyCb = mNotifyCb;
- app_cb->argm_notify.msg_type = CAMERA_MSG_SHUTTER;
- app_cb->argm_notify.ext1 = 0;
- app_cb->argm_notify.ext2 = TRUE;
- app_cb->argm_notify.cookie = mCallbackCookie;
- mShutterSoundPlayed = TRUE;
- default:
- break;
- }
- ALOGI("processCtrlEvent: X");
- return;
-}
-
-void QCameraHardwareInterface::processStatsEvent(
- mm_camera_stats_event_t *event, app_notify_cb_t *app_cb)
-{
- ALOGI("processStatsEvent: E");
- if (!isPreviewRunning( )) {
- ALOGE("preview is not running");
- return;
- }
-
- switch (event->event_id) {
-
- case MM_CAMERA_STATS_EVT_HISTO:
- {
- ALOGE("HAL process Histo: mMsgEnabled=0x%x, mStatsOn=%d, mSendData=%d, mDataCb=%p ",
- (mMsgEnabled & CAMERA_MSG_STATS_DATA), mStatsOn, mSendData, mDataCb);
- int msgEnabled = mMsgEnabled;
- /*get stats buffer based on index*/
- camera_preview_histogram_info* hist_info =
- (camera_preview_histogram_info*) mHistServer.camera_memory[event->e.stats_histo.index]->data;
-
- if(mStatsOn == QCAMERA_PARM_ENABLE && mSendData &&
- mDataCb && (msgEnabled & CAMERA_MSG_STATS_DATA) ) {
- uint32_t *dest;
- mSendData = false;
- mCurrentHisto = (mCurrentHisto + 1) % 3;
- // The first element of the array will contain the maximum hist value provided by driver.
- *(uint32_t *)((unsigned int)(mStatsMapped[mCurrentHisto]->data)) = hist_info->max_value;
- memcpy((uint32_t *)((unsigned int)mStatsMapped[mCurrentHisto]->data + sizeof(int32_t)),
- (uint32_t *)hist_info->buffer,(sizeof(int32_t) * 256));
-
- app_cb->dataCb = mDataCb;
- app_cb->argm_data_cb.msg_type = CAMERA_MSG_STATS_DATA;
- app_cb->argm_data_cb.data = mStatsMapped[mCurrentHisto];
- app_cb->argm_data_cb.index = 0;
- app_cb->argm_data_cb.metadata = NULL;
- app_cb->argm_data_cb.cookie = mCallbackCookie;
- }
- break;
-
- }
- default:
- break;
- }
- ALOGV("receiveCameraStats X");
-}
-
-void QCameraHardwareInterface::processInfoEvent(
- mm_camera_info_event_t *event, app_notify_cb_t *app_cb) {
- ALOGI("processInfoEvent: %d, E",event->event_id);
- switch(event->event_id)
- {
- case MM_CAMERA_INFO_EVT_ROI:
- roiEvent(event->e.roi, app_cb);
- break;
- default:
- break;
- }
- ALOGI("processInfoEvent: X");
- return;
-}
-
-void QCameraHardwareInterface::processEvent(mm_camera_event_t *event)
-{
- app_notify_cb_t app_cb;
- ALOGE("processEvent: type :%d E",event->event_type);
- if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED){
- ALOGE("Stop recording issued. Return from process Event");
- return;
- }
- memset(&app_cb, 0, sizeof(app_notify_cb_t));
- switch(event->event_type)
- {
- case MM_CAMERA_EVT_TYPE_CH:
- processChannelEvent(&event->e.ch, &app_cb);
- break;
- case MM_CAMERA_EVT_TYPE_CTRL:
- processCtrlEvent(&event->e.ctrl, &app_cb);
- break;
- case MM_CAMERA_EVT_TYPE_STATS:
- processStatsEvent(&event->e.stats, &app_cb);
- break;
- case MM_CAMERA_EVT_TYPE_INFO:
- processInfoEvent(&event->e.info, &app_cb);
- break;
- default:
- break;
- }
- ALOGE(" App_cb Notify %p, datacb=%p", app_cb.notifyCb, app_cb.dataCb);
- if (app_cb.notifyCb) {
- app_cb.notifyCb(app_cb.argm_notify.msg_type,
- app_cb.argm_notify.ext1, app_cb.argm_notify.ext2,
- app_cb.argm_notify.cookie);
- }
- if (app_cb.dataCb) {
- app_cb.dataCb(app_cb.argm_data_cb.msg_type,
- app_cb.argm_data_cb.data, app_cb.argm_data_cb.index,
- app_cb.argm_data_cb.metadata, app_cb.argm_data_cb.cookie);
- }
- ALOGI("processEvent: X");
- return;
-}
-
-status_t QCameraHardwareInterface::startPreview()
-{
- status_t retVal = NO_ERROR;
-
- ALOGE("%s: mPreviewState =%d", __func__, mPreviewState);
- Mutex::Autolock lock(mLock);
-
- switch(mPreviewState) {
- case QCAMERA_HAL_TAKE_PICTURE:
- /* cancel pic internally */
- cancelPictureInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- /* then continue with start preview */
- case QCAMERA_HAL_PREVIEW_STOPPED:
- mPreviewState = QCAMERA_HAL_PREVIEW_START;
- ALOGE("%s: HAL::startPreview begin", __func__);
-
- if(QCAMERA_HAL_PREVIEW_START == mPreviewState &&
- (mPreviewWindow || isNoDisplayMode())) {
- ALOGE("%s: start preview now", __func__);
- retVal = startPreview2();
- if(retVal == NO_ERROR)
- mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
- } else {
- ALOGE("%s: received startPreview, but preview window = null", __func__);
- }
- break;
- case QCAMERA_HAL_PREVIEW_START:
- case QCAMERA_HAL_PREVIEW_STARTED:
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- ALOGE("%s: cannot start preview in recording state", __func__);
- break;
- default:
- ALOGE("%s: unknow state %d received", __func__, mPreviewState);
- retVal = UNKNOWN_ERROR;
- break;
- }
- return retVal;
-}
-
-status_t QCameraHardwareInterface::startPreview2()
-{
- ALOGV("startPreview2: E");
- status_t ret = NO_ERROR;
-
- cam_ctrl_dimension_t dim;
- mm_camera_dimension_t maxDim;
- uint32_t stream[2];
- mm_camera_bundle_attr_t attr;
-
- if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED) { //isPreviewRunning()){
- ALOGE("%s:Preview already started mPreviewState = %d!", __func__, mPreviewState);
- ALOGE("%s: X", __func__);
- return NO_ERROR;
- }
-
- /* config the parmeters and see if we need to re-init the stream*/
- ret = setDimension();
- if (MM_CAMERA_OK != ret) {
- ALOGE("%s: error - can't Set Dimensions!", __func__);
- return BAD_VALUE;
- }
-
- memset(&mHdrInfo, 0, sizeof(snap_hdr_record_t));
-
- if(isZSLMode()) {
- ALOGE("<DEBUGMODE>In ZSL mode");
- ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO");
- mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_ZSL;
- ret = mCameraHandle->ops->set_parm(
- mCameraHandle->camera_handle,
- MM_CAMERA_PARM_OP_MODE,
- &op_mode);
- ALOGE("OP Mode Set");
- /* Start preview streaming */
- /*now init all the buffers and send to steam object*/
- ret = mStreams[MM_CAMERA_PREVIEW]->initStream(FALSE, TRUE);
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't init Preview channel!", __func__);
- return BAD_VALUE;
- }
-
- /* Start ZSL stream */
- ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->initStream(TRUE, TRUE);
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't init Snapshot stream!", __func__);
- mStreams[MM_CAMERA_PREVIEW]->deinitStream();
- return BAD_VALUE;
- }
-
- stream[0] = mStreams[MM_CAMERA_PREVIEW]->mStreamId;
- stream[1] = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mStreamId;
-
- attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
- attr.burst_num = getNumOfSnapshots();
- attr.look_back = getZSLBackLookCount();
- attr.post_frame_skip = getZSLBurstInterval();
- attr.water_mark = getZSLQueueDepth();
- ALOGE("%s: burst_num=%d, look_back=%d, frame_skip=%d, water_mark=%d",
- __func__, attr.burst_num, attr.look_back,
- attr.post_frame_skip, attr.water_mark);
-
- ret = mCameraHandle->ops->init_stream_bundle(
- mCameraHandle->camera_handle,
- mChannelId,
- superbuf_cb_routine,
- this,
- &attr,
- 2,
- stream);
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't init zsl preview streams!", __func__);
- mStreams[MM_CAMERA_PREVIEW]->deinitStream();
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
- return BAD_VALUE;
- }
-
- ret = mStreams[MM_CAMERA_PREVIEW]->streamOn();
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't start preview stream!", __func__);
- mStreams[MM_CAMERA_PREVIEW]->deinitStream();
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
- return BAD_VALUE;
- }
-
- ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOn();
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't start snapshot stream!", __func__);
- mStreams[MM_CAMERA_PREVIEW]->streamOff(0);
- mStreams[MM_CAMERA_PREVIEW]->deinitStream();
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
- return BAD_VALUE;
- }
- }else{
- /*now init all the buffers and send to steam object*/
- ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO");
- mm_camera_op_mode_type_t op_mode = MM_CAMERA_OP_MODE_VIDEO;
- ret = mCameraHandle->ops->set_parm(
- mCameraHandle->camera_handle,
- MM_CAMERA_PARM_OP_MODE,
- &op_mode);
- ALOGE("OP Mode Set");
-
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_VIDEO err=%d\n", __func__, ret);
- return BAD_VALUE;
- }
- if(rdiMode == STREAM_RAW) {
- if(mStreams[MM_CAMERA_RDI] == NULL) {
- createRdi();
- }
- mStreams[MM_CAMERA_RDI]->initStream(FALSE, TRUE);
- ret = mStreams[MM_CAMERA_RDI]->streamOn();
- return ret;
- }
- /*now init all the buffers and send to steam object*/
- ret = mStreams[MM_CAMERA_PREVIEW]->initStream(FALSE, TRUE);
- ALOGE("%s : called initStream from Preview and ret = %d", __func__, ret);
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't init Preview channel!", __func__);
- return BAD_VALUE;
- }
- if(mRecordingHint == true) {
- ret = mStreams[MM_CAMERA_VIDEO]->initStream(FALSE, TRUE);
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't init Record channel!", __func__);
- mStreams[MM_CAMERA_PREVIEW]->deinitStream();
- return BAD_VALUE;
- }
- if (!canTakeFullSizeLiveshot()) {
- // video-size live snapshot, config same as video
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mFormat = mStreams[MM_CAMERA_VIDEO]->mFormat;
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mWidth = mStreams[MM_CAMERA_VIDEO]->mWidth;
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mHeight = mStreams[MM_CAMERA_VIDEO]->mHeight;
- ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->initStream(FALSE, FALSE);
- } else {
- ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->initStream(FALSE, TRUE);
- }
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't init Snapshot Main!", __func__);
- mStreams[MM_CAMERA_PREVIEW]->deinitStream();
- mStreams[MM_CAMERA_VIDEO]->deinitStream();
- return BAD_VALUE;
- }
-
- }
- ret = mStreams[MM_CAMERA_PREVIEW]->streamOn();
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't start preview stream!", __func__);
- if (mRecordingHint == true) {
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
- mStreams[MM_CAMERA_VIDEO]->deinitStream();
- mStreams[MM_CAMERA_PREVIEW]->deinitStream();
- }
- return BAD_VALUE;
- }
- }
-
- ALOGV("startPreview: X");
- return ret;
-}
-
-void QCameraHardwareInterface::stopPreview()
-{
- ALOGI("%s: stopPreview: E", __func__);
- Mutex::Autolock lock(mLock);
- //mm_camera_util_profile("HAL: stopPreview(): E");
- mFaceDetectOn = false;
-
- // reset recording hint to the value passed from Apps
- const char * str = mParameters.get(QCameraParameters::KEY_RECORDING_HINT);
- if((str != NULL) && !strcmp(str, "true")){
- mRecordingHint = TRUE;
- } else {
- mRecordingHint = FALSE;
- }
-
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_START:
- //mPreviewWindow = NULL;
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- break;
- case QCAMERA_HAL_PREVIEW_STARTED:
- cancelPictureInternal();
- stopPreviewInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- cancelPictureInternal();
- stopRecordingInternal();
- stopPreviewInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- cancelPictureInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- break;
- case QCAMERA_HAL_PREVIEW_STOPPED:
- default:
- break;
- }
- ALOGI("stopPreview: X, mPreviewState = %d", mPreviewState);
-}
-
-void QCameraHardwareInterface::stopPreviewInternal()
-{
- ALOGI("stopPreviewInternal: E");
- status_t ret = NO_ERROR;
-
- if(!mStreams[MM_CAMERA_PREVIEW]) {
- ALOGE("mStreamDisplay is null");
- return;
- }
-
- if(isZSLMode()) {
- mStreams[MM_CAMERA_PREVIEW]->streamOff(0);
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOff(0);
- ret = mCameraHandle->ops->destroy_stream_bundle(mCameraHandle->camera_handle,mChannelId);
- if(ret != MM_CAMERA_OK) {
- ALOGE("%s : ZSL destroy_stream_bundle Error",__func__);
- }
- }else{
- if(rdiMode == STREAM_RAW) {
- mStreams[MM_CAMERA_RDI]->streamOff(0);
- mStreams[MM_CAMERA_RDI]->deinitStream();
- return;
- }
- mStreams[MM_CAMERA_PREVIEW]->streamOff(0);
- }
- if (mStreams[MM_CAMERA_VIDEO])
- mStreams[MM_CAMERA_VIDEO]->deinitStream();
- if (mStreams[MM_CAMERA_SNAPSHOT_MAIN])
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
- mStreams[MM_CAMERA_PREVIEW]->deinitStream();
-
- ALOGI("stopPreviewInternal: X");
-}
-
-int QCameraHardwareInterface::previewEnabled()
-{
- ALOGI("previewEnabled: E");
- Mutex::Autolock lock(mLock);
- ALOGE("%s: mPreviewState = %d", __func__, mPreviewState);
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_START:
- case QCAMERA_HAL_PREVIEW_STARTED:
- case QCAMERA_HAL_RECORDING_STARTED:
- return true;
- default:
- return false;
- }
-}
-
-status_t QCameraHardwareInterface::startRecording()
-{
- ALOGI("startRecording: E");
- status_t ret = NO_ERROR;
- Mutex::Autolock lock(mLock);
-
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STOPPED:
- ALOGE("%s: preview has not been started", __func__);
- ret = UNKNOWN_ERROR;
- break;
- case QCAMERA_HAL_PREVIEW_START:
- ALOGE("%s: no preview native window", __func__);
- ret = UNKNOWN_ERROR;
- break;
- case QCAMERA_HAL_PREVIEW_STARTED:
- if (mRecordingHint == FALSE) {
- ALOGE("%s: start recording when hint is false, stop preview first", __func__);
- stopPreviewInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-
- // Set recording hint to TRUE
- mRecordingHint = TRUE;
- setRecordingHintValue(mRecordingHint);
-
- // start preview again
- mPreviewState = QCAMERA_HAL_PREVIEW_START;
- if (startPreview2() == NO_ERROR)
- mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
- }
- ret = mStreams[MM_CAMERA_VIDEO]->streamOn();
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - mStreamRecord->start!", __func__);
- ret = BAD_VALUE;
- break;
- }
- mPreviewState = QCAMERA_HAL_RECORDING_STARTED;
-
- if (mPowerModule) {
- if (mPowerModule->powerHint) {
- mPowerModule->powerHint(mPowerModule, POWER_HINT_VIDEO_ENCODE, (void *)"state=1");
- }
- }
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- ALOGE("%s: ", __func__);
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- default:
- ret = BAD_VALUE;
- break;
- }
- ALOGI("startRecording: X");
- return ret;
-}
-
-void QCameraHardwareInterface::stopRecording()
-{
- ALOGI("stopRecording: E");
- Mutex::Autolock lock(mLock);
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STOPPED:
- case QCAMERA_HAL_PREVIEW_START:
- case QCAMERA_HAL_PREVIEW_STARTED:
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- cancelPictureInternal();
- stopRecordingInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
-
- if (mPowerModule) {
- if (mPowerModule->powerHint) {
- mPowerModule->powerHint(mPowerModule, POWER_HINT_VIDEO_ENCODE, (void *)"state=0");
- }
- }
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- default:
- break;
- }
- ALOGI("stopRecording: X");
-
-}
-void QCameraHardwareInterface::stopRecordingInternal()
-{
- ALOGI("stopRecordingInternal: E");
- status_t ret = NO_ERROR;
-
- if(!mStreams[MM_CAMERA_VIDEO]) {
- ALOGE("mStreamRecord is null");
- return;
- }
-
- /*
- * call QCameraStream_record::stop()
- * Unregister Callback, action stop
- */
- mStreams[MM_CAMERA_VIDEO]->streamOff(0);
- mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
- ALOGI("stopRecordingInternal: X");
- return;
-}
-
-int QCameraHardwareInterface::recordingEnabled()
-{
- int ret = 0;
- Mutex::Autolock lock(mLock);
- ALOGV("%s: E", __func__);
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STOPPED:
- case QCAMERA_HAL_PREVIEW_START:
- case QCAMERA_HAL_PREVIEW_STARTED:
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- ret = 1;
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- default:
- break;
- }
- ALOGV("%s: X, ret = %d", __func__, ret);
- return ret; //isRecordingRunning();
-}
-
-/**
-* Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
-*/
-void QCameraHardwareInterface::releaseRecordingFrame(const void *opaque)
-{
- ALOGV("%s : BEGIN",__func__);
- if(mStreams[MM_CAMERA_VIDEO] == NULL) {
- ALOGE("Record stream Not Initialized");
- return;
- }
- mStreams[MM_CAMERA_VIDEO]->releaseRecordingFrame(opaque);
- ALOGV("%s : END",__func__);
- return;
-}
-
-status_t QCameraHardwareInterface::autoFocusEvent(cam_ctrl_status_t *status, app_notify_cb_t *app_cb)
-{
- ALOGE("autoFocusEvent: E");
- int ret = NO_ERROR;
-/************************************************************
- BEGIN MUTEX CODE
-*************************************************************/
-
- ALOGE("%s:%d: Trying to acquire AF bit lock",__func__,__LINE__);
- mAutofocusLock.lock();
- ALOGE("%s:%d: Acquired AF bit lock",__func__,__LINE__);
-
- if(mAutoFocusRunning==false) {
- ALOGE("%s:AF not running, discarding stale event",__func__);
- mAutofocusLock.unlock();
- return ret;
- }
-
- /* If autofocus call has been made during CAF, CAF will be locked.
- * We specifically need to call cancelAutoFocus to unlock CAF.
- * In that sense, AF is still running.*/
- isp3a_af_mode_t afMode = getAutoFocusMode(mParameters);
- if (afMode == AF_MODE_CAF) {
- mNeedToUnlockCaf = true;
- }
- mAutoFocusRunning = false;
- mAutofocusLock.unlock();
-
-/************************************************************
- END MUTEX CODE
-*************************************************************/
- if(status==NULL) {
- ALOGE("%s:NULL ptr received for status",__func__);
- return BAD_VALUE;
- }
-
- /* update focus distances after autofocus is done */
- if(updateFocusDistances() != NO_ERROR) {
- ALOGE("%s: updateFocusDistances failed for %d", __FUNCTION__, mFocusMode);
- }
-
- /*(Do?) we need to make sure that the call back is the
- last possible step in the execution flow since the same
- context might be used if a fail triggers another round
- of AF then the mAutoFocusRunning flag and other state
- variables' validity will be under question*/
-
- if (mNotifyCb && ( mMsgEnabled & CAMERA_MSG_FOCUS)){
- ALOGE("%s:Issuing callback to service",__func__);
-
- /* "Accepted" status is not appropriate it should be used for
- initial cmd, event reporting should only give use SUCCESS/FAIL
- */
-
- app_cb->notifyCb = mNotifyCb;
- app_cb->argm_notify.msg_type = CAMERA_MSG_FOCUS;
- app_cb->argm_notify.ext2 = 0;
- app_cb->argm_notify.cookie = mCallbackCookie;
-
- ALOGE("Auto foucs state =%d", *status);
- if(*status==CAM_CTRL_SUCCESS) {
- app_cb->argm_notify.ext1 = true;
- }
- else if(*status==CAM_CTRL_FAILED){
- app_cb->argm_notify.ext1 = false;
- }
- else{
- app_cb->notifyCb = NULL;
- ALOGE("%s:Unknown AF status (%d) received",__func__,*status);
- }
-
- }/*(mNotifyCb && ( mMsgEnabled & CAMERA_MSG_FOCUS))*/
- else{
- ALOGE("%s:Call back not enabled",__func__);
- }
-
- ALOGE("autoFocusEvent: X");
- return ret;
-
-}
-
-status_t QCameraHardwareInterface::cancelPicture()
-{
- ALOGI("cancelPicture: E, mPreviewState = %d", mPreviewState);
- status_t ret = MM_CAMERA_OK;
- Mutex::Autolock lock(mLock);
-
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STOPPED:
- case QCAMERA_HAL_PREVIEW_START:
- case QCAMERA_HAL_PREVIEW_STARTED:
- default:
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- ret = cancelPictureInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- ret = cancelPictureInternal();
- break;
- }
- ALOGI("cancelPicture: X");
- return ret;
-}
-
-status_t QCameraHardwareInterface::cancelPictureInternal()
-{
- ALOGI("%s: E mPreviewState=%d", __func__ , mPreviewState);
- status_t ret = MM_CAMERA_OK;
-
- /* set rawdata proc thread and jpeg notify thread to inactive state */
- /* no need for notify thread as a sync call for stop cmd */
- mNotifyTh->sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC, FALSE, TRUE);
- /* dataProc Thread need to process "stop" as sync call because abort jpeg job should be a sync call*/
- mDataProcTh->sendCmd(CAMERA_CMD_TYPE_STOP_DATA_PROC, TRUE, TRUE);
-
- if (isZSLMode()) {
- ret = mCameraHandle->ops->cancel_super_buf_request(mCameraHandle->camera_handle, mChannelId);
- } else {
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOff(0);
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->streamOff(0);
- ret = mCameraHandle->ops->destroy_stream_bundle(mCameraHandle->camera_handle, mChannelId);
- if(ret != MM_CAMERA_OK) {
- ALOGE("%s : destroy_stream_bundle Error",__func__);
- }
- if(mPreviewState != QCAMERA_HAL_RECORDING_STARTED) {
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->deinitStream();
- }
- }
- ALOGI("cancelPictureInternal: X");
- return ret;
-}
-
-status_t QCameraHardwareInterface::takePicture()
-{
- ALOGE("takePicture: E");
- status_t ret = MM_CAMERA_OK;
- uint32_t stream_info;
- uint32_t stream[2];
- mm_camera_bundle_attr_t attr;
- mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_CAPTURE;
- int num_streams = 0;
- Mutex::Autolock lock(mLock);
-
- /* set rawdata proc thread and jpeg notify thread to active state */
- mNotifyTh->sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, FALSE, FALSE);
- mDataProcTh->sendCmd(CAMERA_CMD_TYPE_START_DATA_PROC, FALSE, FALSE);
-
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STARTED:
- {
- if (isZSLMode()) {
- ALOGE("ZSL: takePicture");
-
- ret = mCameraHandle->ops->request_super_buf(
- mCameraHandle->camera_handle,
- mChannelId,
- getNumOfSnapshots());
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't start Snapshot streams!", __func__);
- return BAD_VALUE;
- }
- return ret;
- }
-
- /*prepare snapshot, e.g LED*/
- takePicturePrepareHardware( );
-
- /* stop preview */
- stopPreviewInternal();
- /*Currently concurrent streaming is not enabled for snapshot
- So in snapshot mode, we turn of the RDI channel and configure backend
- for only pixel stream*/
-
- if (!isRawSnapshot()) {
- op_mode=MM_CAMERA_OP_MODE_CAPTURE;
- } else {
- ALOGV("%s: Raw snapshot so setting op mode to raw", __func__);
- op_mode=MM_CAMERA_OP_MODE_RAW;
- }
- ret = mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_OP_MODE, &op_mode);
-
- if(MM_CAMERA_OK != ret) {
- ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_CAPTURE err=%d\n", __func__, ret);
- return BAD_VALUE;
- }
-
- ret = setDimension();
- if (MM_CAMERA_OK != ret) {
- ALOGE("%s: error - can't Set Dimensions!", __func__);
- return BAD_VALUE;
- }
-
- //added to support hdr
- bool hdr;
- int frm_num = 1;
- int exp[MAX_HDR_EXP_FRAME_NUM];
- hdr = getHdrInfoAndSetExp(MAX_HDR_EXP_FRAME_NUM, &frm_num, exp);
- initHdrInfoForSnapshot(hdr, frm_num, exp); // - for hdr figure out equivalent of mStreamSnap
- memset(&attr, 0, sizeof(mm_camera_bundle_attr_t));
- attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
-
- num_streams = 0;
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->initStream(TRUE, TRUE);
- if (NO_ERROR!=ret) {
- ALOGE("%s E: can't init native camera snapshot main ch\n",__func__);
- return ret;
- }
- stream[num_streams++] = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mStreamId;
-
- if (!isRawSnapshot()) {
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->initStream(TRUE, TRUE);
- if (NO_ERROR!=ret) {
- ALOGE("%s E: can't init native camera snapshot thumb ch\n",__func__);
- return ret;
- }
- stream[num_streams++] = mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mStreamId;
- }
- ret = mCameraHandle->ops->init_stream_bundle(
- mCameraHandle->camera_handle,
- mChannelId,
- superbuf_cb_routine,
- this,
- &attr,
- num_streams,
- stream);
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't init Snapshot streams!", __func__);
- return BAD_VALUE;
- }
- ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOn();
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't start Snapshot streams!", __func__);
- mCameraHandle->ops->destroy_stream_bundle(
- mCameraHandle->camera_handle,
- mChannelId);
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->deinitStream();
- return BAD_VALUE;
- }
- if (!isRawSnapshot()) {
- ret = mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->streamOn();
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't start Thumbnail streams!", __func__);
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOff(0);
- mCameraHandle->ops->destroy_stream_bundle(
- mCameraHandle->camera_handle,
- mChannelId);
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->deinitStream();
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->deinitStream();
- return BAD_VALUE;
- }
- }
- mPreviewState = QCAMERA_HAL_TAKE_PICTURE;
- }
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- break;
- case QCAMERA_HAL_PREVIEW_STOPPED:
- case QCAMERA_HAL_PREVIEW_START:
- ret = UNKNOWN_ERROR;
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- stream[0] = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mStreamId;
- memset(&attr, 0, sizeof(mm_camera_bundle_attr_t));
- attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
- ret = mCameraHandle->ops->init_stream_bundle(
- mCameraHandle->camera_handle,
- mChannelId,
- superbuf_cb_routine,
- this,
- &attr,
- 1,
- stream);
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't init Snapshot streams!", __func__);
- return BAD_VALUE;
- }
- ret = mStreams[MM_CAMERA_SNAPSHOT_MAIN]->streamOn();
- if (MM_CAMERA_OK != ret){
- ALOGE("%s: error - can't start Snapshot streams!", __func__);
- mCameraHandle->ops->destroy_stream_bundle(
- mCameraHandle->camera_handle,
- mChannelId);
- return BAD_VALUE;
- }
- break;
- default:
- ret = UNKNOWN_ERROR;
- break;
- }
- ALOGI("takePicture: X");
- return ret;
-}
-
-status_t QCameraHardwareInterface::autoFocus()
-{
- ALOGI("autoFocus: E");
- status_t ret = NO_ERROR;
-
- Mutex::Autolock lock(mLock);
- ALOGI("autoFocus: Got lock");
- bool status = true;
- isp3a_af_mode_t afMode = getAutoFocusMode(mParameters);
-
- if(mAutoFocusRunning==true){
- ALOGE("%s:AF already running should not have got this call",__func__);
- return NO_ERROR;
- }
-
- if (afMode == AF_MODE_MAX) {
- /* This should never happen. We cannot send a
- * callback notifying error from this place because
- * the CameraService has called this function after
- * acquiring the lock. So if we try to issue a callback
- * from this place, the callback will try to acquire
- * the same lock in CameraService and it will result
- * in deadlock. So, let the call go in to the lower
- * layer. The lower layer will anyway return error if
- * the autofocus is not supported or if the focus
- * value is invalid.
- * Just print out the error. */
- ALOGE("%s:Invalid AF mode (%d)", __func__, afMode);
- }
-
- ALOGI("%s:AF start (mode %d)", __func__, afMode);
- if(MM_CAMERA_OK != mCameraHandle->ops->start_focus(mCameraHandle->camera_handle,
- mChannelId,0,(uint32_t)&afMode)){
- ALOGE("%s: AF command failed err:%d error %s",
- __func__, errno, strerror(errno));
- return UNKNOWN_ERROR;
- }
-
- mAutoFocusRunning = true;
- ALOGE("autoFocus: X");
- return ret;
-}
-
-status_t QCameraHardwareInterface::cancelAutoFocus()
-{
- ALOGE("cancelAutoFocus: E");
- status_t ret = NO_ERROR;
- Mutex::Autolock lock(mLock);
-
-/**************************************************************
- BEGIN MUTEX CODE
-*************************************************************/
-
- mAutofocusLock.lock();
- if(mAutoFocusRunning || mNeedToUnlockCaf) {
-
- mAutoFocusRunning = false;
- mNeedToUnlockCaf = false;
- mAutofocusLock.unlock();
-
- }else/*(!mAutoFocusRunning)*/{
-
- mAutofocusLock.unlock();
- ALOGE("%s:Af not running",__func__);
- return NO_ERROR;
- }
-/**************************************************************
- END MUTEX CODE
-*************************************************************/
-
- if(MM_CAMERA_OK!= mCameraHandle->ops->abort_focus(mCameraHandle->camera_handle,
- mChannelId,0)){
- ALOGE("%s: AF command failed err:%d error %s",__func__, errno,strerror(errno));
- }
- ALOGE("cancelAutoFocus: X");
- return NO_ERROR;
-}
-
-/*==========================================================================
- * FUNCTION - processprepareSnapshotEvent -
- *
- * DESCRIPTION: Process the event of preparesnapshot done msg
- unblock prepareSnapshotAndWait( )
- *=========================================================================*/
-void QCameraHardwareInterface::processprepareSnapshotEvent(cam_ctrl_status_t *status)
-{
- ALOGI("processprepareSnapshotEvent: E");
- pthread_mutex_lock(&mAsyncCmdMutex);
- pthread_cond_signal(&mAsyncCmdWait);
- pthread_mutex_unlock(&mAsyncCmdMutex);
- ALOGI("processprepareSnapshotEvent: X");
-}
-
-void QCameraHardwareInterface::roiEvent(fd_roi_t roi,app_notify_cb_t *app_cb)
-{
- ALOGE("roiEvent: E");
-
- if(mStreams[MM_CAMERA_PREVIEW]) {
- mStreams[MM_CAMERA_PREVIEW]->notifyROIEvent(roi);
- }
- ALOGE("roiEvent: X");
-}
-
-
-void QCameraHardwareInterface::handleZoomEventForSnapshot(void)
-{
- ALOGI("%s: E", __func__);
-
- if (mStreams[MM_CAMERA_SNAPSHOT_MAIN] != NULL) {
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->setCrop();
- }
- if (mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL] != NULL) {
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->setCrop();
- }
- ALOGI("%s: X", __func__);
-}
-
-void QCameraHardwareInterface::handleZoomEventForPreview(app_notify_cb_t *app_cb)
-{
- ALOGI("%s: E", __func__);
-
- /*regular zooming or smooth zoom stopped*/
- if (mStreams[MM_CAMERA_PREVIEW] != NULL) {
- ALOGI("%s: Fetching crop info", __func__);
- mStreams[MM_CAMERA_PREVIEW]->setCrop();
- ALOGI("%s: Currrent zoom :%d",__func__, mCurrentZoom);
- }
-
- ALOGI("%s: X", __func__);
-}
-
-void QCameraHardwareInterface::zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *app_cb)
-{
- ALOGI("zoomEvent: state:%d E",mPreviewState);
- switch (mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STOPPED:
- break;
- case QCAMERA_HAL_PREVIEW_START:
- break;
- case QCAMERA_HAL_PREVIEW_STARTED:
- handleZoomEventForPreview(app_cb);
- if (isZSLMode())
- handleZoomEventForSnapshot();
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- handleZoomEventForPreview(app_cb);
- if (mFullLiveshotEnabled)
- handleZoomEventForSnapshot();
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- if(isZSLMode())
- handleZoomEventForPreview(app_cb);
- handleZoomEventForSnapshot();
- break;
- default:
- break;
- }
- ALOGI("zoomEvent: X");
-}
-
-void QCameraHardwareInterface::dumpFrameToFile(const void * data, uint32_t size, char* name, char* ext, int index)
-{
- char buf[32];
- int file_fd;
- if ( data != NULL) {
- char * str;
- snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name, index, ext);
- ALOGE("marvin, %s size =%d", buf, size);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- write(file_fd, data, size);
- close(file_fd);
- }
-}
-
-void QCameraHardwareInterface::dumpFrameToFile(mm_camera_buf_def_t* newFrame,
- HAL_cam_dump_frm_type_t frm_type)
-{
- ALOGV("%s: E", __func__);
- int32_t enabled = 0;
- int frm_num;
- uint32_t skip_mode;
- char value[PROPERTY_VALUE_MAX];
- char buf[32];
- int main_422 = 1;
- property_get("persist.camera.dumpimg", value, "0");
- enabled = atoi(value);
-
- ALOGV(" newFrame =%p, frm_type = %x, enabled=%x", newFrame, frm_type, enabled);
- if(enabled & HAL_DUMP_FRM_MASK_ALL) {
- if((enabled & frm_type) && newFrame) {
- frm_num = ((enabled & 0xffff0000) >> 16);
- if(frm_num == 0) frm_num = 10; /*default 10 frames*/
- if(frm_num > 256) frm_num = 256; /*256 buffers cycle around*/
- skip_mode = ((enabled & 0x0000ff00) >> 8);
- if(skip_mode == 0) skip_mode = 1; /*no -skip */
-
- if( mDumpSkipCnt % skip_mode == 0) {
- if (mDumpFrmCnt >= 0 && mDumpFrmCnt <= frm_num) {
- int w, h;
- int file_fd;
- switch (frm_type) {
- case HAL_DUMP_FRM_PREVIEW:
- w = mDimension.display_width;
- h = mDimension.display_height;
- snprintf(buf, sizeof(buf), "/data/%dp_%dx%d_%d.yuv", mDumpFrmCnt, w, h, newFrame->frame_idx);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- break;
- case HAL_DUMP_FRM_VIDEO:
- w = mDimension.video_width;
- h = mDimension.video_height;
- snprintf(buf, sizeof(buf),"/data/%dv_%dx%d_%d.yuv", mDumpFrmCnt, w, h, newFrame->frame_idx);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- break;
- case HAL_DUMP_FRM_MAIN:
- w = mDimension.picture_width;
- h = mDimension.picture_height;
- snprintf(buf, sizeof(buf), "/data/%dm_%dx%d_%d.yuv", mDumpFrmCnt, w, h, newFrame->frame_idx);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- if (mDimension.main_img_format == CAMERA_YUV_422_NV16 ||
- mDimension.main_img_format == CAMERA_YUV_422_NV61)
- main_422 = 2;
- break;
- case HAL_DUMP_FRM_THUMBNAIL:
- w = mDimension.ui_thumbnail_width;
- h = mDimension.ui_thumbnail_height;
- snprintf(buf, sizeof(buf),"/data/%dt_%dx%d_%d.yuv", mDumpFrmCnt, w, h, newFrame->frame_idx);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- break;
- case HAL_DUMP_FRM_RDI:
- w = mRdiWidth;
- h = mRdiHeight;
- snprintf(buf, sizeof(buf),"/data/%dr_%dx%d.raw", mDumpFrmCnt, w, h);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- break;
- default:
- w = h = 0;
- file_fd = -1;
- break;
- }
-
- if (file_fd < 0) {
- ALOGE("%s: cannot open file:type=%d\n", __func__, frm_type);
- } else {
- write(file_fd, (const void *)(newFrame->buffer), w * h);
- write(file_fd, (const void *)
- (newFrame->buffer), w * h / 2 * main_422);
- close(file_fd);
- ALOGE("dump %s", buf);
- }
- } else if(frm_num == 256){
- mDumpFrmCnt = 0;
- }
- mDumpFrmCnt++;
- }
- mDumpSkipCnt++;
- }
- } else {
- mDumpFrmCnt = 0;
- }
- ALOGV("%s: X", __func__);
-}
-
-status_t QCameraHardwareInterface::setPreviewWindow(preview_stream_ops_t* window)
-{
- status_t retVal = NO_ERROR;
- ALOGE(" %s: E mPreviewState = %d, mStreamDisplay = %p",
- __func__, mPreviewState, mStreams[MM_CAMERA_PREVIEW]);
- if( window == NULL) {
- ALOGE("%s:Received Setting NULL preview window", __func__);
- }
- Mutex::Autolock lock(mLock);
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_START:
- mPreviewWindow = window;
- if(mPreviewWindow) {
- /* we have valid surface now, start preview */
- ALOGE("%s: calling startPreview2", __func__);
- retVal = startPreview2();
- if(retVal == NO_ERROR)
- mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
- ALOGE("%s: startPreview2 done, mPreviewState = %d", __func__, mPreviewState);
- } else
- ALOGE("%s: null window received, mPreviewState = %d", __func__, mPreviewState);
- break;
- case QCAMERA_HAL_PREVIEW_STARTED:
- /* new window comes */
- ALOGE("%s: bug, cannot handle new window in started state", __func__);
- //retVal = UNKNOWN_ERROR;
- break;
- case QCAMERA_HAL_PREVIEW_STOPPED:
- case QCAMERA_HAL_TAKE_PICTURE:
- mPreviewWindow = window;
- ALOGE("%s: mPreviewWindow = 0x%p, mStreamDisplay = 0x%p",
- __func__, mPreviewWindow, mStreams[MM_CAMERA_PREVIEW]);
- break;
- default:
- ALOGE("%s: bug, cannot handle new window in state %d", __func__, mPreviewState);
- retVal = UNKNOWN_ERROR;
- break;
- }
- ALOGE(" %s : X, mPreviewState = %d", __FUNCTION__, mPreviewState);
- return retVal;
-}
-
-int QCameraHardwareInterface::storeMetaDataInBuffers(int enable)
-{
- /* this is a dummy func now. fix me later */
- mStoreMetaDataInFrame = enable;
- return 0;
-}
-
-int QCameraHardwareInterface::allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type)
-{
- int rc = 0;
- struct ion_handle_data handle_data;
- struct ion_allocation_data alloc;
- struct ion_fd_data ion_info_fd;
- int main_ion_fd = 0;
-
- main_ion_fd = open("/dev/ion", O_RDONLY);
- if (main_ion_fd <= 0) {
- ALOGE("Ion dev open failed %s\n", strerror(errno));
- goto ION_OPEN_FAILED;
- }
-
- memset(&alloc, 0, sizeof(alloc));
- alloc.len = mem_info->size;
- /* to make it page size aligned */
- alloc.len = (alloc.len + 4095) & (~4095);
- alloc.align = 4096;
- alloc.flags = ION_FLAG_CACHED;
- alloc.heap_mask = ion_type;
- rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &alloc);
- if (rc < 0) {
- ALOGE("ION allocation failed\n");
- goto ION_ALLOC_FAILED;
- }
-
- memset(&ion_info_fd, 0, sizeof(ion_info_fd));
- ion_info_fd.handle = alloc.handle;
- rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd);
- if (rc < 0) {
- ALOGE("ION map failed %s\n", strerror(errno));
- goto ION_MAP_FAILED;
- }
-
- mem_info->main_ion_fd = main_ion_fd;
- mem_info->fd = ion_info_fd.fd;
- mem_info->handle = ion_info_fd.handle;
- mem_info->size = alloc.len;
- return 0;
-
-ION_MAP_FAILED:
- memset(&handle_data, 0, sizeof(handle_data));
- handle_data.handle = ion_info_fd.handle;
- ioctl(main_ion_fd, ION_IOC_FREE, &handle_data);
-ION_ALLOC_FAILED:
- close(main_ion_fd);
-ION_OPEN_FAILED:
- return -1;
-}
-
-int QCameraHardwareInterface::deallocate_ion_memory(QCameraHalMemInfo_t *mem_info)
-{
- struct ion_handle_data handle_data;
- int rc = 0;
-
- if (mem_info->fd > 0) {
- close(mem_info->fd);
- mem_info->fd = 0;
- }
-
- if (mem_info->main_ion_fd > 0) {
- memset(&handle_data, 0, sizeof(handle_data));
- handle_data.handle = mem_info->handle;
- ioctl(mem_info->main_ion_fd, ION_IOC_FREE, &handle_data);
- close(mem_info->main_ion_fd);
- mem_info->main_ion_fd = 0;
- }
- return rc;
-}
-
-int QCameraHardwareInterface::initHeapMem( QCameraHalHeap_t *heap,
- int num_of_buf,
- uint32_t buf_len,
- int pmem_type,
- mm_camera_frame_len_offset* offset,
- mm_camera_buf_def_t *buf_def)
-{
- int rc = 0;
- int i;
- int path;
- ALOGE("Init Heap =%p. pmem_type =%d, num_of_buf=%d. buf_len=%d",
- heap, pmem_type, num_of_buf, buf_len);
- if(num_of_buf > MM_CAMERA_MAX_NUM_FRAMES || heap == NULL ||
- mGetMemory == NULL ) {
- ALOGE("Init Heap error");
- rc = -1;
- return rc;
- }
-
- memset(heap, 0, sizeof(QCameraHalHeap_t));
- heap->buffer_count = num_of_buf;
- for(i = 0; i < num_of_buf; i++) {
- heap->mem_info[i].size = buf_len;
-#ifdef USE_ION
- if (isZSLMode()) {
- rc = allocate_ion_memory(&heap->mem_info[i],
- ((0x1 << CAMERA_ZSL_ION_HEAP_ID) | (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
- }
- else {
- rc = allocate_ion_memory(&heap->mem_info[i],
- ((0x1 << CAMERA_ION_HEAP_ID) | (0x1 << CAMERA_ION_FALLBACK_HEAP_ID)));
- }
-
- if (rc < 0) {
- ALOGE("%s: ION allocation failed\n", __func__);
- break;
- }
-#else
- if (pmem_type == MSM_PMEM_MAX){
- ALOGE("%s : USE_ION not defined, pmemtype == MSM_PMEM_MAX, so ret -1", __func__);
- rc = -1;
- break;
- }
- else {
- heap->mem_info[i].fd = open("/dev/pmem_adsp", O_RDWR|O_SYNC);
- if ( heap->mem_info[i].fd <= 0) {
- ALOGE("Open fail: heap->fd[%d] =%d", i, heap->mem_info[i].fd);
- rc = -1;
- break;
- }
- }
-#endif
- heap->camera_memory[i] = mGetMemory(heap->mem_info[i].fd,
- heap->mem_info[i].size,
- 1,
- (void *)this);
-
- if (heap->camera_memory[i] == NULL ) {
- ALOGE("Getmem fail %d: ", i);
- rc = -1;
- break;
- }
-
- if(buf_def != NULL && offset != NULL) {
- buf_def[i].fd = heap->mem_info[i].fd;
- buf_def[i].frame_len = heap->mem_info[i].size;
- buf_def[i].buffer = heap->camera_memory[i]->data;
- buf_def[i].mem_info = (void *)&heap->mem_info[i];
- buf_def[i].num_planes = offset->num_planes;
- /* Plane 0 needs to be set seperately. Set other planes
- * in a loop. */
- buf_def[i].planes[0].length = offset->mp[0].len;
- buf_def[i].planes[0].m.userptr = heap->mem_info[i].fd;
- buf_def[i].planes[0].data_offset = offset->mp[0].offset;
- buf_def[i].planes[0].reserved[0] = 0;
- for (int j = 1; j < buf_def[i].num_planes; j++) {
- buf_def[i].planes[j].length = offset->mp[j].len;
- buf_def[i].planes[j].m.userptr = heap->mem_info[i].fd;
- buf_def[i].planes[j].data_offset = offset->mp[j].offset;
- buf_def[i].planes[j].reserved[0] =
- buf_def[i].planes[j-1].reserved[0] +
- buf_def[i].planes[j-1].length;
- }
- }
-
- ALOGE("heap->fd[%d] =%d, camera_memory=%p", i,
- heap->mem_info[i].fd, heap->camera_memory[i]);
- heap->local_flag[i] = 1;
- }
- if( rc < 0) {
- releaseHeapMem(heap);
- }
- return rc;
-}
-
-int QCameraHardwareInterface::releaseHeapMem(QCameraHalHeap_t *heap)
-{
- int rc = 0;
- ALOGE("Release %p", heap);
- if (heap != NULL) {
- for (int i = 0; i < heap->buffer_count; i++) {
- if(heap->camera_memory[i] != NULL) {
- heap->camera_memory[i]->release( heap->camera_memory[i] );
- heap->camera_memory[i] = NULL;
- } else if (heap->mem_info[i].fd <= 0) {
- ALOGE("impossible: camera_memory[%d] = %p, fd = %d",
- i, heap->camera_memory[i], heap->mem_info[i].fd);
- }
-
-#ifdef USE_ION
- deallocate_ion_memory(&heap->mem_info[i]);
-#endif
- }
- memset(heap, 0, sizeof(QCameraHalHeap_t));
- }
- return rc;
-}
-
-preview_format_info_t QCameraHardwareInterface::getPreviewFormatInfo( )
-{
- return mPreviewFormatInfo;
-}
-
-void QCameraHardwareInterface::wdenoiseEvent(cam_ctrl_status_t status, void *cookie)
-{
-
-}
-
-bool QCameraHardwareInterface::isWDenoiseEnabled()
-{
- return mDenoiseValue;
-}
-
-void QCameraHardwareInterface::takePicturePrepareHardware()
-{
- ALOGV("%s: E", __func__);
-
- /* Prepare snapshot*/
- mCameraHandle->ops->prepare_snapshot(mCameraHandle->camera_handle,
- mChannelId,
- 0);
- ALOGV("%s: X", __func__);
-}
-
-bool QCameraHardwareInterface::isNoDisplayMode()
-{
- return (mNoDisplayMode != 0);
-}
-
-void QCameraHardwareInterface::restartPreview()
-{
- if (QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) {
- stopPreviewInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- }
- startPreview2();
- mPreviewState = QCAMERA_HAL_PREVIEW_STARTED;
-}
-
-// added to support hdr
-bool QCameraHardwareInterface::getHdrInfoAndSetExp(int max_num_frm, int *num_frame, int *exp)
-{
- bool rc = FALSE;
- ALOGE("%s, mHdrMode = %d, HDR_MODE = %d", __func__, mHdrMode, HDR_MODE);
- if (mHdrMode == HDR_MODE && num_frame != NULL && exp != NULL &&
- mRecordingHint != TRUE &&
- mPreviewState != QCAMERA_HAL_RECORDING_STARTED ) {
- ALOGE("%s : mHdrMode == HDR_MODE", __func__);
- int ret = 0;
- *num_frame = 1;
- exp_bracketing_t temp;
- memset(&temp, 0, sizeof(exp_bracketing_t));
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_HDR, (void *)&temp );
- ALOGE("hdr - %s : ret = %d", __func__, ret);
- if (ret == NO_ERROR && max_num_frm > 0) {
- ALOGE("%s ret == NO_ERROR and max_num_frm = %d", __func__, max_num_frm);
- /*set as AE Bracketing mode*/
- temp.hdr_enable = FALSE;
- temp.mode = HDR_MODE;
- temp.total_hal_frames = temp.total_frames;
- ret = native_set_parms(MM_CAMERA_PARM_HDR,
- sizeof(exp_bracketing_t), (void *)&temp);
- ALOGE("%s, ret from set_parm = %d", __func__, ret);
- if (ret) {
- char *val, *exp_value, *prev_value;
- int i;
- exp_value = (char *) temp.values;
- i = 0;
- val = strtok_r(exp_value,",", &prev_value);
- while (val != NULL ){
- exp[i++] = atoi(val);
- if(i >= max_num_frm )
- break;
- val = strtok_r(NULL, ",", &prev_value);
- }
- *num_frame =temp.total_frames;
- rc = TRUE;
- }
- } else {
- temp.total_frames = 1;
- }
- /* Application waits until this many snapshots before restarting preview */
- mParameters.set("num-snaps-per-shutter", 2);
- }
- ALOGE("%s, hdr - rc = %d, num_frame = %d", __func__, rc, *num_frame);
- return rc;
-}
-
-status_t QCameraHardwareInterface::initHistogramBuffers()
-{
- int page_size_minus_1 = getpagesize() - 1;
- int statSize = sizeof (camera_preview_histogram_info );
- int32_t mAlignedStatSize = ((statSize + page_size_minus_1)
- & (~page_size_minus_1));
- mm_camera_frame_map_type map_buf;
- ALOGI("%s E ", __func__);
-
- if (mHistServer.active) {
- ALOGI("%s Previous buffers not deallocated yet. ", __func__);
- return BAD_VALUE;
- }
-
- mStatSize = sizeof(uint32_t) * HISTOGRAM_STATS_SIZE;
- mCurrentHisto = -1;
-
- memset(&map_buf, 0, sizeof(map_buf));
- for(int cnt = 0; cnt < NUM_HISTOGRAM_BUFFERS; cnt++) {
- mStatsMapped[cnt] = mGetMemory(-1, mStatSize, 1, mCallbackCookie);
- if(mStatsMapped[cnt] == NULL) {
- ALOGE("Failed to get camera memory for stats heap index: %d", cnt);
- return NO_MEMORY;
- } else {
- ALOGI("Received following info for stats mapped data:%p,handle:%p,"
- " size:%d,release:%p", mStatsMapped[cnt]->data,
- mStatsMapped[cnt]->handle, mStatsMapped[cnt]->size,
- mStatsMapped[cnt]->release);
- }
- mHistServer.mem_info[cnt].size = sizeof(camera_preview_histogram_info);
-#ifdef USE_ION
- int flag = (0x1 << ION_CP_MM_HEAP_ID | 0x1 << ION_IOMMU_HEAP_ID);
- if(allocate_ion_memory(&mHistServer.mem_info[cnt], flag) < 0) {
- ALOGE("%s ION alloc failed for %d\n", __func__, cnt);
- return NO_MEMORY;
- }
-#else
- mHistServer.mem_info[cnt].fd = open("/dev/pmem_adsp", O_RDWR|O_SYNC);
- if(mHistServer.mem_info[cnt].fd <= 0) {
- ALOGE("%s: no pmem for frame %d", __func__, cnt);
- return NO_INIT;
- }
-#endif
- mHistServer.camera_memory[cnt] = mGetMemory(mHistServer.mem_info[cnt].fd,
- mHistServer.mem_info[cnt].size,
- 1,
- mCallbackCookie);
- if(mHistServer.camera_memory[cnt] == NULL) {
- ALOGE("Failed to get camera memory for server side "
- "histogram index: %d", cnt);
- return NO_MEMORY;
- } else {
- ALOGE("Received following info for server side histogram data:%p,"
- " handle:%p, size:%d,release:%p",
- mHistServer.camera_memory[cnt]->data,
- mHistServer.camera_memory[cnt]->handle,
- mHistServer.camera_memory[cnt]->size,
- mHistServer.camera_memory[cnt]->release);
- }
- /*Register buffer at back-end*/
- map_buf.fd = mHistServer.mem_info[cnt].fd;
- map_buf.frame_idx = cnt;
- map_buf.size = mHistServer.mem_info[cnt].size;
- map_buf.ext_mode = 0;
- map_buf.is_hist = TRUE;
- mCameraHandle->ops->send_command(mCameraHandle->camera_handle,
- MM_CAMERA_CMD_TYPE_NATIVE,
- NATIVE_CMD_ID_SOCKET_MAP,
- sizeof(map_buf), &map_buf);
- }
- mHistServer.active = TRUE;
- ALOGI("%s X", __func__);
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::deInitHistogramBuffers()
-{
- mm_camera_frame_unmap_type unmap_buf;
- memset(&unmap_buf, 0, sizeof(unmap_buf));
-
- ALOGI("%s E", __func__);
-
- if (!mHistServer.active) {
- ALOGI("%s Histogram buffers not active. return. ", __func__);
- return NO_ERROR;
- }
-
- //release memory
- for(int i = 0; i < NUM_HISTOGRAM_BUFFERS; i++) {
- if(mStatsMapped[i] != NULL) {
- mStatsMapped[i]->release(mStatsMapped[i]);
- }
-
- unmap_buf.ext_mode = 0;
- unmap_buf.frame_idx = i;
- unmap_buf.is_hist = TRUE;
- mCameraHandle->ops->send_command(mCameraHandle->camera_handle,
- MM_CAMERA_CMD_TYPE_NATIVE,
- NATIVE_CMD_ID_SOCKET_UNMAP,
- sizeof(unmap_buf), &unmap_buf);
-
- if(mHistServer.camera_memory[i] != NULL) {
- mHistServer.camera_memory[i]->release(mHistServer.camera_memory[i]);
- }
-#ifdef USE_ION
- deallocate_ion_memory(&mHistServer.mem_info[i]);
-#endif
- }
- mHistServer.active = FALSE;
- ALOGI("%s X", __func__);
- return NO_ERROR;
-}
-
-mm_jpeg_color_format QCameraHardwareInterface::getColorfmtFromImgFmt(uint32_t img_fmt)
-{
- switch (img_fmt) {
- case CAMERA_YUV_420_NV21:
- return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
- case CAMERA_YUV_420_NV21_ADRENO:
- return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
- case CAMERA_YUV_420_NV12:
- return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2;
- case CAMERA_YUV_420_YV12:
- return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2;
- case CAMERA_YUV_422_NV61:
- return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1;
- case CAMERA_YUV_422_NV16:
- return MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1;
- default:
- return MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
- }
-}
-
-void QCameraHardwareInterface::doHdrProcessing()
-{
- cam_sock_packet_t packet;
- int i;
- memset(&packet, 0, sizeof(cam_sock_packet_t));
- packet.msg_type = CAM_SOCK_MSG_TYPE_HDR_START;
-
- packet.payload.hdr_pkg.cookie = (long unsigned int) this;
- packet.payload.hdr_pkg.num_hdr_frames = mHdrInfo.num_frame;
- ALOGI("%s num frames = %d ", __func__, mHdrInfo.num_frame);
- for (i = 0; i < mHdrInfo.num_frame; i++) {
- packet.payload.hdr_pkg.hdr_main_idx[i] =
- mHdrInfo.recvd_frame[i]->bufs[0]->buf_idx;
- packet.payload.hdr_pkg.hdr_thm_idx[i] =
- mHdrInfo.recvd_frame[i]->bufs[1]->buf_idx;
- packet.payload.hdr_pkg.exp[i] = mHdrInfo.exp[i];
- ALOGI("%s Adding buffer M %d T %d Exp %d into hdr pkg ", __func__,
- packet.payload.hdr_pkg.hdr_main_idx[i],
- packet.payload.hdr_pkg.hdr_thm_idx[i],
- packet.payload.hdr_pkg.exp[i]);
- }
- mCameraHandle->ops->send_command(mCameraHandle->camera_handle,
- MM_CAMERA_CMD_TYPE_NATIVE,
- NATIVE_CMD_ID_IOCTL_CTRL,
- sizeof(cam_sock_packet_t), &packet);
-}
-
-void QCameraHardwareInterface::initHdrInfoForSnapshot(bool Hdr_on, int number_frames, int *exp )
-{
- ALOGE("%s E hdr_on = %d", __func__, Hdr_on);
- mHdrInfo.hdr_on = Hdr_on;
- mHdrInfo.num_frame = number_frames;
- mHdrInfo.num_raw_received = 0;
- if(number_frames) {
- memcpy(mHdrInfo.exp, exp, sizeof(int)*number_frames);
- }
- memset(mHdrInfo.recvd_frame, 0,
- sizeof(mm_camera_super_buf_t *)*MAX_HDR_EXP_FRAME_NUM);
- ALOGE("%s X", __func__);
-}
-
-void QCameraHardwareInterface::notifyHdrEvent(cam_ctrl_status_t status, void * cookie)
-{
- ALOGE("%s E", __func__);
- mm_camera_super_buf_t *frame;
- int i;
- ALOGI("%s: HDR Done status (%d) received",__func__,status);
- for (i = 0; i < 2; i++) {
- frame = mHdrInfo.recvd_frame[i];
- mSuperBufQueue.enqueue(frame);
- /* notify dataNotify thread that new super buf is avail
- * check if it's done with current JPEG notification and
- * a new encoding job could be conducted */
- mNotifyTh->sendCmd(CAMERA_CMD_TYPE_DO_NEXT_JOB, FALSE, FALSE);
- mHdrInfo.recvd_frame[i] = NULL;
- }
- /* qbuf the third frame */
- frame = mHdrInfo.recvd_frame[2];
- for(i = 0; i < frame->num_bufs; i++) {
- mCameraHandle->ops->qbuf(frame->camera_handle,
- frame->ch_id,
- frame->bufs[i]);
- cache_ops((QCameraHalMemInfo_t *)(frame->bufs[i]->mem_info),
- frame->bufs[i]->buffer,
- ION_IOC_INV_CACHES);
- }
- free(frame);
- mHdrInfo.recvd_frame[2] = NULL;
-
- ALOGE("%s X", __func__);
-}
-
-int QCameraHardwareInterface::cache_ops(QCameraHalMemInfo_t *mem_info,
- void *buf_ptr,
- unsigned int cmd)
-{
- struct ion_flush_data cache_inv_data;
- struct ion_custom_data custom_data;
- int ret = MM_CAMERA_OK;
-
-#ifdef USE_ION
- if (NULL == mem_info) {
- ALOGE("%s: mem_info is NULL, return here", __func__);
- return -1;
- }
-
- memset(&cache_inv_data, 0, sizeof(cache_inv_data));
- memset(&custom_data, 0, sizeof(custom_data));
- cache_inv_data.vaddr = buf_ptr;
- cache_inv_data.fd = mem_info->fd;
- cache_inv_data.handle = mem_info->handle;
- cache_inv_data.length = mem_info->size;
- custom_data.cmd = cmd;
- custom_data.arg = (unsigned long)&cache_inv_data;
-
- ALOGD("addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d",
- cache_inv_data.vaddr, cache_inv_data.fd,
- cache_inv_data.handle, cache_inv_data.length,
- mem_info->main_ion_fd);
- if(mem_info->main_ion_fd > 0) {
- if(ioctl(mem_info->main_ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
- ALOGE("%s: Cache Invalidate failed\n", __func__);
- ret = -1;
- }
- }
-#endif
-
- return ret;
-}
-
-uint8_t QCameraHardwareInterface::canTakeFullSizeLiveshot() {
- if (mFullLiveshotEnabled && !isLowPowerCamcorder()) {
- /* Full size liveshot enabled. */
-
- /* If Picture size is same as video size, switch to Video size
- * live snapshot */
- if ((mDimension.picture_width == mDimension.video_width) &&
- (mDimension.picture_height == mDimension.video_height)) {
- return FALSE;
- }
-
- if (mDisEnabled) {
- /* If DIS is enabled and Picture size is
- * less than (video size + 10% DIS Margin)
- * then fall back to Video size liveshot. */
- if ((mDimension.picture_width <
- (int)(mDimension.video_width * 1.1)) ||
- (mDimension.picture_height <
- (int)(mDimension.video_height * 1.1))) {
- return FALSE;
- } else {
- /* Go with Full size live snapshot. */
- return TRUE;
- }
- } else {
- /* DIS Disabled. Go with Full size live snapshot */
- return TRUE;
- }
- } else {
- /* Full size liveshot disabled. Fallback to Video size liveshot. */
- return FALSE;
- }
-}
-
-QCameraQueue::QCameraQueue()
-{
- pthread_mutex_init(&mlock, NULL);
- cam_list_init(&mhead.list);
- msize = 0;
- mdata_rel_fn = NULL;
- muser_data = NULL;
-}
-
-QCameraQueue::QCameraQueue(release_data_fn data_rel_fn, void *user_data)
-{
- pthread_mutex_init(&mlock, NULL);
- cam_list_init(&mhead.list);
- msize = 0;
- mdata_rel_fn = data_rel_fn;
- muser_data = user_data;
-}
-
-QCameraQueue::~QCameraQueue()
-{
- flush();
- pthread_mutex_destroy(&mlock);
-}
-
-bool QCameraQueue::is_empty()
-{
- bool isEmpty = true;
- pthread_mutex_lock(&mlock);
- if (msize > 0) {
- isEmpty = false;
- }
- pthread_mutex_unlock(&mlock);
- return isEmpty;
-}
-
-bool QCameraQueue::enqueue(void *data)
-{
- camera_q_node *node =
- (camera_q_node *)malloc(sizeof(camera_q_node));
- if (NULL == node) {
- ALOGE("%s: No memory for camera_q_node", __func__);
- return false;
- }
-
- memset(node, 0, sizeof(camera_q_node));
- node->data = data;
-
- pthread_mutex_lock(&mlock);
- cam_list_add_tail_node(&node->list, &mhead.list);
- msize++;
- pthread_mutex_unlock(&mlock);
- return true;
-}
-
-/* priority queue, will insert into the head of the queue */
-bool QCameraQueue::pri_enqueue(void *data)
-{
- camera_q_node *node =
- (camera_q_node *)malloc(sizeof(camera_q_node));
- if (NULL == node) {
- ALOGE("%s: No memory for camera_q_node", __func__);
- return false;
- }
-
- memset(node, 0, sizeof(camera_q_node));
- node->data = data;
-
- pthread_mutex_lock(&mlock);
- struct cam_list *p_next = mhead.list.next;
-
- mhead.list.next = &node->list;
- p_next->prev = &node->list;
- node->list.next = p_next;
- node->list.prev = &mhead.list;
-
- msize++;
- pthread_mutex_unlock(&mlock);
- return true;
-}
-
-void* QCameraQueue::dequeue()
-{
- camera_q_node* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&mlock);
- head = &mhead.list;
- pos = head->next;
- if (pos != head) {
- node = member_of(pos, camera_q_node, list);
- cam_list_del_node(&node->list);
- msize--;
- }
- pthread_mutex_unlock(&mlock);
-
- if (NULL != node) {
- data = node->data;
- free(node);
- }
-
- return data;
-}
-
-void QCameraQueue::flush(){
- camera_q_node* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&mlock);
- head = &mhead.list;
- pos = head->next;
-
- while(pos != head) {
- node = member_of(pos, camera_q_node, list);
- pos = pos->next;
- cam_list_del_node(&node->list);
- msize--;
-
- if (NULL != node->data) {
- if (mdata_rel_fn) {
- mdata_rel_fn(node->data, muser_data);
- }
- free(node->data);
- }
- free(node);
-
- }
- msize = 0;
- pthread_mutex_unlock(&mlock);
-}
-
-QCameraCmdThread::QCameraCmdThread() :
- cmd_queue()
-{
- sem_init(&sync_sem, 0, 0);
- sem_init(&cmd_sem, 0, 0);
-}
-
-QCameraCmdThread::~QCameraCmdThread()
-{
- sem_destroy(&sync_sem);
- sem_destroy(&cmd_sem);
-}
-
-int32_t QCameraCmdThread::launch(void *(*start_routine)(void *),
- void* user_data)
-{
- /* launch the thread */
- pthread_create(&cmd_pid,
- NULL,
- start_routine,
- user_data);
- return 0;
-}
-
-int32_t QCameraCmdThread::sendCmd(camera_cmd_type_t cmd, uint8_t sync_cmd, uint8_t priority)
-{
- camera_cmd_t *node = (camera_cmd_t *)malloc(sizeof(camera_cmd_t));
- if (NULL == node) {
- ALOGE("%s: No memory for camera_cmd_t", __func__);
- return -1;
- }
- memset(node, 0, sizeof(camera_cmd_t));
- node->cmd = cmd;
-
- ALOGD("%s: enqueue cmd %d", __func__, cmd);
- if (TRUE == priority) {
- cmd_queue.pri_enqueue((void *)node);
- } else {
- cmd_queue.enqueue((void *)node);
- }
- sem_post(&cmd_sem);
-
- /* if is a sync call, need to wait until it returns */
- if (sync_cmd) {
- sem_wait(&sync_sem);
- }
- return 0;
-}
-
-camera_cmd_type_t QCameraCmdThread::getCmd()
-{
- camera_cmd_type_t cmd = CAMERA_CMD_TYPE_NONE;
- camera_cmd_t *node = (camera_cmd_t *)cmd_queue.dequeue();
- if (NULL == node) {
- ALOGD("%s: No notify avail", __func__);
- return CAMERA_CMD_TYPE_NONE;
- } else {
- cmd = node->cmd;
- free(node);
- }
- return cmd;
-}
-
-int32_t QCameraCmdThread::exit()
-{
- int32_t rc = 0;
-
- rc = sendCmd(CAMERA_CMD_TYPE_EXIT, FALSE, TRUE);
- if (0 != rc) {
- ALOGE("%s: Error during exit, rc = %d", __func__, rc);
- return rc;
- }
-
- /* wait until cmd thread exits */
- if (pthread_join(cmd_pid, NULL) != 0) {
- ALOGD("%s: pthread dead already\n", __func__);
- }
- cmd_pid = 0;
- return rc;
-}
-
-}; // namespace android
-
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Mem.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Mem.cpp
deleted file mode 100755
index 37b0e07..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Mem.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHWI_Mem"
-#include <utils/Log.h>
-
-#include <utils/Errors.h>
-#include <utils/threads.h>
-#include <utils/String16.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <cutils/properties.h>
-#include <math.h>
-#if HAVE_ANDROID_OS
-#include <linux/android_pmem.h>
-#endif
-#include <linux/ioctl.h>
-#include <camera/QCameraParameters.h>
-#include <media/mediarecorder.h>
-#include <gralloc_priv.h>
-
-#include "QCameraHWI_Mem.h"
-
-#define CAMERA_HAL_UNUSED(expr) do { (void)(expr); } while (0)
-
-/* QCameraHardwareInterface class implementation goes here*/
-/* following code implement the contol logic of this class*/
-
-namespace android {
-
-
-static bool register_buf(int size,
- int frame_size,
- int cbcr_offset,
- int yoffset,
- int pmempreviewfd,
- uint32_t offset,
- uint8_t *buf,
- int pmem_type,
- bool vfe_can_write,
- bool register_buffer = true);
-
-MemPool::MemPool(int buffer_size, int num_buffers,
- int frame_size,
- const char *name) :
- mBufferSize(buffer_size),
- mNumBuffers(num_buffers),
- mFrameSize(frame_size),
- mBuffers(NULL), mName(name)
-{
- int page_size_minus_1 = getpagesize() - 1;
- mAlignedBufferSize = (buffer_size + page_size_minus_1) & (~page_size_minus_1);
-}
-
-void MemPool::completeInitialization()
-{
- // If we do not know how big the frame will be, we wait to allocate
- // the buffers describing the individual frames until we do know their
- // size.
-
- if (mFrameSize > 0) {
- mBuffers = new sp<MemoryBase>[mNumBuffers];
- for (int i = 0; i < mNumBuffers; i++) {
- mBuffers[i] = new
- MemoryBase(mHeap,
- i * mAlignedBufferSize,
- mFrameSize);
- }
- }
-}
-
-AshmemPool::AshmemPool(int buffer_size, int num_buffers,
- int frame_size,
- const char *name) :
- MemPool(buffer_size,
- num_buffers,
- frame_size,
- name)
-{
- ALOGV("constructing MemPool %s backed by ashmem: "
- "%d frames @ %d uint8_ts, "
- "buffer size %d",
- mName,
- num_buffers, frame_size, buffer_size);
-
- int page_mask = getpagesize() - 1;
- int ashmem_size = buffer_size * num_buffers;
- ashmem_size += page_mask;
- ashmem_size &= ~page_mask;
-
- mHeap = new MemoryHeapBase(ashmem_size);
-
- completeInitialization();
-}
-
-static bool register_buf(int size,
- int frame_size,
- int cbcr_offset,
- int yoffset,
- int pmempreviewfd,
- uint32_t offset,
- uint8_t *buf,
- int pmem_type,
- bool vfe_can_write,
- bool register_buffer)
-{
- return true;
-
-}
-
-PmemPool::~PmemPool()
-{
- ALOGI("%s: %s E", __FUNCTION__, mName);
-
- ALOGI("%s: %s X", __FUNCTION__, mName);
-}
-MemPool::~MemPool()
-{
- ALOGV("destroying MemPool %s", mName);
- if (mFrameSize > 0)
- delete [] mBuffers;
- mHeap.clear();
- ALOGV("destroying MemPool %s completed", mName);
-}
-
-
-status_t MemPool::dump(int fd, const Vector<String16>& args) const
-{
- const size_t SIZE = 256;
- char buffer[SIZE];
- String8 result;
- CAMERA_HAL_UNUSED(args);
- snprintf(buffer, 255, "QualcommCameraHardware::AshmemPool::dump\n");
- result.append(buffer);
- if (mName) {
- snprintf(buffer, 255, "mem pool name (%s)\n", mName);
- result.append(buffer);
- }
- if (mHeap != 0) {
- snprintf(buffer, 255, "heap base(%p), size(%d), flags(%d), device(%s)\n",
- mHeap->getBase(), mHeap->getSize(),
- mHeap->getFlags(), mHeap->getDevice());
- result.append(buffer);
- }
- snprintf(buffer, 255,
- "buffer size (%d), number of buffers (%d), frame size(%d)",
- mBufferSize, mNumBuffers, mFrameSize);
- result.append(buffer);
- write(fd, result.string(), result.size());
- return NO_ERROR;
-}
-
-};
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Parm.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Parm.cpp
deleted file mode 100755
index c37e341..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Parm.cpp
+++ /dev/null
@@ -1,4277 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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 ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHWI_Parm"
-#include <utils/Log.h>
-
-#include <utils/Errors.h>
-#include <utils/threads.h>
-#include <utils/String16.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <cutils/properties.h>
-#include <math.h>
-#if HAVE_ANDROID_OS
-#include <linux/android_pmem.h>
-#endif
-#include <linux/ioctl.h>
-#include <camera/QCameraParameters.h>
-#include <media/mediarecorder.h>
-#include <gralloc_priv.h>
-
-#include "linux/msm_mdp.h"
-#include <linux/fb.h>
-#include <limits.h>
-
-
-extern "C" {
-#include <fcntl.h>
-#include <time.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <termios.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <signal.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/system_properties.h>
-#include <sys/time.h>
-#include <stdlib.h>
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include <cam_fifo.h>
-#include <jpege.h>
-
-} // extern "C"
-
-#include "QCameraHWI.h"
-
-/* QCameraHardwareInterface class implementation goes here*/
-/* following code implements the parameter logic of this class*/
-#define EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR 12
-#define EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR -12
-#define EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR 0
-#define EXPOSURE_COMPENSATION_DENOMINATOR 6
-#define EXPOSURE_COMPENSATION_STEP ((float (1))/EXPOSURE_COMPENSATION_DENOMINATOR)
-#define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)"
-
-#define HDR_HAL_FRAME 2
-
-#define BURST_INTREVAL_MIN 1
-#define BURST_INTREVAL_MAX 10
-#define BURST_INTREVAL_DEFAULT 1
-
-//Default FPS
-#define MINIMUM_FPS 5
-#define MAXIMUM_FPS 120
-#define DEFAULT_FIXED_FPS 30
-#define DEFAULT_FPS MAXIMUM_FPS
-
-//Default Picture Width
-#define DEFAULT_PICTURE_WIDTH 640
-#define DEFAULT_PICTURE_HEIGHT 480
-
-//Default Video Width
-#define DEFAULT_VIDEO_WIDTH 1920
-#define DEFAULT_VIDEO_HEIGHT 1080
-
-#define THUMBNAIL_SIZE_COUNT (sizeof(thumbnail_sizes)/sizeof(thumbnail_size_type))
-#define DEFAULT_THUMBNAIL_SETTING 4
-#define THUMBNAIL_WIDTH_STR "512"
-#define THUMBNAIL_HEIGHT_STR "384"
-#define THUMBNAIL_SMALL_HEIGHT 144
-
-#define DONT_CARE_COORDINATE -1
-
-// All fps ranges which can be supported. This list will be filtered according
-// to the min and max fps supported by hardware
-// this list must be sorted first by max_fps and then min_fps
-// fps values are multiplied by 1000
-static android::FPSRange allFpsRanges[] = {
- android::FPSRange(7500, 7500),
- android::FPSRange(10000, 10000),
- android::FPSRange(7500, 15000),
- android::FPSRange(15000, 15000),
- android::FPSRange(7500, 20000),
- android::FPSRange(20000, 20000),
- android::FPSRange(7500, 30000),
- android::FPSRange(10000, 30000),
- android::FPSRange(15000, 30000),
- android::FPSRange(30000, 30000)
-};
-#define ALL_FPS_RANGES_COUNT (sizeof(allFpsRanges)/sizeof(android::FPSRange))
-
-typedef struct {
- uint32_t aspect_ratio;
- uint32_t width;
- uint32_t height;
-} thumbnail_size_type;
-
-static thumbnail_size_type thumbnail_sizes[] = {
-{ 7281, 512, 288 }, //1.777778
-{ 6826, 480, 288 }, //1.666667
-{ 6808, 256, 154 }, //1.66233
-{ 6144, 432, 288 }, //1.5
-{ 5461, 512, 384 }, //1.333333
-{ 5006, 352, 288 }, //1.222222
-{ 5461, 320, 240 }, //1.33333
-{ 5006, 176, 144 }, //1.222222
-
-};
-
-static struct camera_size_type zsl_picture_sizes[] = {
- { 1024, 768}, // 1MP XGA
- { 800, 600}, //SVGA
- { 800, 480}, // WVGA
- { 640, 480}, // VGA
- { 352, 288}, //CIF
- { 320, 240}, // QVGA
- { 176, 144} // QCIF
-};
-
-static camera_size_type default_picture_sizes[] = {
- { 4000, 3000}, // 12MP
- { 3200, 2400}, // 8MP
- { 2592, 1944}, // 5MP
- { 2048, 1536}, // 3MP QXGA
- { 1920, 1080}, //HD1080
- { 1600, 1200}, // 2MP UXGA
- { 1280, 768}, //WXGA
- { 1280, 720}, //HD720
- { 1024, 768}, // 1MP XGA
- { 800, 600}, //SVGA
- { 800, 480}, // WVGA
- { 720, 480},
- { 640, 480}, // VGA
- { 352, 288}, //CIF
- { 320, 240}, // QVGA
- { 176, 144} // QCIF
-};
-
-static int iso_speed_values[] = {
- 0, 1, 100, 200, 400, 800, 1600
-};
-
-extern int HAL_numOfCameras;
-extern camera_info_t HAL_cameraInfo[MSM_MAX_CAMERA_SENSORS];
-extern mm_camera_info_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS];
-
-namespace android {
-
-static uint32_t HFR_SIZE_COUNT=2;
-static const int PICTURE_FORMAT_JPEG = 1;
-static const int PICTURE_FORMAT_RAW = 2;
-
-/********************************************************************/
-static const str_map effects[] = {
- { QCameraParameters::EFFECT_NONE, CAMERA_EFFECT_OFF },
- { QCameraParameters::EFFECT_MONO, CAMERA_EFFECT_MONO },
- { QCameraParameters::EFFECT_NEGATIVE, CAMERA_EFFECT_NEGATIVE },
- { QCameraParameters::EFFECT_SOLARIZE, CAMERA_EFFECT_SOLARIZE },
- { QCameraParameters::EFFECT_SEPIA, CAMERA_EFFECT_SEPIA },
- { QCameraParameters::EFFECT_POSTERIZE, CAMERA_EFFECT_POSTERIZE },
- { QCameraParameters::EFFECT_WHITEBOARD, CAMERA_EFFECT_WHITEBOARD },
- { QCameraParameters::EFFECT_BLACKBOARD, CAMERA_EFFECT_BLACKBOARD },
- { QCameraParameters::EFFECT_AQUA, CAMERA_EFFECT_AQUA },
- { QCameraParameters::EFFECT_EMBOSS, CAMERA_EFFECT_EMBOSS },
- { QCameraParameters::EFFECT_SKETCH, CAMERA_EFFECT_SKETCH },
- { QCameraParameters::EFFECT_NEON, CAMERA_EFFECT_NEON }
-};
-
-static const str_map iso[] = {
- { QCameraParameters::ISO_AUTO, CAMERA_ISO_AUTO},
- { QCameraParameters::ISO_HJR, CAMERA_ISO_DEBLUR},
- { QCameraParameters::ISO_100, CAMERA_ISO_100},
- { QCameraParameters::ISO_200, CAMERA_ISO_200},
- { QCameraParameters::ISO_400, CAMERA_ISO_400},
- { QCameraParameters::ISO_800, CAMERA_ISO_800 },
- { QCameraParameters::ISO_1600, CAMERA_ISO_1600 }
-};
-
-static const str_map scenemode[] = {
- { QCameraParameters::SCENE_MODE_AUTO, CAMERA_BESTSHOT_OFF },
- { QCameraParameters::SCENE_MODE_ASD, CAMERA_BESTSHOT_AUTO },
- { QCameraParameters::SCENE_MODE_ACTION, CAMERA_BESTSHOT_ACTION },
- { QCameraParameters::SCENE_MODE_PORTRAIT, CAMERA_BESTSHOT_PORTRAIT },
- { QCameraParameters::SCENE_MODE_LANDSCAPE, CAMERA_BESTSHOT_LANDSCAPE },
- { QCameraParameters::SCENE_MODE_NIGHT, CAMERA_BESTSHOT_NIGHT },
- { QCameraParameters::SCENE_MODE_NIGHT_PORTRAIT, CAMERA_BESTSHOT_NIGHT_PORTRAIT },
- { QCameraParameters::SCENE_MODE_THEATRE, CAMERA_BESTSHOT_THEATRE },
- { QCameraParameters::SCENE_MODE_BEACH, CAMERA_BESTSHOT_BEACH },
- { QCameraParameters::SCENE_MODE_SNOW, CAMERA_BESTSHOT_SNOW },
- { QCameraParameters::SCENE_MODE_SUNSET, CAMERA_BESTSHOT_SUNSET },
- { QCameraParameters::SCENE_MODE_STEADYPHOTO, CAMERA_BESTSHOT_ANTISHAKE },
- { QCameraParameters::SCENE_MODE_FIREWORKS , CAMERA_BESTSHOT_FIREWORKS },
- { QCameraParameters::SCENE_MODE_SPORTS , CAMERA_BESTSHOT_SPORTS },
- { QCameraParameters::SCENE_MODE_PARTY, CAMERA_BESTSHOT_PARTY },
- { QCameraParameters::SCENE_MODE_CANDLELIGHT, CAMERA_BESTSHOT_CANDLELIGHT },
- { QCameraParameters::SCENE_MODE_BACKLIGHT, CAMERA_BESTSHOT_BACKLIGHT },
- { QCameraParameters::SCENE_MODE_FLOWERS, CAMERA_BESTSHOT_FLOWERS },
- { QCameraParameters::SCENE_MODE_AR, CAMERA_BESTSHOT_AR },
-};
-
-static const str_map scenedetect[] = {
- { QCameraParameters::SCENE_DETECT_OFF, FALSE },
- { QCameraParameters::SCENE_DETECT_ON, TRUE },
-};
-
-#define DONT_CARE AF_MODE_MAX
-static const str_map focus_modes[] = {
- { QCameraParameters::FOCUS_MODE_AUTO, AF_MODE_AUTO},
- { QCameraParameters::FOCUS_MODE_INFINITY, AF_MODE_INFINITY },
- { QCameraParameters::FOCUS_MODE_NORMAL, AF_MODE_NORMAL },
- { QCameraParameters::FOCUS_MODE_MACRO, AF_MODE_MACRO },
- { QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE, AF_MODE_CAF},
- { QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO, AF_MODE_CAF }
-};
-
-static const str_map selectable_zone_af[] = {
- { QCameraParameters::SELECTABLE_ZONE_AF_AUTO, AUTO },
- { QCameraParameters::SELECTABLE_ZONE_AF_SPOT_METERING, SPOT },
- { QCameraParameters::SELECTABLE_ZONE_AF_CENTER_WEIGHTED, CENTER_WEIGHTED },
- { QCameraParameters::SELECTABLE_ZONE_AF_FRAME_AVERAGE, AVERAGE }
-};
-
-// from qcamera/common/camera.h
-static const str_map autoexposure[] = {
- { QCameraParameters::AUTO_EXPOSURE_FRAME_AVG, CAMERA_AEC_FRAME_AVERAGE },
- { QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED, CAMERA_AEC_CENTER_WEIGHTED },
- { QCameraParameters::AUTO_EXPOSURE_SPOT_METERING, CAMERA_AEC_SPOT_METERING }
-};
-
-// from aeecamera.h
-static const str_map whitebalance[] = {
- { QCameraParameters::WHITE_BALANCE_AUTO, CAMERA_WB_AUTO },
- { QCameraParameters::WHITE_BALANCE_INCANDESCENT, CAMERA_WB_INCANDESCENT },
- { QCameraParameters::WHITE_BALANCE_FLUORESCENT, CAMERA_WB_FLUORESCENT },
- { QCameraParameters::WHITE_BALANCE_DAYLIGHT, CAMERA_WB_DAYLIGHT },
- { QCameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT, CAMERA_WB_CLOUDY_DAYLIGHT }
-};
-
-static const str_map antibanding[] = {
- { QCameraParameters::ANTIBANDING_OFF, CAMERA_ANTIBANDING_OFF },
- { QCameraParameters::ANTIBANDING_50HZ, CAMERA_ANTIBANDING_50HZ },
- { QCameraParameters::ANTIBANDING_60HZ, CAMERA_ANTIBANDING_60HZ },
- { QCameraParameters::ANTIBANDING_AUTO, CAMERA_ANTIBANDING_AUTO }
-};
-
-static const str_map frame_rate_modes[] = {
- {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO},
- {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED}
-};
-
-static const str_map touchafaec[] = {
- { QCameraParameters::TOUCH_AF_AEC_OFF, FALSE },
- { QCameraParameters::TOUCH_AF_AEC_ON, TRUE }
-};
-
-static const str_map hfr[] = {
- { QCameraParameters::VIDEO_HFR_OFF, CAMERA_HFR_MODE_OFF },
- { QCameraParameters::VIDEO_HFR_2X, CAMERA_HFR_MODE_60FPS },
- { QCameraParameters::VIDEO_HFR_3X, CAMERA_HFR_MODE_90FPS },
- { QCameraParameters::VIDEO_HFR_4X, CAMERA_HFR_MODE_120FPS },
-};
-static const int HFR_VALUES_COUNT = (sizeof(hfr)/sizeof(str_map));
-
-static const str_map flash[] = {
- { QCameraParameters::FLASH_MODE_OFF, LED_MODE_OFF },
- { QCameraParameters::FLASH_MODE_AUTO, LED_MODE_AUTO },
- { QCameraParameters::FLASH_MODE_ON, LED_MODE_ON },
- { QCameraParameters::FLASH_MODE_TORCH, LED_MODE_TORCH}
-};
-
-static const str_map lensshade[] = {
- { QCameraParameters::LENSSHADE_ENABLE, TRUE },
- { QCameraParameters::LENSSHADE_DISABLE, FALSE }
-};
-
-static const str_map mce[] = {
- { QCameraParameters::MCE_ENABLE, TRUE },
- { QCameraParameters::MCE_DISABLE, FALSE }
-};
-
-static const str_map histogram[] = {
- { QCameraParameters::HISTOGRAM_ENABLE, TRUE },
- { QCameraParameters::HISTOGRAM_DISABLE, FALSE }
-};
-
-static const str_map skinToneEnhancement[] = {
- { QCameraParameters::SKIN_TONE_ENHANCEMENT_ENABLE, TRUE },
- { QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE, FALSE }
-};
-
-static const str_map denoise[] = {
- { QCameraParameters::DENOISE_OFF, FALSE },
- { QCameraParameters::DENOISE_ON, TRUE }
-};
-
-static const str_map facedetection[] = {
- { QCameraParameters::FACE_DETECTION_OFF, FALSE },
- { QCameraParameters::FACE_DETECTION_ON, TRUE }
-};
-
-static const str_map redeye_reduction[] = {
- { QCameraParameters::REDEYE_REDUCTION_ENABLE, TRUE },
- { QCameraParameters::REDEYE_REDUCTION_DISABLE, FALSE }
-};
-
-static const str_map picture_formats[] = {
- {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG},
- {QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW}
-};
-
-static const str_map recording_Hints[] = {
- {"false", FALSE},
- {"true", TRUE}
-};
-
-static const str_map preview_formats[] = {
- {QCameraParameters::PIXEL_FORMAT_YUV420SP, HAL_PIXEL_FORMAT_YCrCb_420_SP},
- {QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO, HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO},
- {QCameraParameters::PIXEL_FORMAT_YV12, HAL_PIXEL_FORMAT_YV12},
- {QCameraParameters::PIXEL_FORMAT_YUV420P,HAL_PIXEL_FORMAT_YV12},
- {QCameraParameters::PIXEL_FORMAT_NV12, HAL_PIXEL_FORMAT_YCbCr_420_SP}
-};
-
-static const preview_format_info_t preview_format_info_list[] = {
- {HAL_PIXEL_FORMAT_YCrCb_420_SP, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_WORD, 2},
- {HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_4K, 2},
- {HAL_PIXEL_FORMAT_YCbCr_420_SP, CAMERA_YUV_420_NV12, CAMERA_PAD_TO_WORD, 2},
- {HAL_PIXEL_FORMAT_YV12, CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3}
-};
-
-static const str_map zsl_modes[] = {
- { QCameraParameters::ZSL_OFF, FALSE },
- { QCameraParameters::ZSL_ON, TRUE },
-};
-
-
-static const str_map hdr_bracket[] = {
- { QCameraParameters::AE_BRACKET_HDR_OFF,HDR_BRACKETING_OFF},
- { QCameraParameters::AE_BRACKET_HDR,HDR_MODE },
- { QCameraParameters::AE_BRACKET,EXP_BRACKETING_MODE }
-};
-
-typedef enum {
- NORMAL_POWER,
- LOW_POWER
-} power_mode;
-
-static const str_map power_modes[] = {
- { QCameraParameters::NORMAL_POWER,NORMAL_POWER },
- { QCameraParameters::LOW_POWER,LOW_POWER }
-};
-
-/**************************************************************************/
-static int attr_lookup(const str_map arr[], int len, const char *name)
-{
- if (name) {
- for (int i = 0; i < len; i++) {
- if (!strcmp(arr[i].desc, name))
- return arr[i].val;
- }
- }
- return NOT_FOUND;
-}
-
-bool QCameraHardwareInterface::native_set_parms(
- mm_camera_parm_type_t type, uint16_t length, void *value)
-{
- ALOGV("%s : type : %d Value : %d",__func__,type,*((int *)value));
- if(mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, type,value ) < 0) {
- ALOGE("native_set_parms failed: type %d length %d error %s",
- type, length, strerror(errno));
- return false;
- }
-
- return true;
-
-}
-
-bool QCameraHardwareInterface::native_set_parms(
- mm_camera_parm_type_t type, uint16_t length, void *value, int *result)
-{
- *result= mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, type,value );
- if( *result >=0 ) {
- ALOGE("native_set_parms: succeeded : %d", *result);
- return true;
- }
-
- ALOGV("native_set_parms failed: type %d length %d error str %s error# %d",
- type, length, strerror(errno), errno);
- return false;
-}
-
-//Filter Picture sizes based on max width and height
-/* TBD: do we still need this - except for ZSL? */
-void QCameraHardwareInterface::filterPictureSizes(){
- unsigned int i;
- if(mPictureSizeCount <= 0)
- return;
- maxSnapshotWidth = mPictureSizes[0].width;
- maxSnapshotHeight = mPictureSizes[0].height;
- // Iterate through all the width and height to find the max value
- for(i =0; i<mPictureSizeCount;i++){
- if(((maxSnapshotWidth < mPictureSizes[i].width) &&
- (maxSnapshotHeight <= mPictureSizes[i].height))){
- maxSnapshotWidth = mPictureSizes[i].width;
- maxSnapshotHeight = mPictureSizes[i].height;
- }
- }
- if(myMode & CAMERA_ZSL_MODE){
- // due to lack of PMEM we restrict to lower resolution
- mPictureSizesPtr = zsl_picture_sizes;
- mSupportedPictureSizesCount = 7;
- }else{
- mPictureSizesPtr = mPictureSizes;
- mSupportedPictureSizesCount = mPictureSizeCount;
- }
-}
-
-static String8 create_sizes_str(const camera_size_type *sizes, int len) {
- String8 str;
- char buffer[32];
-
- if (len > 0) {
- snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
- str.append(buffer);
- }
- for (int i = 1; i < len; i++) {
- snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height);
- str.append(buffer);
- }
- return str;
-}
-
-String8 QCameraHardwareInterface::create_values_str(const str_map *values, int len) {
- String8 str;
-
- if (len > 0) {
- str.append(values[0].desc);
- }
- for (int i = 1; i < len; i++) {
- str.append(",");
- str.append(values[i].desc);
- }
- return str;
-}
-
-static String8 create_fps_str(const android:: FPSRange* fps, int len) {
- String8 str;
- char buffer[32];
-
- if (len > 0) {
- snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS);
- str.append(buffer);
- }
- for (int i = 1; i < len; i++) {
- snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS);
- str.append(buffer);
- }
- return str;
-}
-
-static String8 create_values_range_str(int min, int max){
- String8 str;
- char buffer[32];
-
- if(min <= max){
- snprintf(buffer, sizeof(buffer), "%d", min);
- str.append(buffer);
-
- for (int i = min + 1; i <= max; i++) {
- snprintf(buffer, sizeof(buffer), ",%d", i);
- str.append(buffer);
- }
- }
- return str;
-}
-
-static int parse_size(const char *str, int &width, int &height)
-{
- // Find the width.
- char *end;
- int w = (int)strtol(str, &end, 10);
- // If an 'x' or 'X' does not immediately follow, give up.
- if ( (*end != 'x') && (*end != 'X') )
- return -1;
-
- // Find the height, immediately after the 'x'.
- int h = (int)strtol(end+1, 0, 10);
-
- width = w;
- height = h;
-
- return 0;
-}
-
-bool QCameraHardwareInterface::isValidDimension(int width, int height) {
- bool retVal = FALSE;
- /* This function checks if a given resolution is valid or not.
- * A particular resolution is considered valid if it satisfies
- * the following conditions:
- * 1. width & height should be multiple of 16.
- * 2. width & height should be less than/equal to the dimensions
- * supported by the camera sensor.
- * 3. the aspect ratio is a valid aspect ratio and is among the
- * commonly used aspect ratio as determined by the thumbnail_sizes
- * data structure.
- */
-
- if( (width == CEILING16(width)) && (height == CEILING16(height))
- && (width <= maxSnapshotWidth)
- && (height <= maxSnapshotHeight) )
- {
- uint32_t pictureAspectRatio = (uint32_t)((width * Q12)/height);
- for(uint32_t i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ) {
- if(thumbnail_sizes[i].aspect_ratio == pictureAspectRatio) {
- retVal = TRUE;
- break;
- }
- }
- }
- return retVal;
-}
-
-void QCameraHardwareInterface::hasAutoFocusSupport(){
-
- ALOGV("%s",__func__);
- mHasAutoFocusSupport = false;
-
- if(isZSLMode()){
- mHasAutoFocusSupport = false;
- return;
- }
-
- if(mCameraHandle->ops->is_op_supported(mCameraHandle->camera_handle, MM_CAMERA_OPS_FOCUS)) {
- mHasAutoFocusSupport = true;
- }
- else {
- ALOGE("AutoFocus is not supported");
- mHasAutoFocusSupport = false;
- }
- ALOGV("%s:rc= %d",__func__, mHasAutoFocusSupport);
-
-}
-
-bool QCameraHardwareInterface::supportsSceneDetection() {
- bool rc ;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_ASD_ENABLE,(uint8_t*)&rc,(uint8_t*)&rc);
- return rc;
-}
-
-bool QCameraHardwareInterface::supportsFaceDetection() {
- bool rc ;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_FD,(uint8_t*)&rc,(uint8_t*)&rc);
- return rc;
-}
-
-bool QCameraHardwareInterface::supportsSelectableZoneAf() {
- bool rc ;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_FOCUS_RECT,(uint8_t*)&rc,(uint8_t*)&rc);
- return rc;
-}
-
-bool QCameraHardwareInterface::supportsRedEyeReduction() {
- bool rc ;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_REDEYE_REDUCTION,(uint8_t*)&rc,(uint8_t*)&rc);
- return rc;
-}
-
-static String8 create_str(int16_t *arr, int length){
- String8 str;
- char buffer[32] = {0};
-
- if(length > 0){
- snprintf(buffer, sizeof(buffer), "%d", arr[0]);
- str.append(buffer);
- }
-
- for (int i =1;i<length;i++){
- snprintf(buffer, sizeof(buffer), ",%d",arr[i]);
- str.append(buffer);
- }
- return str;
-}
-
-bool QCameraHardwareInterface::getMaxPictureDimension(mm_camera_dimension_t *maxDim)
-{
- bool ret = NO_ERROR;
- mm_camera_dimension_t dim;
-
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim);
- if (ret != NO_ERROR)
- return ret;
-
- /* Find the first dimension in the mPictureSizes
- * array which is smaller than the max dimension.
- * This will be the valid max picture resolution */
- for (unsigned int i = 0; i < mPictureSizeCount; i++) {
- if ((mPictureSizes[i].width <= dim.width) &&
- (mPictureSizes[i].height <= dim.height)) {
- maxDim->height = mPictureSizes[i].height;
- maxDim->width = mPictureSizes[i].width;
- break;
- }
- }
- ALOGD("%s: Found Max Picture dimension: %d x %d", __func__,
- maxDim->width, maxDim->height);
- return ret;
-}
-void QCameraHardwareInterface::loadTables()
-{
-
- bool ret = NO_ERROR;
- ALOGV("%s: E", __func__);
-
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_PREVIEW_SIZES_CNT, &preview_sizes_count);
-
- default_sizes_tbl_t preview_sizes_tbl;
- preview_sizes_tbl.tbl_size=preview_sizes_count;
- preview_sizes_tbl.sizes_tbl=&default_preview_sizes[0];
- if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_DEF_PREVIEW_SIZES, &preview_sizes_tbl)<0){
- ALOGE("%s:Failed to get default preview sizes",__func__);
- }
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_VIDEO_SIZES_CNT, &video_sizes_count);
-
- default_sizes_tbl_t video_sizes_tbl;
- video_sizes_tbl.tbl_size=video_sizes_count;
- video_sizes_tbl.sizes_tbl=&default_video_sizes[0];
- if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_DEF_VIDEO_SIZES, &video_sizes_tbl)<0){
- ALOGE("%s:Failed to get default video sizes",__func__);
- }
-
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_THUMB_SIZES_CNT, &thumbnail_sizes_count);
-
- default_sizes_tbl_t thumbnail_sizes_tbl;
- thumbnail_sizes_tbl.tbl_size=thumbnail_sizes_count;
- thumbnail_sizes_tbl.sizes_tbl=&default_thumbnail_sizes[0];
- if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_DEF_THUMB_SIZES, &thumbnail_sizes_tbl)<0){
- ALOGE("%s:Failed to get default thumbnail sizes",__func__);
- }
-
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_HFR_SIZES_CNT, &hfr_sizes_count);
-
- default_sizes_tbl_t hfr_sizes_tbl;
- hfr_sizes_tbl.tbl_size=hfr_sizes_count;
- hfr_sizes_tbl.sizes_tbl=&default_hfr_sizes[0];
- if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_DEF_HFR_SIZES, &hfr_sizes_tbl)<0){
- ALOGE("%s:Failed to get default HFR sizes",__func__);
- }
- ALOGE("%s: X", __func__);
-}
-void QCameraHardwareInterface::initDefaultParameters()
-{
- bool ret;
- char prop[PROPERTY_VALUE_MAX];
- mm_camera_dimension_t maxDim;
- int rc = 0;
- ALOGI("%s: E", __func__);
- uint8_t supported;
-
- memset(&maxDim, 0, sizeof(mm_camera_dimension_t));
- ret = getMaxPictureDimension(&maxDim);
-
- if (ret != NO_ERROR) {
- ALOGE("%s: Cannot get Max picture size supported", __func__);
- return;
- }
- if (!maxDim.width || !maxDim.height) {
- maxDim.width = DEFAULT_LIVESHOT_WIDTH;
- maxDim.height = DEFAULT_LIVESHOT_HEIGHT;
- }
-
- memset(prop, 0, sizeof(prop));
- property_get("persist.camera.snap.format", prop, "0");
- mSnapshotFormat = atoi(prop);
- ALOGV("%s: prop =(%s), snap_format=%d", __func__, prop, mSnapshotFormat);
-
- //cam_ctrl_dimension_t dim;
- mHFRLevel = 0;
- memset(&mDimension, 0, sizeof(cam_ctrl_dimension_t));
- memset(&mPreviewFormatInfo, 0, sizeof(preview_format_info_t));
- mDimension.video_width = DEFAULT_VIDEO_WIDTH;
- mDimension.video_height = DEFAULT_VIDEO_HEIGHT;
- mDimension.picture_width = maxDim.width;
- mDimension.picture_height = maxDim.height;
- mDimension.display_width = DEFAULT_STREAM_WIDTH;
- mDimension.display_height = DEFAULT_STREAM_HEIGHT;
- mDimension.orig_picture_dx = mDimension.picture_width;
- mDimension.orig_picture_dy = mDimension.picture_height;
- mDimension.ui_thumbnail_width = DEFAULT_STREAM_WIDTH;
- mDimension.ui_thumbnail_height = DEFAULT_STREAM_HEIGHT;
- mDimension.orig_video_width = DEFAULT_STREAM_WIDTH;
- mDimension.orig_video_height = DEFAULT_STREAM_HEIGHT;
-
- mDimension.prev_format = CAMERA_YUV_420_NV21;
- mDimension.enc_format = CAMERA_YUV_420_NV12;
- if (mSnapshotFormat == 1) {
- mDimension.main_img_format = CAMERA_YUV_422_NV61;
- } else {
- mDimension.main_img_format = CAMERA_YUV_420_NV21;
- }
- mDimension.thumb_format = CAMERA_YUV_420_NV21;
- ALOGV("%s: main_img_format =%d, thumb_format=%d", __func__,
- mDimension.main_img_format, mDimension.thumb_format);
- mDimension.prev_padding_format = CAMERA_PAD_TO_WORD;
-
- ret = native_set_parms(MM_CAMERA_PARM_DIMENSION,
- sizeof(cam_ctrl_dimension_t), (void *) &mDimension);
- if(!ret) {
- ALOGE("MM_CAMERA_PARM_DIMENSION Failed.");
- return;
- }
-
- hasAutoFocusSupport();
-
- // Initialize constant parameter strings. This will happen only once in the
- // lifetime of the mediaserver process.
- if (true/*!mParamStringInitialized*/) {
- //filter picture sizes
- filterPictureSizes();
- mPictureSizeValues = create_sizes_str(
- mPictureSizesPtr, mSupportedPictureSizesCount);
- mPreviewSizeValues = create_sizes_str(
- mPreviewSizes, mPreviewSizeCount);
- mVideoSizeValues = create_sizes_str(
- mVideoSizes, mVideoSizeCount);
-
- //Query for max HFR value
- camera_hfr_mode_t maxHFR;
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_MAX_HFR_MODE, (void *)&maxHFR);
- //Filter HFR values and build parameter string
- String8 str;
- for(int i=0; i<HFR_VALUES_COUNT; i++){
- if(hfr[i].val <= maxHFR){
- if(i>0) str.append(",");
- str.append(hfr[i].desc);
- }
- }
- mHfrValues = str;
- mHfrSizeValues = create_sizes_str(
- default_hfr_sizes, hfr_sizes_count);
-
- //Query for min and max fps values from lower layer
- if(MM_CAMERA_OK != mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_FPS_RANGE, (void *)&mSensorFpsRange)){
- ALOGE("error: failed to get fps range from sensor");
- return;
- } else {
- ALOGD("sensor fps range = (%f, %f)", mSensorFpsRange.min_fps,
- mSensorFpsRange.max_fps);
-
- mSupportedFpsRanges = new android::FPSRange[ALL_FPS_RANGES_COUNT+1];
-
- //min and max fps in android format
- int minFps = (int)(mSensorFpsRange.min_fps * 1000);
- int maxFps = (int)(mSensorFpsRange.max_fps * 1000);
- int idx=0;
- //filter supported fps ranges according to sensor fps range
- for(int i=0; i<(int)ALL_FPS_RANGES_COUNT; i++) {
- if(allFpsRanges[i].maxFPS <= maxFps && allFpsRanges[i].minFPS >= minFps) {
- memcpy(&mSupportedFpsRanges[idx], &allFpsRanges[i], sizeof(android::FPSRange));
- idx++;
- }
- }
- mSupportedFpsRangesCount = idx;
- //insert sensor absolute fps range as one entry, if
- //its not already there in table
- //find insertion point
- int insertIndex = mSupportedFpsRangesCount;
- for(int i=0; i<mSupportedFpsRangesCount; i++) {
- if(mSupportedFpsRanges[i].maxFPS < maxFps) {
- continue;
- } else if (mSupportedFpsRanges[i].maxFPS == maxFps) {
- if(mSupportedFpsRanges[i].minFPS > minFps) {
- insertIndex = i;
- break;
- } else if (mSupportedFpsRanges[i].minFPS == minFps) {
- //entry already exists, no need to insert
- insertIndex = -1;
- break;
- }
- }
- }
- if(insertIndex != -1) {
- for(int i=mSupportedFpsRangesCount; i>=0; i--) {
- if(insertIndex == i) {
- mSupportedFpsRanges[i].maxFPS = maxFps;
- mSupportedFpsRanges[i].minFPS = minFps;
- mSupportedFpsRangesCount++;
- break;
- }
- mSupportedFpsRanges[i].maxFPS = mSupportedFpsRanges[i-1].maxFPS;
- mSupportedFpsRanges[i].minFPS = mSupportedFpsRanges[i-1].minFPS;
- }
- }
- mFpsRangesSupportedValues = create_fps_str(mSupportedFpsRanges, mSupportedFpsRangesCount);
-
- ALOGD("supported fps ranges = %s", mFpsRangesSupportedValues.string());
- mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
- mFpsRangesSupportedValues);
- mParameters.setPreviewFpsRange(minFps, maxFps);
- }
-
- mFlashValues = create_values_str(
- flash, sizeof(flash) / sizeof(str_map));
- mLensShadeValues = create_values_str(
- lensshade,sizeof(lensshade)/sizeof(str_map));
- mMceValues = create_values_str(
- mce,sizeof(mce)/sizeof(str_map));
- mEffectValues = create_values_str(effects, sizeof(effects) / sizeof(str_map));
- mAntibandingValues = create_values_str(
- antibanding, sizeof(antibanding) / sizeof(str_map));
- mIsoValues = create_values_str(iso,sizeof(iso)/sizeof(str_map));
- mAutoExposureValues = create_values_str(
- autoexposure, sizeof(autoexposure) / sizeof(str_map));
- mWhitebalanceValues = create_values_str(
- whitebalance, sizeof(whitebalance) / sizeof(str_map));
-
- if(mHasAutoFocusSupport){
- mFocusModeValues = create_values_str(
- focus_modes, sizeof(focus_modes) / sizeof(str_map));
- }
-
- mSceneModeValues = create_values_str(scenemode, sizeof(scenemode) / sizeof(str_map));
-
- if(mHasAutoFocusSupport){
- mTouchAfAecValues = create_values_str(
- touchafaec,sizeof(touchafaec)/sizeof(str_map));
- }
- //Currently Enabling Histogram for 8x60
- mHistogramValues = create_values_str(
- histogram,sizeof(histogram)/sizeof(str_map));
-
- mSkinToneEnhancementValues = create_values_str(
- skinToneEnhancement,sizeof(skinToneEnhancement)/sizeof(str_map));
-
- mPictureFormatValues = create_values_str(
- picture_formats, sizeof(picture_formats)/sizeof(str_map));
-
- mZoomSupported=false;
- mMaxZoom=0;
- mm_camera_zoom_tbl_t zmt;
- if( mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_MAXZOOM, &mMaxZoom)<0){
- ALOGE("%s:Failed to get max zoom",__func__);
- }else{
-
- ALOGE("Max Zoom:%d",mMaxZoom);
- /* Kernel driver limits the max amount of data that can be retreived through a control
- command to 260 bytes hence we conservatively limit to 110 zoom ratios */
- if(mMaxZoom>MAX_ZOOM_RATIOS) {
- ALOGE("%s:max zoom is larger than sizeof zoomRatios table",__func__);
- mMaxZoom=MAX_ZOOM_RATIOS-1;
- }
- zmt.size=mMaxZoom;
- zmt.zoom_ratio_tbl=&zoomRatios[0];
- if( mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_ZOOM_RATIO, &zmt)<0){
- ALOGE("%s:Failed to get max zoom ratios",__func__);
- }else{
- mZoomSupported=true;
- mZoomRatioValues = create_str(zoomRatios, mMaxZoom);
- }
- }
-
- ALOGE("Zoom supported:%d",mZoomSupported);
-
- denoise_value = create_values_str(
- denoise, sizeof(denoise) / sizeof(str_map));
-
- if(supportsFaceDetection()) {
- mFaceDetectionValues = create_values_str(
- facedetection, sizeof(facedetection) / sizeof(str_map));
- }
-
- if(mHasAutoFocusSupport){
- mSelectableZoneAfValues = create_values_str(
- selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map));
- }
-
- mSceneDetectValues = create_values_str(scenedetect, sizeof(scenedetect) / sizeof(str_map));
-
- mRedeyeReductionValues = create_values_str(
- redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map));
-
- mZslValues = create_values_str(
- zsl_modes,sizeof(zsl_modes)/sizeof(str_map));
-
- mParamStringInitialized = true;
- }
-
- //set supported video sizes
- mParameters.set(QCameraParameters::KEY_SUPPORTED_VIDEO_SIZES, mVideoSizeValues.string());
-
- //set default video size to first one in supported table
- String8 vSize = create_sizes_str(&mVideoSizes[0], 1);
- mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, vSize.string());
-
- //Set Preview size
- int default_preview_width, default_preview_height;
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH,
- &default_preview_width);
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT,
- &default_preview_height);
- mParameters.setPreviewSize(default_preview_width, default_preview_height);
- mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
- mPreviewSizeValues.string());
- mDimension.display_width = default_preview_width;
- mDimension.display_height = default_preview_height;
-
- mPreviewFrameRateValues = create_values_range_str(
- MINIMUM_FPS, MAXIMUM_FPS);
-
-
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle, MM_CAMERA_PARM_FPS,&supported,&supported);
- if (supported) {
- mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
- mPreviewFrameRateValues.string());
- } else {
- mParameters.set(
- QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
- DEFAULT_FIXED_FPS);
- }
- //Set Preview Format
- //mParameters.setPreviewFormat("yuv420sp"); // informative
- mParameters.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP);
-
- mPreviewFormatValues = create_values_str(
- preview_formats, sizeof(preview_formats) / sizeof(str_map));
- mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
- mPreviewFormatValues.string());
-
- //Set Overlay Format
- mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP);
- mParameters.set("max-num-detected-faces-hw", "2");
-
- // Set supported max faces
- int maxNumFaces = 0;
- if (supportsFaceDetection()) {
- //Query the maximum number of faces supported by hardware.
- if(MM_CAMERA_OK != mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_MAX_NUM_FACES_DECT, &maxNumFaces)){
- ALOGE("%s:Failed to get max number of faces supported",__func__);
- }
- }
- mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, maxNumFaces);
- //This paramtere is set to default here. This will be changed by application
- //if it needs to support specific number of faces. See also setParameters.
- mParameters.set(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES, 2);
-
- // Set camera features supported flag
- int32_t featureFlag = 0;
- if (supportsFaceDetection()) {
- featureFlag |= 0x00000001; // bit 0 indicate faciral feature
- }
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES, featureFlag);
-
- //Set Picture Size
- mParameters.setPictureSize(DEFAULT_PICTURE_WIDTH, DEFAULT_PICTURE_HEIGHT);
- mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
- mPictureSizeValues.string());
-
- //Set Preview Frame Rate
- if(mFps >= MINIMUM_FPS && mFps <= MAXIMUM_FPS) {
- mParameters.setPreviewFrameRate(mFps);
- }else{
- mParameters.setPreviewFrameRate(DEFAULT_FIXED_FPS);
- }
-
- //Set Picture Format
- mParameters.setPictureFormat("jpeg"); // informative
- mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
- mPictureFormatValues);
-
- mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, "85"); // max quality
- mJpegQuality = 85;
- //Set Video Format
- mParameters.set(QCameraParameters::KEY_VIDEO_FRAME_FORMAT, "yuv420sp");
-
- //Set Thumbnail parameters
- mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
- THUMBNAIL_WIDTH_STR); // informative
- mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
- THUMBNAIL_HEIGHT_STR); // informative
- mDimension.ui_thumbnail_width =
- thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].width;
- mDimension.ui_thumbnail_height =
- thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].height;
- mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "90");
- String8 valuesStr = create_sizes_str(default_thumbnail_sizes, thumbnail_sizes_count);
- mParameters.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
- valuesStr.string());
- // Define CAMERA_SMOOTH_ZOOM in Android.mk file , to enable smoothzoom
-#ifdef CAMERA_SMOOTH_ZOOM
- mParameters.set(QCameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, "true");
-#endif
- if(mZoomSupported){
- mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "true");
- ALOGE("max zoom is %d", mMaxZoom-1);
- /* mMaxZoom value that the query interface returns is the size
- ALOGV("max zoom is %d", mMaxZoom-1);
- * mMaxZoom value that the query interface returns is the size
- * of zoom table. So the actual max zoom value will be one
- * less than that value. */
-
- mParameters.set("max-zoom",mMaxZoom-1);
- mParameters.set(QCameraParameters::KEY_ZOOM_RATIOS,
- mZoomRatioValues);
- } else
- {
- mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "false");
- }
-
- /* Enable zoom support for video application if VPE enabled */
- if(mZoomSupported) {
- mParameters.set("video-zoom-support", "true");
- } else {
- mParameters.set("video-zoom-support", "false");
- }
-
- //8960 supports Power modes : Low power, Normal Power.
- mParameters.set("power-mode-supported", "true");
- //Set Live shot support
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_LIVESHOT_MAIN,
- &supported,&supported);
- if(!supported) {
- ALOGE("%s:LIVESHOT is not supported", __func__);
- mParameters.set("video-snapshot-supported", "false");
- mFullLiveshotEnabled = rc;
- } else {
- mParameters.set("video-snapshot-supported", "true");
- }
-
- //Set default power mode
- mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Normal_Power");
-
- //Set Camera Mode
- mParameters.set(QCameraParameters::KEY_QC_CAMERA_MODE,0);
- mParameters.set(QCameraParameters::KEY_QC_AE_BRACKET_HDR,"Off");
-
- //Set Antibanding
- mParameters.set(QCameraParameters::KEY_ANTIBANDING,
- QCameraParameters::ANTIBANDING_OFF);
- mParameters.set(QCameraParameters::KEY_SUPPORTED_ANTIBANDING,
- mAntibandingValues);
-
- //Set Effect
- mParameters.set(QCameraParameters::KEY_EFFECT,
- QCameraParameters::EFFECT_NONE);
- mParameters.set(QCameraParameters::KEY_SUPPORTED_EFFECTS, mEffectValues);
-
- //Set Auto Exposure
- mParameters.set(QCameraParameters::KEY_QC_AUTO_EXPOSURE,
- QCameraParameters::AUTO_EXPOSURE_FRAME_AVG);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE, mAutoExposureValues);
-
- //Set WhiteBalance
- mParameters.set(QCameraParameters::KEY_WHITE_BALANCE,
- QCameraParameters::WHITE_BALANCE_AUTO);
- mParameters.set(QCameraParameters::KEY_SUPPORTED_WHITE_BALANCE,mWhitebalanceValues);
-
- //Set AEC_LOCK
- mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, "false");
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_AEC_LOCK,&supported,&supported);
- if(supported){
- mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true");
- } else {
- mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "false");
- }
- //Set AWB_LOCK
- mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, "false");
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_AWB_LOCK,&supported,&supported);
- if(supported)
- mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true");
- else
- mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "false");
-
- //Set Focus Mode
- if(mHasAutoFocusSupport){
- mParameters.set(QCameraParameters::KEY_FOCUS_MODE,
- QCameraParameters::FOCUS_MODE_AUTO);
- mFocusMode = AF_MODE_AUTO;
- mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES,
- mFocusModeValues);
- mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "1");
- mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "1");
- } else {
- mParameters.set(QCameraParameters::KEY_FOCUS_MODE,
- QCameraParameters::FOCUS_MODE_INFINITY);
- mFocusMode = DONT_CARE;
- mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES,
- QCameraParameters::FOCUS_MODE_INFINITY);
- mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "0");
- mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "0");
- }
-
- mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, DEFAULT_CAMERA_AREA);
- mParameters.set(QCameraParameters::KEY_METERING_AREAS, DEFAULT_CAMERA_AREA);
-
- //Set Flash
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_LED_MODE,&supported,&supported);
- if(supported){
- mParameters.set(CameraParameters::KEY_FLASH_MODE,
- CameraParameters::FLASH_MODE_OFF);
- mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
- mFlashValues);
- }
-
- //Set Sharpness
- mParameters.set(QCameraParameters::KEY_QC_MAX_SHARPNESS,
- CAMERA_MAX_SHARPNESS);
- mParameters.set(QCameraParameters::KEY_QC_SHARPNESS,
- CAMERA_DEF_SHARPNESS);
-
- //Set Contrast
- mParameters.set(QCameraParameters::KEY_QC_MAX_CONTRAST,
- CAMERA_MAX_CONTRAST);
- mParameters.set(QCameraParameters::KEY_QC_CONTRAST,
- CAMERA_DEF_CONTRAST);
-
- //Set Saturation
- mParameters.set(QCameraParameters::KEY_QC_MAX_SATURATION,
- CAMERA_MAX_SATURATION);
- mParameters.set(QCameraParameters::KEY_QC_SATURATION,
- CAMERA_DEF_SATURATION);
-
- //Set Brightness/luma-adaptaion
- mParameters.set("luma-adaptation", "3");
-
- mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT,
- QCameraParameters::PIXEL_FORMAT_JPEG);
-
- //Set Lensshading
- mParameters.set(QCameraParameters::KEY_QC_LENSSHADE,
- QCameraParameters::LENSSHADE_ENABLE);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES,
- mLensShadeValues);
-
- //Set ISO Mode
- mParameters.set(QCameraParameters::KEY_QC_ISO_MODE,
- QCameraParameters::ISO_AUTO);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES,
- mIsoValues);
-
- //Set MCE
- mParameters.set(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT,
- QCameraParameters::MCE_ENABLE);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES,
- mMceValues);
-
- //Set HFR
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_HFR,&supported,&supported);
- if(supported){
- mParameters.set(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE,
- QCameraParameters::VIDEO_HFR_OFF);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES,
- mHfrSizeValues.string());
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES,
- mHfrValues);
- } else{
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES,"");
- }
-
- //Set Histogram
- mParameters.set(QCameraParameters::KEY_QC_HISTOGRAM,
- QCameraParameters::HISTOGRAM_DISABLE);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES,
- mHistogramValues);
-
- //Set SkinTone Enhancement
- mParameters.set(QCameraParameters::KEY_QC_SKIN_TONE_ENHANCEMENT,
- QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE);
- mParameters.set("skinToneEnhancement", "0");
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES,
- mSkinToneEnhancementValues);
-
- //Set Scene Mode
- mParameters.set(QCameraParameters::KEY_SCENE_MODE,
- QCameraParameters::SCENE_MODE_AUTO);
- mParameters.set(QCameraParameters::KEY_SUPPORTED_SCENE_MODES,
- mSceneModeValues);
-
- //Set Streaming Textures
- mParameters.set("strtextures", "OFF");
-
- //Set Denoise
- mParameters.set(QCameraParameters::KEY_QC_DENOISE,
- QCameraParameters::DENOISE_OFF);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_DENOISE,
- denoise_value);
- //Set Touch AF/AEC
- mParameters.set(QCameraParameters::KEY_QC_TOUCH_AF_AEC,
- QCameraParameters::TOUCH_AF_AEC_OFF);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC,
- mTouchAfAecValues);
- mParameters.set("touchAfAec-dx","100");
- mParameters.set("touchAfAec-dy","100");
-
- //Set Scene Detection
- mParameters.set(QCameraParameters::KEY_QC_SCENE_DETECT,
- QCameraParameters::SCENE_DETECT_OFF);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT,
- mSceneDetectValues);
-
- //Set Selectable Zone AF
- mParameters.set(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF,
- QCameraParameters::SELECTABLE_ZONE_AF_AUTO);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SELECTABLE_ZONE_AF,
- mSelectableZoneAfValues);
-
- //Set Face Detection
- mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION,
- QCameraParameters::FACE_DETECTION_OFF);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION,
- mFaceDetectionValues);
-
- //Set Red Eye Reduction
- mParameters.set(QCameraParameters::KEY_QC_REDEYE_REDUCTION,
- QCameraParameters::REDEYE_REDUCTION_DISABLE);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION,
- mRedeyeReductionValues);
-
- //Set ZSL
- mParameters.set(QCameraParameters::KEY_QC_ZSL,
- QCameraParameters::ZSL_OFF);
- mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES,
- mZslValues);
-
- //Set Focal length, horizontal and vertical view angles
- float focalLength = 0.0f;
- float horizontalViewAngle = 0.0f;
- float verticalViewAngle = 0.0f;
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_FOCAL_LENGTH,
- (void *)&focalLength);
- mParameters.setFloat(QCameraParameters::KEY_FOCAL_LENGTH,
- focalLength);
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE,
- (void *)&horizontalViewAngle);
- mParameters.setFloat(QCameraParameters::KEY_HORIZONTAL_VIEW_ANGLE,
- horizontalViewAngle);
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE,
- (void *)&verticalViewAngle);
- mParameters.setFloat(QCameraParameters::KEY_VERTICAL_VIEW_ANGLE,
- verticalViewAngle);
-
- //Set Exposure Compensation
- mParameters.set(
- QCameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
- EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR);
- mParameters.set(
- QCameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
- EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR);
- mParameters.set(
- QCameraParameters::KEY_EXPOSURE_COMPENSATION,
- EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR);
- mParameters.setFloat(
- QCameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
- EXPOSURE_COMPENSATION_STEP);
-
- mParameters.set("num-snaps-per-shutter", 1);
-
- mParameters.set("capture-burst-captures-values", getZSLQueueDepth());
- mParameters.set("capture-burst-interval-supported", "true");
- mParameters.set("capture-burst-interval-max", BURST_INTREVAL_MAX); /*skip frames*/
- mParameters.set("capture-burst-interval-min", BURST_INTREVAL_MIN); /*skip frames*/
- mParameters.set("capture-burst-interval", BURST_INTREVAL_DEFAULT); /*skip frames*/
- mParameters.set("capture-burst-retroactive", 0);
- mParameters.set("capture-burst-retroactive-max", getZSLQueueDepth());
- mParameters.set("capture-burst-exposures", "");
- mParameters.set("capture-burst-exposures-values",
- "-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12");
- {
- String8 CamModeStr;
- char buffer[32];
- int flag = 0;
-
- for (int i = 0; i < HAL_CAM_MODE_MAX; i++) {
- if ( 0 ) { /*exclude some conflicting case*/
- } else {
- if (flag == 0) { /*first item*/
- snprintf(buffer, sizeof(buffer), "%d", i);
- } else {
- snprintf(buffer, sizeof(buffer), ",%d", i);
- }
- flag = 1;
- CamModeStr.append(buffer);
- }
- }
- mParameters.set("camera-mode-values", CamModeStr);
- }
-
- mParameters.set("ae-bracket-hdr-values",
- create_values_str(hdr_bracket, sizeof(hdr_bracket)/sizeof(str_map) ));
-
- mParameters.set("no-display-mode", 0);
- mParameters.set("zoom", 0);
-
- int mNuberOfVFEOutputs;
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, &mNuberOfVFEOutputs);
- if(ret < 0) {
- ALOGE("get parm MM_CAMERA_PARM_VFE_OUTPUT_ENABLE failed");
- ret = BAD_VALUE;
- }
- if(mNuberOfVFEOutputs == 1)
- {
- mParameters.set(QCameraParameters::KEY_QC_SINGLE_ISP_OUTPUT_ENABLED, "true");
- } else {
- mParameters.set(QCameraParameters::KEY_QC_SINGLE_ISP_OUTPUT_ENABLED, "false");
- }
-
- if (setParameters(mParameters) != NO_ERROR) {
- ALOGE("Failed to set default parameters?!");
- }
- mInitialized = true;
- strTexturesOn = false;
-
- ALOGI("%s: X", __func__);
- return;
-}
-
-/**
- * Set the camera parameters. This returns BAD_VALUE if any parameter is
- * invalid or not supported.
- */
-
-int QCameraHardwareInterface::setParameters(const char *parms)
-{
- QCameraParameters param;
- String8 str = String8(parms);
- param.unflatten(str);
- status_t ret = setParameters(param);
- if(ret == NO_ERROR)
- return 0;
- else
- return -1;
-}
-
-/**
- * Set the camera parameters. This returns BAD_VALUE if any parameter is
- * invalid or not supported. */
-status_t QCameraHardwareInterface::setParameters(const QCameraParameters& params)
-{
- status_t ret = NO_ERROR;
-
- ALOGI("%s: E", __func__);
-// Mutex::Autolock l(&mLock);
- status_t rc, final_rc = NO_ERROR;
- mRestartPreview = false;
-
- if ((rc = setCameraMode(params))) final_rc = rc;
-// if ((rc = setChannelInterfaceMask(params))) final_rc = rc;
- if ((rc = setPowerMode(params))) final_rc = rc;
- if ((rc = setPreviewSize(params))) final_rc = rc;
- if ((rc = setVideoSize(params))) final_rc = rc;
- if ((rc = setPictureSize(params))) final_rc = rc;
- if ((rc = setJpegThumbnailSize(params))) final_rc = rc;
- if ((rc = setJpegQuality(params))) final_rc = rc;
- if ((rc = setEffect(params))) final_rc = rc;
- if ((rc = setGpsLocation(params))) final_rc = rc;
- if ((rc = setRotation(params))) final_rc = rc;
- if ((rc = setZoom(params))) final_rc = rc;
- if ((rc = setOrientation(params))) final_rc = rc;
- if ((rc = setLensshadeValue(params))) final_rc = rc;
- if ((rc = setMCEValue(params))) final_rc = rc;
- if ((rc = setPictureFormat(params))) final_rc = rc;
- if ((rc = setSharpness(params))) final_rc = rc;
- if ((rc = setSaturation(params))) final_rc = rc;
- if ((rc = setSceneMode(params))) final_rc = rc;
- if ((rc = setContrast(params))) final_rc = rc;
- if ((rc = setFaceDetect(params))) final_rc = rc;
- if ((rc = setStrTextures(params))) final_rc = rc;
- if ((rc = setPreviewFormat(params))) final_rc = rc;
- if ((rc = setSkinToneEnhancement(params))) final_rc = rc;
- if ((rc = setWaveletDenoise(params))) final_rc = rc;
- if ((rc = setAntibanding(params))) final_rc = rc;
- // if ((rc = setOverlayFormats(params))) final_rc = rc;
- if ((rc = setRedeyeReduction(params))) final_rc = rc;
- if ((rc = setCaptureBurstExp())) final_rc = rc;
- if ((rc = setRDIMode(params))) final_rc = rc;
-
- const char *str_val = params.get("capture-burst-exposures");
- if ( str_val == NULL || strlen(str_val)==0 ) {
- char burst_exp[PROPERTY_VALUE_MAX];
- memset(burst_exp, 0, sizeof(burst_exp));
- property_get("persist.capture.burst.exposures", burst_exp, "");
- if ( strlen(burst_exp)>0 ) {
- mParameters.set("capture-burst-exposures", burst_exp);
- }
- } else {
- mParameters.set("capture-burst-exposures", str_val);
- }
- mParameters.set("num-snaps-per-shutter", params.get("num-snaps-per-shutter"));
-
- if ((rc = setAEBracket(params))) final_rc = rc;
- // if ((rc = setDenoise(params))) final_rc = rc;
- if ((rc = setPreviewFpsRange(params))) final_rc = rc;
- if((rc = setRecordingHint(params))) final_rc = rc;
- if ((rc = setNumOfSnapshot(params))) final_rc = rc;
- if ((rc = setAecAwbLock(params))) final_rc = rc;
-
- const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
- int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
-
- if((value != NOT_FOUND) && (value == CAMERA_BESTSHOT_OFF )) {
- //if ((rc = setPreviewFrameRateMode(params))) final_rc = rc;
- if ((rc = setPreviewFrameRate(params))) final_rc = rc;
- if ((rc = setAutoExposure(params))) final_rc = rc;
- if ((rc = setExposureCompensation(params))) final_rc = rc;
- if ((rc = setWhiteBalance(params))) final_rc = rc;
- if ((rc = setFlash(params))) final_rc = rc;
- if ((rc = setFocusMode(params))) final_rc = rc;
- if ((rc = setBrightness(params))) final_rc = rc;
- if ((rc = setISOValue(params))) final_rc = rc;
- if ((rc = setFocusAreas(params))) final_rc = rc;
- if ((rc = setMeteringAreas(params))) final_rc = rc;
- }
- //selectableZoneAF needs to be invoked after continuous AF
- if ((rc = setSelectableZoneAf(params))) final_rc = rc;
- // setHighFrameRate needs to be done at end, as there can
- // be a preview restart, and need to use the updated parameters
- if ((rc = setHighFrameRate(params))) final_rc = rc;
- if ((rc = setZSLBurstLookBack(params))) final_rc = rc;
- if ((rc = setZSLBurstInterval(params))) final_rc = rc;
- if ((rc = setNoDisplayMode(params))) final_rc = rc;
- if ((rc = setMobiCat(params))) final_rc = rc;
-
- //Update Exiftag values.
- setExifTags();
-
- if (mRestartPreview) {
- ALOGI("%s: need to restart preview", __func__);
- restartPreview();
- mRestartPreview = false;
- }
-
- ALOGI("%s: X", __func__);
- return final_rc;
-}
-
-/** Retrieve the camera parameters. The buffer returned by the camera HAL
- must be returned back to it with put_parameters, if put_parameters
- is not NULL.
- */
-int QCameraHardwareInterface::getParameters(char **parms)
-{
- char* rc = NULL;
- String8 str;
- QCameraParameters param = getParameters();
- //param.dump();
- str = param.flatten( );
- rc = (char *)malloc(sizeof(char)*(str.length()+1));
- if(rc != NULL){
- memset(rc, 0, sizeof(char)*(str.length()+1));
- strncpy(rc, str.string(), str.length());
- rc[str.length()] = 0;
- *parms = rc;
- }
- return 0;
-}
-
-/** The camera HAL uses its own memory to pass us the parameters when we
- call get_parameters. Use this function to return the memory back to
- the camera HAL, if put_parameters is not NULL. If put_parameters
- is NULL, then you have to use free() to release the memory.
-*/
-void QCameraHardwareInterface::putParameters(char *rc)
-{
- free(rc);
- rc = NULL;
-}
-
-QCameraParameters& QCameraHardwareInterface::getParameters()
-{
- Mutex::Autolock lock(mLock);
- mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string());
- return mParameters;
-}
-
-status_t QCameraHardwareInterface::runFaceDetection()
-{
- bool ret = true;
-
- const char *str = mParameters.get(QCameraParameters::KEY_QC_FACE_DETECTION);
- if (str != NULL) {
- int value = attr_lookup(facedetection,
- sizeof(facedetection) / sizeof(str_map), str);
- fd_set_parm_t fd_set_parm;
- int requested_faces = mParameters.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
- fd_set_parm.fd_mode = value;
- fd_set_parm.num_fd = requested_faces;
- ret = native_set_parms(MM_CAMERA_PARM_FD, sizeof(int8_t), (void *)&value);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSharpness(const QCameraParameters& params)
-{
- bool ret = false;
- int rc = MM_CAMERA_OK;
- ALOGV("%s",__func__);
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_SHARPNESS,(uint8_t*)&rc,(uint8_t*)&rc);
- if(!rc) {
- ALOGE("%s:CONTRAST not supported", __func__);
- return NO_ERROR;
- }
- int sharpness = params.getInt(QCameraParameters::KEY_QC_SHARPNESS);
- if((sharpness < CAMERA_MIN_SHARPNESS
- || sharpness > CAMERA_MAX_SHARPNESS))
- return UNKNOWN_ERROR;
-
- ALOGV("setting sharpness %d", sharpness);
- mParameters.set(QCameraParameters::KEY_QC_SHARPNESS, sharpness);
- ret = native_set_parms(MM_CAMERA_PARM_SHARPNESS, sizeof(sharpness),
- (void *)&sharpness);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
-}
-
-status_t QCameraHardwareInterface::setSaturation(const QCameraParameters& params)
-{
- bool ret = false;
- int rc = MM_CAMERA_OK;
- ALOGV("%s",__func__);
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_SATURATION,(uint8_t*)&rc,(uint8_t*)&rc);
- if(!rc) {
- ALOGE("%s:MM_CAMERA_PARM_SATURATION not supported", __func__);
- return NO_ERROR;
- }
- int result;
- int saturation = params.getInt(QCameraParameters::KEY_QC_SATURATION);
-
- if((saturation < CAMERA_MIN_SATURATION)
- || (saturation > CAMERA_MAX_SATURATION))
- return UNKNOWN_ERROR;
-
- ALOGV("Setting saturation %d", saturation);
- mParameters.set(QCameraParameters::KEY_QC_SATURATION, saturation);
- ret = native_set_parms(MM_CAMERA_PARM_SATURATION, sizeof(saturation),
- (void *)&saturation, (int *)&result);
- if(result != MM_CAMERA_OK)
- ALOGI("Saturation Value: %d is not set as the selected value is not supported", saturation);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
-}
-
-status_t QCameraHardwareInterface::setContrast(const QCameraParameters& params)
-{
- ALOGV("%s E", __func__ );
- int rc = MM_CAMERA_OK;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_CONTRAST,(uint8_t*)&rc,(uint8_t*)&rc);
- if(!rc) {
- ALOGE("%s:CONTRAST not supported", __func__);
- return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
- ALOGE("Contrast : %s",str);
- int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
- if(value == CAMERA_BESTSHOT_OFF) {
- int contrast = params.getInt(QCameraParameters::KEY_QC_CONTRAST);
- if((contrast < CAMERA_MIN_CONTRAST)
- || (contrast > CAMERA_MAX_CONTRAST))
- {
- ALOGE("Contrast Value not matching");
- return UNKNOWN_ERROR;
- }
- ALOGV("setting contrast %d", contrast);
- mParameters.set(QCameraParameters::KEY_QC_CONTRAST, contrast);
- ALOGE("Calling Contrast set on Lower layer");
- bool ret = native_set_parms(MM_CAMERA_PARM_CONTRAST, sizeof(contrast),
- (void *)&contrast);
- ALOGE("Lower layer returned %d", ret);
- int bestshot_reconfigure;
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
- &bestshot_reconfigure);
- if(bestshot_reconfigure) {
- if (mContrast != contrast) {
- mContrast = contrast;
- if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
- mRestartPreview = true;
- }
- }
- }
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- } else {
- ALOGI(" Contrast value will not be set " \
- "when the scenemode selected is %s", str);
- return NO_ERROR;
- }
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSceneDetect(const QCameraParameters& params)
-{
- ALOGV("%s",__func__);
- bool retParm;
- int rc = 0;
-
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_ASD_ENABLE,(uint8_t*)&rc,(uint8_t*)&rc);
- if(!rc) {
- ALOGE("%s:MM_CAMERA_PARM_ASD_ENABLE not supported", __func__);
- return NO_ERROR;
- }
-
- const char *str = params.get(QCameraParameters::KEY_QC_SCENE_DETECT);
- ALOGE("Scene Detect string : %s",str);
- if (str != NULL) {
- int32_t value = attr_lookup(scenedetect, sizeof(scenedetect) / sizeof(str_map), str);
- ALOGE("Scenedetect Value : %d",value);
- if (value != NOT_FOUND) {
- mParameters.set(QCameraParameters::KEY_QC_SCENE_DETECT, str);
-
- retParm = native_set_parms(MM_CAMERA_PARM_ASD_ENABLE, sizeof(value),
- (void *)&value);
-
- return retParm ? NO_ERROR : UNKNOWN_ERROR;
- }
- }
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setZoom(const QCameraParameters& params)
-{
- status_t rc = NO_ERROR;
-
- ALOGV("%s: E",__func__);
- uint8_t supported;
-
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_ZOOM,&supported,&supported);
- if(!supported){
- ALOGE("%s:MM_CAMERA_PARM_ZOOM not supported", __func__);
- return NO_ERROR;
- }
- // No matter how many different zoom values the driver can provide, HAL
- // provides applictations the same number of zoom levels. The maximum driver
- // zoom value depends on sensor output (VFE input) and preview size (VFE
- // output) because VFE can only crop and cannot upscale. If the preview size
- // is bigger, the maximum zoom ratio is smaller. However, we want the
- // zoom ratio of each zoom level is always the same whatever the preview
- // size is. Ex: zoom level 1 is always 1.2x, zoom level 2 is 1.44x, etc. So,
- // we need to have a fixed maximum zoom value and do read it from the
- // driver.
- static const int ZOOM_STEP = 1;
- int32_t zoom_level = params.getInt("zoom");
- if(zoom_level >= 0 && zoom_level <= mMaxZoom-1) {
- mParameters.set("zoom", zoom_level);
- int32_t zoom_value = ZOOM_STEP * zoom_level;
- bool ret = native_set_parms(MM_CAMERA_PARM_ZOOM,
- sizeof(zoom_value), (void *)&zoom_value);
- if(ret) {
- mCurrentZoom=zoom_level;
- }
- rc = ret ? NO_ERROR : UNKNOWN_ERROR;
- } else {
- rc = BAD_VALUE;
- }
- ALOGV("%s X",__func__);
- return rc;
-
-}
-
-status_t QCameraHardwareInterface::setISOValue(const QCameraParameters& params) {
-
- ALOGV("%s",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_ISO,&supported,&supported);
- if(!supported) {
- ALOGE("%s:MM_CAMERA_PARM_ISO not supported", __func__);
- return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_QC_ISO_MODE);
- ALOGV("ISO string : %s",str);
- int8_t temp_hjr;
- if (str != NULL) {
- int value = (camera_iso_mode_type)attr_lookup(
- iso, sizeof(iso) / sizeof(str_map), str);
- ALOGE("ISO Value : %d",value);
- if (value != NOT_FOUND) {
- camera_iso_mode_type temp = (camera_iso_mode_type) value;
- if (value == CAMERA_ISO_DEBLUR) {
- temp_hjr = true;
- native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr);
- mHJR = value;
- }
- else {
- if (mHJR == CAMERA_ISO_DEBLUR) {
- temp_hjr = false;
- native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr);
- mHJR = value;
- }
- }
-
- mParameters.set(QCameraParameters::KEY_QC_ISO_MODE, str);
- native_set_parms(MM_CAMERA_PARM_ISO, sizeof(camera_iso_mode_type), (void *)&temp);
- return NO_ERROR;
- }
- }
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::updateFocusDistances()
-{
- ALOGV("%s: IN", __FUNCTION__);
- focus_distances_info_t focusDistances;
- if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_FOCUS_DISTANCES,
- &focusDistances) >= 0) {
- String8 str;
- char buffer[32] = {0};
- //set all distances to infinity if focus mode is infinity
- if(mFocusMode == AF_MODE_INFINITY) {
- snprintf(buffer, sizeof(buffer), "Infinity,");
- str.append(buffer);
- snprintf(buffer, sizeof(buffer), "Infinity,");
- str.append(buffer);
- snprintf(buffer, sizeof(buffer), "Infinity");
- str.append(buffer);
- } else {
- snprintf(buffer, sizeof(buffer), "%f", focusDistances.focus_distance[0]);
- str.append(buffer);
- snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[1]);
- str.append(buffer);
- snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[2]);
- str.append(buffer);
- }
- ALOGE("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string());
- mFocusDistance = str;
- return NO_ERROR;
- }
- ALOGV("%s: get CAMERA_PARM_FOCUS_DISTANCES failed!!!", __FUNCTION__);
- return BAD_VALUE;
-}
-
-// Parse string like "(1, 2, 3, 4, ..., N)"
-// num is pointer to an allocated array of size N
-static int parseNDimVector(const char *str, int *num, int N, char delim = ',')
-{
- char *start, *end;
- if(num == NULL) {
- ALOGE("Invalid output array (num == NULL)");
- return -1;
- }
- //check if string starts and ends with parantheses
- if(str[0] != '(' || str[strlen(str)-1] != ')') {
- ALOGE("Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", str);
- return -1;
- }
- start = (char*) str;
- start++;
- for(int i=0; i<N; i++) {
- *(num+i) = (int) strtol(start, &end, 10);
- if(*end != delim && i < N-1) {
- ALOGE("Cannot find delimeter '%c' in string \"%s\". end = %c", delim, str, *end);
- return -1;
- }
- start = end+1;
- }
- return 0;
-}
-
-// parse string like "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..."
-static int parseCameraAreaString(const char* str, int max_num_areas,
- camera_area_t *pAreas, int *num_areas_found)
-{
- char area_str[32];
- const char *start, *end, *p;
- start = str; end = NULL;
- int values[5], index=0;
- *num_areas_found = 0;
-
- while(start != NULL) {
- if(*start != '(') {
- ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
- return -1;
- }
- end = strchr(start, ')');
- if(end == NULL) {
- ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
- return -1;
- }
- int i;
- for (i=0,p=start; p<=end; p++, i++) {
- area_str[i] = *p;
- }
- area_str[i] = '\0';
- if(parseNDimVector(area_str, values, 5) < 0){
- ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str);
- return -1;
- }
- // no more areas than max_num_areas are accepted.
- if(index >= max_num_areas) {
- ALOGE("%s: error: too many areas specified %s", __func__, str);
- return -1;
- }
- pAreas[index].x1 = values[0];
- pAreas[index].y1 = values[1];
- pAreas[index].x2 = values[2];
- pAreas[index].y2 = values[3];
- pAreas[index].weight = values[4];
-
- index++;
- start = strchr(end, '('); // serach for next '('
- }
- (*num_areas_found) = index;
- return 0;
-}
-static bool validateCameraAreas(camera_area_t *areas, int num_areas)
-{
- for(int i=0; i<num_areas; i++) {
-
- // handle special case (0, 0, 0, 0, 0)
- if((areas[i].x1 == 0) && (areas[i].y1 == 0)
- && (areas[i].x2 == 0) && (areas[i].y2 == 0) && (areas[i].weight == 0)) {
- continue;
- }
- if(areas[i].x1 < -1000) return false; // left should be >= -1000
- if(areas[i].y1 < -1000) return false; // top should be >= -1000
- if(areas[i].x2 > 1000) return false; // right should be <= 1000
- if(areas[i].y2 > 1000) return false; // bottom should be <= 1000
- if(areas[i].weight <= 0 || areas[i].weight > 1000) // weight should be in [1, 1000]
- return false;
- if(areas[i].x1 >= areas[i].x2) { // left should be < right
- return false;
- }
- if(areas[i].y1 >= areas[i].y2) // top should be < bottom
- return false;
- }
- return true;
-}
-
-status_t QCameraHardwareInterface::setFocusAreas(const QCameraParameters& params)
-{
- ALOGV("%s: E", __func__);
- status_t rc;
- int max_num_af_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS);
- if(max_num_af_areas == 0) {
- return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_FOCUS_AREAS);
- if (str == NULL) {
- ALOGE("%s: Parameter string is null", __func__);
- rc = NO_ERROR;
- } else {
- camera_area_t *areas = new camera_area_t[max_num_af_areas];
- int num_areas_found=0;
- if(parseCameraAreaString(str, max_num_af_areas, areas, &num_areas_found) < 0) {
- ALOGE("%s: Failed to parse the string: %s", __func__, str);
- delete areas;
- return BAD_VALUE;
- }
- for(int i=0; i<num_areas_found; i++) {
- ALOGD("FocusArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1),
- (areas[i].x2), (areas[i].y2), (areas[i].weight));
- }
- if(validateCameraAreas(areas, num_areas_found) == false) {
- ALOGE("%s: invalid areas specified : %s", __func__, str);
- delete areas;
- return BAD_VALUE;
- }
- mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, str);
- num_areas_found = 1; //temp; need to change after the multi-roi is enabled
-
- //if the native_set_parms is called when preview is not started, it
- //crashes in lower layer, so return of preview is not started
- if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) {
- delete areas;
- return NO_ERROR;
- }
-
- //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
- //so no action is takenby the lower layer
- if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0)
- && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) {
- num_areas_found = 0;
- }
- roi_info_t af_roi_value;
- memset(&af_roi_value, 0, sizeof(roi_info_t));
- uint16_t x1, x2, y1, y2, dx, dy;
- int previewWidth, previewHeight;
- this->getPreviewSize(&previewWidth, &previewHeight);
- //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
- x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f));
- y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f));
- x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f));
- y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f));
- dx = x2 - x1;
- dy = y2 - y1;
-
- af_roi_value.num_roi = num_areas_found;
- af_roi_value.roi[0].x = x1;
- af_roi_value.roi[0].y = y1;
- af_roi_value.roi[0].dx = dx;
- af_roi_value.roi[0].dy = dy;
- af_roi_value.is_multiwindow = 0;
- if (native_set_parms(MM_CAMERA_PARM_AF_ROI, sizeof(roi_info_t), (void*)&af_roi_value))
- rc = NO_ERROR;
- else
- rc = BAD_VALUE;
- delete areas;
- }
- ALOGE("%s: X", __func__);
- return rc;
-}
-
-status_t QCameraHardwareInterface::setMeteringAreas(const QCameraParameters& params)
-{
- ALOGV("%s: E", __func__);
- status_t rc;
- int max_num_mtr_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_METERING_AREAS);
- if(max_num_mtr_areas == 0) {
- return NO_ERROR;
- }
-
- const char *str = params.get(QCameraParameters::KEY_METERING_AREAS);
- if (str == NULL) {
- ALOGE("%s: Parameter string is null", __func__);
- rc = NO_ERROR;
- } else {
- camera_area_t *areas = new camera_area_t[max_num_mtr_areas];
- int num_areas_found=0;
- if(parseCameraAreaString(str, max_num_mtr_areas, areas, &num_areas_found) < 0) {
- ALOGE("%s: Failed to parse the string: %s", __func__, str);
- delete areas;
- return BAD_VALUE;
- }
- for(int i=0; i<num_areas_found; i++) {
- ALOGD("MeteringArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1),
- (areas[i].x2), (areas[i].y2), (areas[i].weight));
- }
- if(validateCameraAreas(areas, num_areas_found) == false) {
- ALOGE("%s: invalid areas specified : %s", __func__, str);
- delete areas;
- return BAD_VALUE;
- }
- mParameters.set(QCameraParameters::KEY_METERING_AREAS, str);
-
- //if the native_set_parms is called when preview is not started, it
- //crashes in lower layer, so return of preview is not started
- if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) {
- delete areas;
- return NO_ERROR;
- }
-
- num_areas_found = 1; //temp; need to change after the multi-roi is enabled
-
- //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
- //so no action is takenby the lower layer
- if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0)
- && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) {
- num_areas_found = 0;
- }
- cam_set_aec_roi_t aec_roi_value;
- uint16_t x1, x2, y1, y2;
- int previewWidth, previewHeight;
- this->getPreviewSize(&previewWidth, &previewHeight);
- //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
- x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f));
- y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f));
- x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f));
- y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f));
- delete areas;
-
- if(num_areas_found == 1) {
- aec_roi_value.aec_roi_enable = AEC_ROI_ON;
- aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE;
- aec_roi_value.aec_roi_position.coordinate.x = (x1+x2)/2;
- aec_roi_value.aec_roi_position.coordinate.y = (y1+y2)/2;
- } else {
- aec_roi_value.aec_roi_enable = AEC_ROI_OFF;
- aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE;
- aec_roi_value.aec_roi_position.coordinate.x = DONT_CARE_COORDINATE;
- aec_roi_value.aec_roi_position.coordinate.y = DONT_CARE_COORDINATE;
- }
-
- if(native_set_parms(MM_CAMERA_PARM_AEC_ROI, sizeof(cam_set_aec_roi_t), (void *)&aec_roi_value))
- rc = NO_ERROR;
- else
- rc = BAD_VALUE;
- }
- ALOGV("%s: X", __func__);
- return rc;
-}
-
-status_t QCameraHardwareInterface::setFocusMode(const QCameraParameters& params)
-{
- const char *str = params.get(QCameraParameters::KEY_FOCUS_MODE);
- const char *prev_str = mParameters.get(QCameraParameters::KEY_FOCUS_MODE);
- ALOGV("%s",__func__);
- if (str != NULL) {
- ALOGE("Focus mode %s",str);
- int32_t value = attr_lookup(focus_modes,
- sizeof(focus_modes) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- mParameters.set(QCameraParameters::KEY_FOCUS_MODE, str);
- mFocusMode = value;
-
- if(updateFocusDistances() != NO_ERROR) {
- ALOGE("%s: updateFocusDistances failed for %s", __FUNCTION__, str);
- return UNKNOWN_ERROR;
- }
- mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string());
- if(mHasAutoFocusSupport){
- bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_MODE,
- sizeof(value),
- (void *)&value);
-
- int cafSupport = FALSE;
- if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ||
- !strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)){
- cafSupport = TRUE;
- }
- ALOGE("Continuous Auto Focus %d", cafSupport);
- ret = native_set_parms(MM_CAMERA_PARM_CONTINUOUS_AF, sizeof(cafSupport),
- (void *)&cafSupport);
- }
-
- return NO_ERROR;
- }
- ALOGE("%s:Could not look up str value",__func__);
- }
- ALOGE("Invalid focus mode value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSceneMode(const QCameraParameters& params)
-{
- ALOGV("%s",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_BESTSHOT_MODE,&supported,&supported);
- if(!supported) {
- ALOGE("%s:Parameter Scenemode is not supported for this sensor", __func__);
- return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
- ALOGE("Scene Mode string : %s",str);
-
- if (str != NULL) {
- int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
- ALOGE("Setting Scenemode value = %d",value );
- if (value != NOT_FOUND) {
- if((value != CAMERA_BESTSHOT_OFF ) && (mColorEffects != CAMERA_EFFECT_OFF )) {
- int result;
- mColorEffects = CAMERA_EFFECT_OFF;
- native_set_parms(MM_CAMERA_PARM_EFFECT, sizeof(mColorEffects),
- (void *)&mColorEffects,(int *)&result);
- if(result != MM_CAMERA_OK) {
- ALOGI("Camera Effect is not set as the EFFECT_NONE and result is not OK");
- }
- }
- mParameters.set(QCameraParameters::KEY_SCENE_MODE, str);
- bool ret = native_set_parms(MM_CAMERA_PARM_BESTSHOT_MODE, sizeof(value),
- (void *)&value);
- int bestshot_reconfigure;
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
- &bestshot_reconfigure);
- if(bestshot_reconfigure) {
- if (mBestShotMode != value) {
- mBestShotMode = value;
- if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
- mRestartPreview = true;
- }
- }
- }
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- }
- ALOGE("Invalid scenemode value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSelectableZoneAf(const QCameraParameters& params)
-{
- ALOGV("%s",__func__);
- uint8_t supported;
- if(mHasAutoFocusSupport) {
- const char *str = params.get(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF);
- if (str != NULL) {
- int32_t value = attr_lookup(selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_FOCUS_RECT,&supported,&supported);
- if(!supported) {
- ALOGE("SelectableZoneAF is not supported for this sensor");
- return NO_ERROR;
- }else {
- mParameters.set(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF, str);
- bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_RECT, sizeof(value),
- (void *)&value);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- }
- }
- ALOGE("Invalid selectable zone af value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setEffect(const QCameraParameters& params)
-{
- ALOGV("%s",__func__);
- uint8_t supported;
- const char *str = params.get(CameraParameters::KEY_EFFECT);
- int result;
- mColorEffects = CAMERA_EFFECT_OFF;
- if (str != NULL) {
- ALOGE("Setting effect %s",str);
- int32_t value = attr_lookup(effects, sizeof(effects) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_EFFECT,&supported,&supported);
- if(!supported) {
- ALOGE("Camera Effect - %s mode is not supported for this sensor",str);
- return NO_ERROR;
- }else {
- mParameters.set(QCameraParameters::KEY_EFFECT, str);
- ALOGE("Setting effect to lower HAL : %d",value);
- mColorEffects = value;
- bool ret = native_set_parms(MM_CAMERA_PARM_EFFECT, sizeof(value),
- (void *)&value,(int *)&result);
- if(result != 0) {
- ALOGI("Camera Effect: %s is not set as the selected value is not supported ", str);
- }
- int bestshot_reconfigure;
- mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
- &bestshot_reconfigure);
- if(bestshot_reconfigure) {
- if (mEffects != value) {
- mEffects = value;
- if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
- mRestartPreview = true;
- }
- }
- }
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- }
- }
- ALOGE("Invalid effect value: %s", (str == NULL) ? "NULL" : str);
- ALOGV("setEffect X");
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setBrightness(const QCameraParameters& params) {
-
- ALOGV("%s",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_BRIGHTNESS,&supported,&supported);
- if(!supported) {
- ALOGE("MM_CAMERA_PARM_BRIGHTNESS mode is not supported for this sensor");
- return NO_ERROR;
- }
- int brightness = params.getInt("luma-adaptation");
- if (mBrightness != brightness) {
- ALOGV(" new brightness value : %d ", brightness);
- mBrightness = brightness;
- mParameters.set("luma-adaptation", brightness);
- bool ret = native_set_parms(MM_CAMERA_PARM_BRIGHTNESS, sizeof(mBrightness),
- (void *)&mBrightness);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
-
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setAutoExposure(const QCameraParameters& params)
-{
-
- ALOGV("%s",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_EXPOSURE,&supported,&supported);
- if(!supported) {
- ALOGE("MM_CAMERA_PARM_EXPOSURE mode is not supported for this sensor");
- return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_QC_AUTO_EXPOSURE);
- if (str != NULL) {
- int32_t value = attr_lookup(autoexposure, sizeof(autoexposure) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- mParameters.set(QCameraParameters::KEY_QC_AUTO_EXPOSURE, str);
- bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE, sizeof(value),
- (void *)&value);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- }
- ALOGE("Invalid auto exposure value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setExposureCompensation(
- const QCameraParameters & params){
- ALOGV("%s",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_EXPOSURE_COMPENSATION,&supported,&supported);
- if(!supported) {
- ALOGE("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor");
- return NO_ERROR;
- }
- int numerator = params.getInt(QCameraParameters::KEY_EXPOSURE_COMPENSATION);
- if(EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR <= numerator &&
- numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){
- int16_t numerator16 = (int16_t)(numerator & 0x0000ffff);
- uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR;
- uint32_t value = 0;
- value = numerator16 << 16 | denominator16;
-
- mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION,
- numerator);
- bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE_COMPENSATION,
- sizeof(value), (void *)&value);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- ALOGE("Invalid Exposure Compensation");
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setWhiteBalance(const QCameraParameters& params)
-{
-
- ALOGV("%s",__func__);
- status_t rc = NO_ERROR;
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_WHITE_BALANCE,&supported,&supported);
- if(!supported) {
- ALOGE("MM_CAMERA_PARM_WHITE_BALANCE mode is not supported for this sensor");
- return NO_ERROR;
- }
- int result;
-
- const char *str = params.get(QCameraParameters::KEY_WHITE_BALANCE);
- if (str != NULL) {
- int32_t value = attr_lookup(whitebalance, sizeof(whitebalance) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str);
- bool ret = native_set_parms(MM_CAMERA_PARM_WHITE_BALANCE, sizeof(value),
- (void *)&value, (int *)&result);
- if(result != MM_CAMERA_OK) {
- ALOGI("WhiteBalance Value: %s is not set as the selected value is not supported ", str);
- }
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- }
- ALOGE("Invalid whitebalance value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-int QCameraHardwareInterface::getAutoFlickerMode()
-{
- /* Enable Advanced Auto Antibanding where we can set
- any of the following option
- ie. CAMERA_ANTIBANDING_AUTO
- CAMERA_ANTIBANDING_AUTO_50HZ
- CAMERA_ANTIBANDING_AUTO_60HZ
- Currently setting it to default */
- return CAMERA_ANTIBANDING_AUTO;
-}
-
-status_t QCameraHardwareInterface::setAntibanding(const QCameraParameters& params)
-{
- int result;
-
- ALOGV("%s",__func__);
- status_t rc = NO_ERROR;
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_ANTIBANDING,&supported,&supported);
- if(!supported) {
- ALOGE("ANTIBANDING mode is not supported for this sensor");
- return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_ANTIBANDING);
- if (str != NULL) {
- int value = (camera_antibanding_type)attr_lookup(
- antibanding, sizeof(antibanding) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- camera_antibanding_type temp = (camera_antibanding_type) value;
- ALOGE("Antibanding Value : %d",value);
- mParameters.set(QCameraParameters::KEY_ANTIBANDING, str);
- if(value == CAMERA_ANTIBANDING_AUTO) {
- value = getAutoFlickerMode();
- }
- bool ret = native_set_parms(MM_CAMERA_PARM_ANTIBANDING,
- sizeof(camera_antibanding_type), (void *)&value ,(int *)&result);
- if(result != MM_CAMERA_OK) {
- ALOGI("AntiBanding Value: %s is not supported for the given BestShot Mode", str);
- }
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- }
- ALOGE("Invalid antibanding value: %s", (str == NULL) ? "NULL" : str);
-
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setPreviewFrameRate(const QCameraParameters& params)
-{
- ALOGV("%s: E",__func__);
- status_t rc = NO_ERROR;
- uint16_t fps = (uint16_t)params.getPreviewFrameRate();
- ALOGV("%s: requested preview frame rate is %d", __func__, fps);
-
- mParameters.setPreviewFrameRate(fps);
- ALOGV("%s: X",__func__);
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setPreviewFrameRateMode(const QCameraParameters& params) {
-
- ALOGV("%s",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_FPS,&supported,&supported);
- if(!supported) {
- ALOGE(" CAMERA FPS mode is not supported for this sensor");
- return NO_ERROR;
- }
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_FPS_MODE,&supported,&supported);
- if(!supported) {
- ALOGE("CAMERA FPS MODE mode is not supported for this sensor");
- return NO_ERROR;
- }
-
- const char *previousMode = mParameters.getPreviewFrameRateMode();
- const char *str = params.getPreviewFrameRateMode();
- if (NULL == previousMode) {
- ALOGE("Preview Frame Rate Mode is NULL\n");
- return NO_ERROR;
- }
- if (NULL == str) {
- ALOGE("Preview Frame Rate Mode is NULL\n");
- return NO_ERROR;
- }
- if( mInitialized && !strcmp(previousMode, str)) {
- ALOGE("frame rate mode same as previous mode %s", previousMode);
- return NO_ERROR;
- }
- int32_t frameRateMode = attr_lookup(frame_rate_modes, sizeof(frame_rate_modes) / sizeof(str_map),str);
- if(frameRateMode != NOT_FOUND) {
- ALOGV("setPreviewFrameRateMode: %s ", str);
- mParameters.setPreviewFrameRateMode(str);
- bool ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(frameRateMode), (void *)&frameRateMode);
- if(!ret) return ret;
- //set the fps value when chaging modes
- int16_t fps = (uint16_t)params.getPreviewFrameRate();
- if(MINIMUM_FPS <= fps && fps <=MAXIMUM_FPS){
- mParameters.setPreviewFrameRate(fps);
- ret = native_set_parms(MM_CAMERA_PARM_FPS,
- sizeof(fps), (void *)&fps);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- ALOGE("Invalid preview frame rate value: %d", fps);
- return BAD_VALUE;
- }
- ALOGE("Invalid preview frame rate mode value: %s", (str == NULL) ? "NULL" : str);
-
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setSkinToneEnhancement(const QCameraParameters& params) {
- ALOGV("%s",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_SCE_FACTOR,&supported,&supported);
- if(!supported) {
- ALOGE("SkinToneEnhancement is not supported for this sensor");
- return NO_ERROR;
- }
- int skinToneValue = params.getInt("skinToneEnhancement");
- if (mSkinToneEnhancement != skinToneValue) {
- ALOGV(" new skinTone correction value : %d ", skinToneValue);
- mSkinToneEnhancement = skinToneValue;
- mParameters.set("skinToneEnhancement", skinToneValue);
- bool ret = native_set_parms(MM_CAMERA_PARM_SCE_FACTOR, sizeof(mSkinToneEnhancement),
- (void *)&mSkinToneEnhancement);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setWaveletDenoise(const QCameraParameters& params) {
- ALOGV("%s",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_WAVELET_DENOISE,&supported,&supported);
- if( !supported ) {
- ALOGE("Wavelet Denoise is not supported for this sensor");
- /* TO DO */
-// return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_QC_DENOISE);
- if (str != NULL) {
- int value = attr_lookup(denoise,
- sizeof(denoise) / sizeof(str_map), str);
- if ((value != NOT_FOUND) && (mDenoiseValue != value)) {
- mDenoiseValue = value;
- mParameters.set(QCameraParameters::KEY_QC_DENOISE, str);
-
- char prop[PROPERTY_VALUE_MAX];
- memset(prop, 0, sizeof(prop));
- property_get("persist.denoise.process.plates", prop, "0");
-
- denoise_param_t temp;
- memset(&temp, 0, sizeof(denoise_param_t));
- temp.denoise_enable = value;
- switch(atoi(prop)) {
- case 0:
- temp.process_plates = WAVELET_DENOISE_YCBCR_PLANE;
- break;
- case 1:
- temp.process_plates = WAVELET_DENOISE_CBCR_ONLY;
- break;
- case 2:
- temp.process_plates = WAVELET_DENOISE_STREAMLINE_YCBCR;
- break;
- case 3:
- temp.process_plates = WAVELET_DENOISE_STREAMLINED_CBCR;
- break;
- default:
- temp.process_plates = WAVELET_DENOISE_STREAMLINE_YCBCR;
- break;
- }
- ALOGE("Denoise enable=%d, plates=%d", temp.denoise_enable, temp.process_plates);
- bool ret = native_set_parms(MM_CAMERA_PARM_WAVELET_DENOISE, sizeof(temp),
- (void *)&temp);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- return NO_ERROR;
- }
- ALOGE("Invalid Denoise value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setVideoSize(const QCameraParameters& params)
-{
- const char *str= NULL;
- const char *str_t= NULL;
- int old_vid_w = 0, old_vid_h = 0;
- ALOGV("%s: E", __func__);
- str = params.get(QCameraParameters::KEY_VIDEO_SIZE);
- str_t = mParameters.get(CameraParameters::KEY_VIDEO_SIZE);
- if(!str) {
- mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, "");
- //If application didn't set this parameter string, use the values from
- //getPreviewSize() as video dimensions.
- ALOGE("No Record Size requested, use the preview dimensions");
- videoWidth = mPreviewWidth;
- videoHeight = mPreviewHeight;
- } else {
- //Extract the record witdh and height that application requested.
- ALOGI("%s: requested record size %s", __func__, str);
- if(!parse_size(str, videoWidth, videoHeight)) {
- parse_size(str_t, old_vid_w, old_vid_h);
- mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, str);
- if((QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) &&
- (old_vid_w != videoWidth || old_vid_h != videoHeight)) {
- ALOGE("%s: Video sizes changes to %s, Restart preview...", __func__, str);
- mRestartPreview = true;
- }
- } else {
- mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, "");
- ALOGE("%s: error :failed to parse parameter record-size (%s)", __func__, str);
- return BAD_VALUE;
- }
- }
- ALOGV("%s: preview dimensions: %dx%d", __func__, mPreviewWidth, mPreviewHeight);
- ALOGV("%s: video dimensions: %dx%d", __func__, videoWidth, videoHeight);
- mDimension.orig_video_width = videoWidth;
- mDimension.orig_video_height = videoHeight;
- mDimension.video_width = videoWidth;
- mDimension.video_height = videoHeight;
-
- ALOGV("%s: X", __func__);
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setCameraMode(const QCameraParameters& params) {
- int32_t value = params.getInt(QCameraParameters::KEY_QC_CAMERA_MODE);
- mParameters.set(QCameraParameters::KEY_QC_CAMERA_MODE,value);
-
- ALOGI("ZSL is enabled %d", value);
- if (value == 1) {
- myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE);
- } else {
- myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE);
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setPowerMode(const QCameraParameters& params) {
- uint32_t value = NORMAL_POWER;
- const char *powermode = NULL;
-
- powermode = params.get(QCameraParameters::KEY_QC_POWER_MODE);
- if (powermode != NULL) {
- value = attr_lookup(power_modes,
- sizeof(power_modes) / sizeof(str_map), powermode);
- if((value == LOW_POWER) || mHFRLevel > 1) {
- ALOGI("Enable Low Power Mode");
- value = LOW_POWER;
- mPowerMode = value;
- mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Low_Power");
- } else {
- ALOGE("Enable Normal Power Mode");
- mPowerMode = value;
- mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Normal_Power");
- }
- }
-
- ALOGI("%s Low power mode %s value = %d", __func__,
- value ? "Enabled" : "Disabled", value);
- native_set_parms(MM_CAMERA_PARM_LOW_POWER_MODE, sizeof(value),
- (void *)&value);
- return NO_ERROR;
-}
-
-
-status_t QCameraHardwareInterface::setPreviewSize(const QCameraParameters& params)
-{
- int width, height;
- params.getPreviewSize(&width, &height);
- ALOGV("################requested preview size %d x %d", width, height);
-
- // Validate the preview size
- for (size_t i = 0; i < mPreviewSizeCount; ++i) {
- if (width == mPreviewSizes[i].width
- && height == mPreviewSizes[i].height) {
- mParameters.setPreviewSize(width, height);
- ALOGE("setPreviewSize: width: %d heigh: %d", width, height);
- mPreviewWidth = width;
- mPreviewHeight = height;
- mDimension.display_width = width;
- mDimension.display_height = height;
- return NO_ERROR;
- }
- }
- ALOGE("Invalid preview size requested: %dx%d", width, height);
- return BAD_VALUE;
-}
-status_t QCameraHardwareInterface::setPreviewFpsRange(const QCameraParameters& params)
-{
- ALOGV("%s: E", __func__);
- int minFps,maxFps;
- int prevMinFps, prevMaxFps;
- int rc = NO_ERROR;
- bool found = false;
-
- mParameters.getPreviewFpsRange(&prevMinFps, &prevMaxFps);
- ALOGV("%s: Existing FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps);
- params.getPreviewFpsRange(&minFps,&maxFps);
- ALOGV("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps);
-
- if(mInitialized && (minFps == prevMinFps && maxFps == prevMaxFps)) {
- ALOGE("%s: No change in FpsRange", __func__);
- rc = NO_ERROR;
- goto end;
- }
- for(int i=0; i<mSupportedFpsRangesCount; i++) {
- // if the value is in the supported list
- if(minFps >= mSupportedFpsRanges[i].minFPS && maxFps <= mSupportedFpsRanges[i].maxFPS) {
- found = true;
- ALOGE("FPS: i=%d : minFps = %d, maxFps = %d ", i, minFps, maxFps);
- mParameters.setPreviewFpsRange(minFps,maxFps);
- // validate the values
- bool valid = true;
- // FPS can not be negative
- if(minFps < 0 || maxFps < 0) valid = false;
- // minFps must be >= maxFps
- if(minFps > maxFps) valid = false;
-
- if(valid) {
- //Set the FPS mode
- const char *str = (minFps == maxFps) ?
- QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE:
- QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE;
- ALOGE("%s FPS_MODE = %s", __func__, str);
- int32_t frameRateMode = attr_lookup(frame_rate_modes,
- sizeof(frame_rate_modes) / sizeof(str_map),str);
- bool ret;
- ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(int32_t),
- (void *)&frameRateMode);
-
- //set FPS values
- uint32_t fps; //lower 2 bytes specify maxFps and higher 2 bytes specify minFps
- fps = ((uint32_t)(minFps/1000) << 16) + ((uint16_t)(maxFps/1000));
-
- ret = native_set_parms(MM_CAMERA_PARM_FPS, sizeof(uint32_t), (void *)&fps);
- mParameters.setPreviewFpsRange(minFps, maxFps);
- if(ret)
- rc = NO_ERROR;
- else {
- rc = BAD_VALUE;
- ALOGE("%s: error: native_set_params failed", __func__);
- }
- } else {
- ALOGE("%s: error: invalid FPS range value", __func__);
- rc = BAD_VALUE;
- }
- }
- }
- if(found == false){
- ALOGE("%s: error: FPS range value not supported", __func__);
- rc = BAD_VALUE;
- }
-end:
- ALOGV("%s: X", __func__);
- return rc;
-}
-
-status_t QCameraHardwareInterface::setJpegThumbnailSize(const QCameraParameters& params){
- int width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
- int height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
-
- ALOGV("requested jpeg thumbnail size %d x %d", width, height);
-
- // Validate the picture size
- for (unsigned int i = 0; i < thumbnail_sizes_count; ++i) {
- if (width == default_thumbnail_sizes[i].width
- && height == default_thumbnail_sizes[i].height) {
- thumbnailWidth = width;
- thumbnailHeight = height;
- mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
- mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
- return NO_ERROR;
- }
- }
- ALOGE("error: setting jpeg thumbnail size");
- return BAD_VALUE;
-}
-status_t QCameraHardwareInterface::setPictureSize(const QCameraParameters& params)
-{
- int width, height;
- ALOGV("QualcommCameraHardware::setPictureSize E");
- params.getPictureSize(&width, &height);
- ALOGE("requested picture size %d x %d", width, height);
-
- // Validate the picture size
- for (int i = 0; i < mSupportedPictureSizesCount; ++i) {
- if (width == mPictureSizesPtr[i].width
- && height == mPictureSizesPtr[i].height) {
- int old_width, old_height;
- mParameters.getPictureSize(&old_width,&old_height);
- mParameters.setPictureSize(width, height);
- mDimension.picture_width = width;
- mDimension.picture_height = height;
- if((QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) &&
- (width != old_width || height != old_height)) {
- mRestartPreview = true;
- }
- return NO_ERROR;
- }
- }
- /* Dimension not among the ones in the list. Check if
- * its a valid dimension, if it is, then configure the
- * camera accordingly. else reject it.
- */
- if( isValidDimension(width, height) ) {
- mParameters.setPictureSize(width, height);
- mDimension.picture_width = width;
- mDimension.picture_height = height;
- return NO_ERROR;
- } else
- ALOGE("Invalid picture size requested: %dx%d", width, height);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setJpegRotation(int isZsl) {
-// return mm_jpeg_encoder_setRotation(mRotation, isZsl);
- return NO_ERROR;
-}
-
-int QCameraHardwareInterface::getJpegRotation(void) {
- ALOGE("%s : rotation is %d", __func__, mRotation);
- return mRotation;
-}
-
-int QCameraHardwareInterface::getISOSpeedValue()
-{
- const char *iso_str = mParameters.get(QCameraParameters::KEY_QC_ISO_MODE);
- int iso_index = attr_lookup(iso, sizeof(iso) / sizeof(str_map), iso_str);
- int iso_value = iso_speed_values[iso_index];
- return iso_value;
-}
-
-
-status_t QCameraHardwareInterface::setJpegQuality(const QCameraParameters& params) {
- status_t rc = NO_ERROR;
- int quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY);
- ALOGV("setJpegQuality E");
- if (quality >= 0 && quality <= 100) {
- mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, quality);
- mJpegQuality = quality;
- } else {
- ALOGE("Invalid jpeg quality=%d", quality);
- rc = BAD_VALUE;
- }
-
- quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
- if (quality >= 0 && quality <= 100) {
- mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, quality);
- } else {
- ALOGE("Invalid jpeg thumbnail quality=%d", quality);
- rc = BAD_VALUE;
- }
- ALOGV("setJpegQuality X");
- return rc;
-}
-
-status_t QCameraHardwareInterface::
-setNumOfSnapshot(const QCameraParameters& params) {
- status_t rc = NO_ERROR;
-
- int num_of_snapshot = getNumOfSnapshots(params);
-
- if (num_of_snapshot <= 0) {
- num_of_snapshot = 1;
- }
- ALOGI("number of snapshots = %d", num_of_snapshot);
- mParameters.set("num-snaps-per-shutter", num_of_snapshot);
-
- bool result = native_set_parms(MM_CAMERA_PARM_SNAPSHOT_BURST_NUM,
- sizeof(int),
- (void *)&num_of_snapshot);
- if(!result)
- ALOGI("%s:Failure setting number of snapshots!!!", __func__);
- return rc;
-}
-
-status_t QCameraHardwareInterface::setPreviewFormat(const QCameraParameters& params) {
- const char *str = params.getPreviewFormat();
- int32_t previewFormat = attr_lookup(preview_formats, sizeof(preview_formats) / sizeof(str_map), str);
- if(previewFormat != NOT_FOUND) {
- int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t);
- int i;
-
- for (i = 0; i < num; i++) {
- if (preview_format_info_list[i].Hal_format == previewFormat) {
- mPreviewFormatInfo = preview_format_info_list[i];
- break;
- }
- }
-
- if (i == num) {
- mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
- mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD;
- return BAD_VALUE;
- }
- bool ret = native_set_parms(MM_CAMERA_PARM_PREVIEW_FORMAT, sizeof(cam_format_t),
- (void *)&mPreviewFormatInfo.mm_cam_format);
- mParameters.set(QCameraParameters::KEY_PREVIEW_FORMAT, str);
- mPreviewFormat = mPreviewFormatInfo.mm_cam_format;
- ALOGI("Setting preview format to %d, i =%d, num=%d, hal_format=%d",
- mPreviewFormat, i, num, mPreviewFormatInfo.Hal_format);
- return NO_ERROR;
- } else if ( strTexturesOn ) {
- mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
- mPreviewFormatInfo.padding = CAMERA_PAD_TO_4K;
- } else {
- mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
- mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD;
- }
- ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setStrTextures(const QCameraParameters& params) {
- const char *str = params.get("strtextures");
- const char *prev_str = mParameters.get("strtextures");
-
- if(str != NULL) {
- if(!strcmp(str,prev_str)) {
- return NO_ERROR;
- }
- int str_size = strlen(str);
- mParameters.set("strtextures", str);
- if(str_size == 2) {
- if(!strncmp(str, "on", str_size) || !strncmp(str, "ON", str_size)){
- ALOGI("Resetting mUseOverlay to false");
- strTexturesOn = true;
- mUseOverlay = false;
- }
- }else if(str_size == 3){
- if (!strncmp(str, "off", str_size) || !strncmp(str, "OFF", str_size)) {
- strTexturesOn = false;
- mUseOverlay = true;
- }
- }
-
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setFlash(const QCameraParameters& params)
-{
- ALOGI("%s: E",__func__);
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_LED_MODE,&supported,&supported);
- if(!supported) {
- ALOGE("%s:LED FLASH not supported", __func__);
- return NO_ERROR;
- }
-
- const char *str = params.get(QCameraParameters::KEY_FLASH_MODE);
- if (str != NULL) {
- int32_t value = attr_lookup(flash, sizeof(flash) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- mParameters.set(QCameraParameters::KEY_FLASH_MODE, str);
- bool ret = native_set_parms(MM_CAMERA_PARM_LED_MODE,
- sizeof(value), (void *)&value);
- return ret ? NO_ERROR : UNKNOWN_ERROR;
- }
- }
- ALOGE("Invalid flash mode value: %s", (str == NULL) ? "NULL" : str);
-
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setAecAwbLock(const QCameraParameters & params)
-{
- ALOGD("%s : E", __func__);
- status_t rc = NO_ERROR;
- int32_t value;
- const char* str;
-
- //for AEC lock
- str = params.get(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK);
- value = (strcmp(str, "true") == 0)? 1 : 0;
- mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK, str);
- rc = (native_set_parms(MM_CAMERA_PARM_AEC_LOCK, sizeof(int32_t), (void *)(&value))) ?
- NO_ERROR : UNKNOWN_ERROR;
-
- //for AWB lock
- str = params.get(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
- value = (strcmp(str, "true") == 0)? 1 : 0;
- mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, str);
- rc = (native_set_parms(MM_CAMERA_PARM_AWB_LOCK, sizeof(int32_t), (void *)(&value))) ?
- NO_ERROR : UNKNOWN_ERROR;
- ALOGD("%s : X", __func__);
- return rc;
-}
-
-status_t QCameraHardwareInterface::setOverlayFormats(const QCameraParameters& params)
-{
- mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP);
- if(mIs3DModeOn == true) {
- int ovFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP|HAL_3D_IN_SIDE_BY_SIDE_L_R|HAL_3D_OUT_SIDE_BY_SIDE;
- mParameters.set("overlay-format", ovFormat);
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setMCEValue(const QCameraParameters& params)
-{
- ALOGE("%s",__func__);
- uint8_t supported;
-
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_MCE,&supported,&supported);
- if(!supported) {
- ALOGE("MM_CAMERA_PARM_MCE mode is not supported for this sensor");
- return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT);
- if (str != NULL) {
- int value = attr_lookup(mce, sizeof(mce) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- int temp = (int8_t)value;
- ALOGI("%s: setting MCE value of %s", __FUNCTION__, str);
- mParameters.set(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT, str);
-
- native_set_parms(MM_CAMERA_PARM_MCE, sizeof(int8_t), (void *)&temp);
- return NO_ERROR;
- }
- }
- ALOGE("Invalid MCE value: %s", (str == NULL) ? "NULL" : str);
-
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setHighFrameRate(const QCameraParameters& params)
-{
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_HFR,&supported,&supported);
- if(!supported) {
- ALOGE("%s: MM_CAMERA_PARM_HFR not supported", __func__);
- return NO_ERROR;
- }
-
- const char *str = params.get(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE);
- if (str != NULL) {
- int value = attr_lookup(hfr, sizeof(hfr) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- mHFRLevel = (int32_t)value;
- //Check for change in HFR value
- const char *oldHfr = mParameters.get(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE);
- if(strcmp(oldHfr, str)){
- mParameters.set(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE, str);
- if(QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) {
- stopPreviewInternal();
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
- native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel);
- mRestartPreview = true;
- return NO_ERROR;
- }
- }
- native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel);
- return NO_ERROR;
- }
- }
- ALOGE("Invalid HFR value: %s", (str == NULL) ? "NULL" : str);
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setLensshadeValue(const QCameraParameters& params)
-{
-
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_ROLLOFF,&supported,&supported);
- if(!supported) {
- ALOGE("%s:LENS SHADING not supported", __func__);
- return NO_ERROR;
- }
-
- const char *str = params.get(QCameraParameters::KEY_QC_LENSSHADE);
- if (str != NULL) {
- int value = attr_lookup(lensshade,
- sizeof(lensshade) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- int8_t temp = (int8_t)value;
- mParameters.set(QCameraParameters::KEY_QC_LENSSHADE, str);
- native_set_parms(MM_CAMERA_PARM_ROLLOFF, sizeof(int8_t), (void *)&temp);
- return NO_ERROR;
- }
- }
- ALOGE("Invalid lensShade value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setFaceDetect(const QCameraParameters& params)
-{
- int requested_faces = params.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
- int hardware_supported_faces = mParameters.getInt(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW);
- if (requested_faces > hardware_supported_faces) {
- requested_faces = hardware_supported_faces;
- }
- mParameters.set(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES, requested_faces);
- const char *str = params.get(QCameraParameters::KEY_QC_FACE_DETECTION);
- ALOGE("setFaceDetect: %s", str);
- if (str != NULL) {
- fd_set_parm_t fd_set_parm;
- int value = attr_lookup(facedetection,
- sizeof(facedetection) / sizeof(str_map), str);
- mFaceDetectOn = value;
- fd_set_parm.fd_mode = value;
- fd_set_parm.num_fd = requested_faces;
- ALOGE("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces);
- native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm);
- mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION, str);
- return NO_ERROR;
- }
- ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-status_t QCameraHardwareInterface::setFaceDetection(const char *str)
-{
- if(supportsFaceDetection() == false){
- ALOGE("Face detection is not enabled");
- return NO_ERROR;
- }
- if (str != NULL) {
- int requested_faces = mParameters.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
- int value = attr_lookup(facedetection,
- sizeof(facedetection) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- fd_set_parm_t fd_set_parm;
- mFaceDetectOn = value;
- fd_set_parm.fd_mode = value;
- fd_set_parm.num_fd = requested_faces;
- ALOGE("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces);
- native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm);
- mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION, str);
- return NO_ERROR;
- }
- }
- ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setAEBracket(const QCameraParameters& params)
-{
- uint8_t supported;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_HDR,&supported,&supported);
- if(!supported || (myMode & CAMERA_ZSL_MODE)) {
- ALOGI("Parameter HDR is not supported for this sensor/ ZSL mode");
-
- if (myMode & CAMERA_ZSL_MODE) {
- ALOGE("In ZSL mode, reset AEBBracket to HDR_OFF mode");
- exp_bracketing_t temp;
- memset(&temp, 0, sizeof(temp));
- mHdrMode = HDR_BRACKETING_OFF;
- temp.hdr_enable= FALSE;
- temp.mode = HDR_BRACKETING_OFF;
- native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
- }
- return NO_ERROR;
- }
- const char *str = params.get(QCameraParameters::KEY_QC_AE_BRACKET_HDR);
-
- if (str != NULL) {
- int value = attr_lookup(hdr_bracket,
- sizeof(hdr_bracket) / sizeof(str_map), str);
- exp_bracketing_t temp;
- memset(&temp, 0, sizeof(temp));
- switch (value) {
- case HDR_MODE:
- {
- mHdrMode = HDR_MODE;
- ALOGE("%s, mHdrMode == HDR_MODE", __func__);
- /* temp.hdr_enable= TRUE;
- temp.mode = HDR_MODE;
- temp.total_frames = 3;
- temp.total_hal_frames = getNumOfSnapshots();
- ALOGI("%s: setting HDR frames (%d)", __FUNCTION__, temp.total_hal_frames);
- native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); */
- }
- break;
- case EXP_BRACKETING_MODE:
- {
- ALOGE("%s, mHdrMode == EXP_BRACKETING_MODE", __func__);
- int numFrames = getNumOfSnapshots();
- const char *str_val = params.get("capture-burst-exposures");
- if ((str_val != NULL) && (strlen(str_val)>0)) {
- ALOGI("%s: capture-burst-exposures %s", __FUNCTION__, str_val);
-
- mHdrMode = EXP_BRACKETING_MODE;
- temp.hdr_enable = FALSE;
- temp.mode = EXP_BRACKETING_MODE;
- temp.total_frames = (numFrames > MAX_SNAPSHOT_BUFFERS -2) ? MAX_SNAPSHOT_BUFFERS -2 : numFrames;
- temp.total_hal_frames = temp.total_frames;
- strlcpy(temp.values, str_val, MAX_EXP_BRACKETING_LENGTH);
- ALOGI("%s: setting Exposure Bracketing value of %s, frame (%d)", __FUNCTION__, temp.values, temp.total_hal_frames);
- native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
- }
- else {
- /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */
- ALOGI("%s: capture-burst-exposures not set, back to HDR OFF mode", __FUNCTION__);
- mHdrMode = HDR_BRACKETING_OFF;
- temp.hdr_enable= FALSE;
- temp.mode = HDR_BRACKETING_OFF;
- native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
- }
- }
- break;
- case HDR_BRACKETING_OFF:
- ALOGE("%s, mHdrMode == HDR_BRACKETING_OFF", __func__);
- default:
- {
- ALOGE("%s, mHdrMode == HDR_BRACKETING_OFF", __func__);
- mHdrMode = HDR_BRACKETING_OFF;
- temp.hdr_enable= FALSE;
- temp.mode = HDR_BRACKETING_OFF;
- native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
- }
- break;
- }
-
- /* save the value*/
- mParameters.set(QCameraParameters::KEY_QC_AE_BRACKET_HDR, str);
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setCaptureBurstExp()
-{
- char burst_exp[PROPERTY_VALUE_MAX];
- memset(burst_exp, 0, sizeof(burst_exp));
- property_get("persist.capture.burst.exposures", burst_exp, "");
- if (NULL != burst_exp)
- mParameters.set("capture-burst-exposures", burst_exp);
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRedeyeReduction(const QCameraParameters& params)
-{
- if(supportsRedEyeReduction() == false) {
- ALOGE("Parameter Redeye Reduction is not supported for this sensor");
- return NO_ERROR;
- }
-
- const char *str = params.get(QCameraParameters::KEY_QC_REDEYE_REDUCTION);
- if (str != NULL) {
- int value = attr_lookup(redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map), str);
- if (value != NOT_FOUND) {
- int8_t temp = (int8_t)value;
- ALOGI("%s: setting Redeye Reduction value of %s", __FUNCTION__, str);
- mParameters.set(QCameraParameters::KEY_QC_REDEYE_REDUCTION, str);
-
- native_set_parms(MM_CAMERA_PARM_REDEYE_REDUCTION, sizeof(int8_t), (void *)&temp);
- return NO_ERROR;
- }
- }
- ALOGE("Invalid Redeye Reduction value: %s", (str == NULL) ? "NULL" : str);
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setGpsLocation(const QCameraParameters& params)
-{
- const char *method = params.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
- if (method) {
- mParameters.set(QCameraParameters::KEY_GPS_PROCESSING_METHOD, method);
- }else {
- mParameters.remove(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
- }
-
- const char *latitude = params.get(QCameraParameters::KEY_GPS_LATITUDE);
- if (latitude) {
- ALOGE("latitude %s",latitude);
- mParameters.set(QCameraParameters::KEY_GPS_LATITUDE, latitude);
- }else {
- mParameters.remove(QCameraParameters::KEY_GPS_LATITUDE);
- }
-
- const char *latitudeRef = params.get(QCameraParameters::KEY_QC_GPS_LATITUDE_REF);
- if (latitudeRef) {
- mParameters.set(QCameraParameters::KEY_QC_GPS_LATITUDE_REF, latitudeRef);
- }else {
- mParameters.remove(QCameraParameters::KEY_QC_GPS_LATITUDE_REF);
- }
-
- const char *longitude = params.get(QCameraParameters::KEY_GPS_LONGITUDE);
- if (longitude) {
- mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE, longitude);
- }else {
- mParameters.remove(QCameraParameters::KEY_GPS_LONGITUDE);
- }
-
- const char *longitudeRef = params.get(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF);
- if (longitudeRef) {
- mParameters.set(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF, longitudeRef);
- }else {
- mParameters.remove(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF);
- }
-
- const char *altitudeRef = params.get(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF);
- if (altitudeRef) {
- mParameters.set(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF, altitudeRef);
- }else {
- mParameters.remove(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF);
- }
-
- const char *altitude = params.get(QCameraParameters::KEY_GPS_ALTITUDE);
- if (altitude) {
- mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE, altitude);
- }else {
- mParameters.remove(QCameraParameters::KEY_GPS_ALTITUDE);
- }
-
- const char *status = params.get(QCameraParameters::KEY_QC_GPS_STATUS);
- if (status) {
- mParameters.set(QCameraParameters::KEY_QC_GPS_STATUS, status);
- }
-
- const char *dateTime = params.get(QCameraParameters::KEY_QC_EXIF_DATETIME);
- if (dateTime) {
- mParameters.set(QCameraParameters::KEY_QC_EXIF_DATETIME, dateTime);
- }else {
- mParameters.remove(QCameraParameters::KEY_QC_EXIF_DATETIME);
- }
-
- const char *timestamp = params.get(QCameraParameters::KEY_GPS_TIMESTAMP);
- if (timestamp) {
- mParameters.set(QCameraParameters::KEY_GPS_TIMESTAMP, timestamp);
- }else {
- mParameters.remove(QCameraParameters::KEY_GPS_TIMESTAMP);
- }
- ALOGE("setGpsLocation X");
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRotation(const QCameraParameters& params)
-{
- status_t rc = NO_ERROR;
- int rotation = params.getInt(QCameraParameters::KEY_ROTATION);
- if (rotation != NOT_FOUND) {
- if (rotation == 0 || rotation == 90 || rotation == 180
- || rotation == 270) {
- mParameters.set(QCameraParameters::KEY_ROTATION, rotation);
- mRotation = rotation;
- } else {
- ALOGE("Invalid rotation value: %d", rotation);
- rc = BAD_VALUE;
- }
- }
- ALOGE("setRotation");
- return rc;
-}
-
-status_t QCameraHardwareInterface::setDenoise(const QCameraParameters& params)
-{
- return BAD_VALUE;
-}
-
-status_t QCameraHardwareInterface::setOrientation(const QCameraParameters& params)
-{
- const char *str = params.get("orientation");
-
- if (str != NULL) {
- if (strcmp(str, "portrait") == 0 || strcmp(str, "landscape") == 0) {
- // Camera service needs this to decide if the preview frames and raw
- // pictures should be rotated.
- mParameters.set("orientation", str);
- } else {
- ALOGE("Invalid orientation value: %s", str);
- return BAD_VALUE;
- }
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setPictureFormat(const QCameraParameters& params)
-{
- const char * str = params.get(QCameraParameters::KEY_PICTURE_FORMAT);
- if(str != NULL){
- int32_t value = attr_lookup(picture_formats,
- sizeof(picture_formats) / sizeof(str_map), str);
- if(value != NOT_FOUND){
- if (isZSLMode() && !strcmp(str, "raw")) {
- mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, "jpeg");
- } else {
- mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, str);
- }
- } else {
- ALOGE("Invalid Picture Format value: %s", str);
- return BAD_VALUE;
- }
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRecordingHintValue(const int32_t value)
-{
- native_set_parms(MM_CAMERA_PARM_RECORDING_HINT, sizeof(value),
- (void *)&value);
- if (value == TRUE){
- native_set_parms(MM_CAMERA_PARM_CAF_ENABLE, sizeof(value),
- (void *)&value);
- }
- setDISMode();
- setFullLiveshot();
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRecordingHint(const QCameraParameters& params)
-{
-
- const char * str = params.get(QCameraParameters::KEY_RECORDING_HINT);
-
- if(str != NULL){
- int32_t value = attr_lookup(recording_Hints,
- sizeof(recording_Hints) / sizeof(str_map), str);
- if(value != NOT_FOUND){
- mRecordingHint = value;
- setRecordingHintValue(mRecordingHint);
- mParameters.set(QCameraParameters::KEY_RECORDING_HINT, str);
- return NO_ERROR;
- } else {
- ALOGE("Invalid Picture Format value: %s", str);
- setDISMode();
- setFullLiveshot();
- return BAD_VALUE;
- }
- }
- setDISMode();
- setFullLiveshot();
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setDISMode() {
- /* Enable DIS only if
- * - Camcorder mode AND
- * - DIS property is set AND
- * - Not in Low power mode. */
- uint32_t value = mRecordingHint && mDisEnabled
- && !isLowPowerCamcorder();
-
- ALOGI("%s DIS is %s value = %d", __func__,
- value ? "Enabled" : "Disabled", value);
- native_set_parms(MM_CAMERA_PARM_DIS_ENABLE, sizeof(value),
- (void *)&value);
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setFullLiveshot()
-{
- /* Enable full size liveshot only if
- * - Camcorder mode AND
- * - Full size liveshot is enabled. */
- uint32_t value = mRecordingHint && mFullLiveshotEnabled
- && !isLowPowerCamcorder();
-
- if (((mDimension.picture_width == mDimension.video_width) &&
- (mDimension.picture_height == mDimension.video_height))) {
- /* If video size matches the live snapshot size
- * turn off full size liveshot to get higher fps. */
- value = 0;
- }
-
- ALOGI("%s Full size liveshot %s value = %d", __func__,
- value ? "Enabled" : "Disabled", value);
- native_set_parms(MM_CAMERA_PARM_FULL_LIVESHOT, sizeof(value),
- (void *)&value);
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setMobiCat(const QCameraParameters& params)
-{
- mm_cam_mobicat_info_t mbc_info;
- char mbc_prop[PROPERTY_VALUE_MAX];
- int propval;
- memset(mbc_prop, 0, sizeof(mbc_prop));
- property_get("persist.camera.mobicat", mbc_prop, "0");
- propval = atoi(mbc_prop);
- mbc_info.enable = (mParameters.getInt("mobicat") == 1) ? 1 : 0;
- ALOGV("%s:%d] prop %d %d", __func__, __LINE__, mbc_info.enable, propval);
- mbc_info.enable |= propval;
-
- if (mbc_info.enable != mMobiCatEnabled) {
- ALOGV("%s:%d] enable %d", __func__, __LINE__, mbc_info.enable);
- native_set_parms(MM_CAMERA_PARM_MOBICAT, sizeof(mm_cam_mobicat_info_t),
- (void *)&mbc_info);
- mMobiCatEnabled = mbc_info.enable;
- }
- return NO_ERROR;
-}
-
-
-isp3a_af_mode_t QCameraHardwareInterface::getAutoFocusMode(
- const QCameraParameters& params)
-{
- isp3a_af_mode_t afMode = AF_MODE_MAX;
- afMode = (isp3a_af_mode_t)mFocusMode;
- return afMode;
-}
-
-void QCameraHardwareInterface::getPictureSize(int *picture_width,
- int *picture_height) const
-{
- mParameters.getPictureSize(picture_width, picture_height);
-}
-
-void QCameraHardwareInterface::getPreviewSize(int *preview_width,
- int *preview_height) const
-{
- mParameters.getPreviewSize(preview_width, preview_height);
-}
-
-void QCameraHardwareInterface::getVideoSize(int *video_width,
- int *video_height) const
-{
- mParameters.getVideoSize(video_width, video_height);
-}
-
-void QCameraHardwareInterface::getThumbnailSize(int *thumb_width,
- int *thumb_height) const
-{
- *thumb_width = mParameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
- *thumb_height = mParameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
-}
-
-cam_format_t QCameraHardwareInterface::getPreviewFormat() const
-{
- cam_format_t foramt = CAMERA_YUV_420_NV21;
- const char *str = mParameters.getPreviewFormat();
- int32_t value = attr_lookup(preview_formats,
- sizeof(preview_formats)/sizeof(str_map),
- str);
-
- if(value != NOT_FOUND) {
- int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t);
- int i;
- for (i = 0; i < num; i++) {
- if (preview_format_info_list[i].Hal_format == value) {
- foramt = preview_format_info_list[i].mm_cam_format;
- break;
- }
- }
- }
-
- return foramt;
-}
-
-cam_pad_format_t QCameraHardwareInterface::getPreviewPadding() const
-{
- return mPreviewFormatInfo.padding;
-}
-
-int QCameraHardwareInterface::getJpegQuality() const
-{
- return mJpegQuality;
-}
-
-int QCameraHardwareInterface::getNumOfSnapshots(void) const
-{
- char prop[PROPERTY_VALUE_MAX];
- memset(prop, 0, sizeof(prop));
- property_get("persist.camera.snapshot.number", prop, "0");
- ALOGI("%s: prop enable/disable = %d", __func__, atoi(prop));
- if (atoi(prop)) {
- ALOGE("%s: Reading maximum no of snapshots = %d"
- "from properties", __func__, atoi(prop));
- return atoi(prop);
- } else {
- return mParameters.getInt("num-snaps-per-shutter");
- }
-}
-
-int QCameraHardwareInterface::getNumOfSnapshots(const QCameraParameters& params)
-{
- char prop[PROPERTY_VALUE_MAX];
- memset(prop, 0, sizeof(prop));
- property_get("persist.camera.snapshot.number", prop, "0");
- ALOGI("%s: prop enable/disable = %d", __func__, atoi(prop));
- if (atoi(prop)) {
- ALOGI("%s: Reading maximum no of snapshots = %d"
- "from properties", __func__, atoi(prop));
- return atoi(prop);
- } else {
- return params.getInt("num-snaps-per-shutter");
- }
-
-}
-
-int QCameraHardwareInterface::
-getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
- int *picture_width,
- int *picture_height)
-{
- for(unsigned int i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ){
- if(thumbnail_sizes[i].aspect_ratio == aspect_ratio)
- {
- *picture_width = thumbnail_sizes[i].width;
- *picture_height = thumbnail_sizes[i].height;
- return NO_ERROR;
- }
- }
-
- return BAD_VALUE;
-}
-
-bool QCameraHardwareInterface::isRawSnapshot()
-{
- const char *format = mParameters.getPictureFormat();
- if( format!= NULL &&
- !strcmp(format, QCameraParameters::PIXEL_FORMAT_RAW)){
- return true;
- }
- else{
- return false;
- }
-}
-
-status_t QCameraHardwareInterface::setPreviewSizeTable(void)
-{
- status_t ret = NO_ERROR;
- mm_camera_dimension_t dim;
- struct camera_size_type* preview_size_table;
- int preview_table_size;
- int i = 0;
- char str[10] = {0};
-
- /* Initialize table with default values */
- preview_size_table = default_preview_sizes;
- preview_table_size = preview_sizes_count;
-
-
- /* Get maximum preview size supported by sensor*/
- memset(&dim, 0, sizeof(mm_camera_dimension_t));
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_MAX_PREVIEW_SIZE, &dim);
- if (ret != NO_ERROR) {
- ALOGE("%s: Failure getting Max Preview Size supported by camera",
- __func__);
- goto end;
- }
-
- ALOGD("%s: Max Preview Sizes Supported: %d X %d", __func__,
- dim.width, dim.height);
-
- for (i = 0; i < preview_table_size; i++) {
- if ((preview_size_table->width <= dim.width) &&
- (preview_size_table->height <= dim.height)) {
- ALOGD("%s: Camera Preview Size Table "
- "Max width: %d height %d table_size: %d",
- __func__, preview_size_table->width,
- preview_size_table->height, preview_table_size - i);
- break;
- }
- preview_size_table++;
- }
- //set preferred preview size to maximum preview size
- sprintf(str, "%dx%d", preview_size_table->width, preview_size_table->height);
- mParameters.set(QCameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, str);
- ALOGD("KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO = %s", str);
-
-end:
- /* Save the table in global member*/
- mPreviewSizes = preview_size_table;
- mPreviewSizeCount = preview_table_size - i;
-
- return ret;
-}
-
-status_t QCameraHardwareInterface::setPictureSizeTable(void)
-{
- status_t ret = NO_ERROR;
- mm_camera_dimension_t dim;
- struct camera_size_type* picture_size_table;
- int picture_table_size;
- int i = 0, count = 0;
-
- /* Initialize table with default values */
- picture_table_size = sizeof(default_picture_sizes)/
- sizeof(default_picture_sizes[0]);
- picture_size_table = default_picture_sizes;
- mPictureSizes =
- ( struct camera_size_type *)malloc(picture_table_size *
- sizeof(struct camera_size_type));
- if (mPictureSizes == NULL) {
- ALOGE("%s: Failre allocating memory to store picture size table",__func__);
- goto end;
- }
-
- /* Get maximum picture size supported by sensor*/
- memset(&dim, 0, sizeof(mm_camera_dimension_t));
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim);
- if (ret != NO_ERROR) {
- ALOGE("%s: Failure getting Max Picture Size supported by camera",
- __func__);
- ret = NO_MEMORY;
- free(mPictureSizes);
- mPictureSizes = NULL;
- goto end;
- }
-
- ALOGD("%s: Max Picture Sizes Supported: %d X %d", __func__,
- dim.width, dim.height);
-
- for (i = 0; i < picture_table_size; i++) {
- /* We'll store those dimensions whose width AND height
- are less than or equal to maximum supported */
- if ((picture_size_table->width <= dim.width) &&
- (picture_size_table->height <= dim.height)) {
- ALOGD("%s: Camera Picture Size Table "
- "Max width: %d height %d table_size: %d",
- __func__, picture_size_table->width,
- picture_size_table->height, count+1);
- mPictureSizes[count].height = picture_size_table->height;
- mPictureSizes[count].width = picture_size_table->width;
- count++;
- }
- picture_size_table++;
- }
- mPictureSizeCount = count;
-
-end:
- /* In case of error, we use default picture sizes */
- if (ret != NO_ERROR) {
- mPictureSizes = default_picture_sizes;
- mPictureSizeCount = picture_table_size;
- }
- return ret;
-}
-
-status_t QCameraHardwareInterface::setVideoSizeTable(void)
-{
- status_t ret = NO_ERROR;
- mm_camera_dimension_t dim;
- struct camera_size_type* video_size_table;
- int video_table_size;
- int i = 0, count = 0;
- ALOGE("%s: E", __func__);
-
- /* Initialize table with default values */
- video_table_size = video_sizes_count;
- video_size_table = default_video_sizes;
- mVideoSizes =
- (struct camera_size_type *)malloc(video_table_size *
- sizeof(struct camera_size_type));
- if(mVideoSizes == NULL) {
- ALOGE("%s: error allocating memory to store video size table",__func__);
- ret = BAD_VALUE;
- goto end;
- }
-
- /* Get maximum video size supported by sensor*/
- memset(&dim, 0, sizeof(mm_camera_dimension_t));
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_MAX_VIDEO_SIZE, &dim);
- if(ret != NO_ERROR) {
- ALOGE("%s: error getting Max Video Size supported by camera",
- __func__);
- ret = NO_MEMORY;
- free(mVideoSizes);
- mVideoSizes = NULL;
- ret = BAD_VALUE;
- goto end;
- }
-
- ALOGD("%s: Max Video Size Supported: %d X %d", __func__,
- dim.width, dim.height);
-
- for(i=0; i < video_table_size; i++) {
- /* We'll store those dimensions whose width AND height
- are less than or equal to maximum supported */
- if((video_size_table->width <= dim.width) &&
- (video_size_table->height <= dim.height)) {
- ALOGD("%s: Supported Video Size [%d] = %dx%d", __func__, count, video_size_table->width,
- video_size_table->height);
- mVideoSizes[count].height = video_size_table->height;
- mVideoSizes[count].width = video_size_table->width;
- count++;
- }
- video_size_table++;
- }
- mVideoSizeCount = count;
-
-end:
- ALOGE("%s: X", __func__);
- return ret;
-}
-
-void QCameraHardwareInterface::freeVideoSizeTable(void)
-{
- if(mVideoSizes != NULL)
- {
- free(mVideoSizes);
- }
- mVideoSizeCount = 0;
-}
-
-
-void QCameraHardwareInterface::freePictureTable(void)
-{
- /* If we couldn't allocate memory to store picture table
- we use the picture table pointer to point to default
- picture table array. In that case we cannot free it.*/
- if ((mPictureSizes != default_picture_sizes) && mPictureSizes) {
- free(mPictureSizes);
- }
-}
-
-status_t QCameraHardwareInterface::setHistogram(int histogram_en)
-{
- status_t ret = NO_ERROR;
-
- ALOGV("setHistogram: E");
- if(mStatsOn == histogram_en) {
- return ret;
- }
-
- status_t rc = NO_ERROR;
- mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_HISTOGRAM,
- (uint8_t*)&rc,(uint8_t*)&rc);
- if(!rc) {
- ALOGE(" Histogram is not supported for this");
- return NO_ERROR;
- }
- mSendData = histogram_en;
- mStatsOn = histogram_en;
-
- if (histogram_en == QCAMERA_PARM_ENABLE) {
- ret = initHistogramBuffers();
- if (ret != NO_ERROR) {
- ALOGE("%s Error initializing Histogram buffers ", __func__);
- return ret;
- }
- }
- ALOGI(" Histogram -> %s", histogram_en ? "Enabled" : "Disabled");
- native_set_parms(MM_CAMERA_PARM_HISTOGRAM, sizeof(int), &histogram_en);
- if(histogram_en == QCAMERA_PARM_DISABLE) {
- ret = deInitHistogramBuffers();
- if (ret != NO_ERROR) {
- ALOGE("%s Error deInitializing Histogram buffers ", __func__);
- return ret;
- }
- }
- ALOGV("setHistogram: X");
- return ret;
-}
-
-status_t QCameraHardwareInterface::setZSLBurstLookBack(const QCameraParameters& params)
-{
- const char *v = params.get("capture-burst-retroactive");
- if (v) {
- int look_back = atoi(v);
- ALOGI("%s: look_back =%d", __func__, look_back);
- mParameters.set("capture-burst-retroactive", look_back);
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setZSLBurstInterval(const QCameraParameters& params)
-{
- mZslInterval = BURST_INTREVAL_DEFAULT;
- const char *v = params.get("capture-burst-interval");
- if (v) {
- int interval = atoi(v);
- ALOGI("%s: Interval =%d", __func__, interval);
- if(interval < BURST_INTREVAL_MIN ||interval > BURST_INTREVAL_MAX ) {
- return BAD_VALUE;
- }
- mZslInterval = interval;
- }
- return NO_ERROR;
-}
-
-int QCameraHardwareInterface::getZSLBurstInterval( void )
-{
- int val;
-
- if (mZslInterval == BURST_INTREVAL_DEFAULT) {
- char prop[PROPERTY_VALUE_MAX];
- memset(prop, 0, sizeof(prop));
- property_get("persist.camera.zsl.interval", prop, "1");
- val = atoi(prop);
- ALOGD("%s: prop interval = %d", __func__, val);
- } else {
- val = mZslInterval;
- }
- return val;
-}
-
-
-int QCameraHardwareInterface::getZSLQueueDepth(void) const
-{
- char prop[PROPERTY_VALUE_MAX];
- memset(prop, 0, sizeof(prop));
- property_get("persist.camera.zsl.queuedepth", prop, "2");
- ALOGI("%s: prop = %d", __func__, atoi(prop));
- return atoi(prop);
-}
-
-int QCameraHardwareInterface::getZSLBackLookCount(void) const
-{
- int look_back;
- char prop[PROPERTY_VALUE_MAX];
- memset(prop, 0, sizeof(prop));
- property_get("persist.camera.zsl.backlookcnt", prop, "0");
- ALOGI("%s: prop = %d", __func__, atoi(prop));
- look_back = atoi(prop);
- if (look_back == 0 ) {
- look_back = mParameters.getInt("capture-burst-retroactive");
- ALOGE("%s: look_back = %d", __func__, look_back);
- }
- return look_back;
-}
-
-//EXIF functions
-void QCameraHardwareInterface::deinitExifData()
-{
- ALOGD("Clearing EXIF data");
- memset(mExifData, 0, sizeof(exif_tags_info_t) * MAX_EXIF_TABLE_ENTRIES);
- mExifTableNumEntries = 0;
-}
-
-void QCameraHardwareInterface::addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
- uint32_t count, uint8_t copy, void *data) {
-
- if(mExifTableNumEntries >= MAX_EXIF_TABLE_ENTRIES) {
- ALOGE("%s: Number of entries exceeded limit", __func__);
- return;
- }
- int index = mExifTableNumEntries;
- mExifData[index].tag_id = tagid;
- mExifData[index].tag_entry.type = type;
- mExifData[index].tag_entry.count = count;
- mExifData[index].tag_entry.copy = copy;
- if((type == EXIF_RATIONAL) && (count > 1))
- mExifData[index].tag_entry.data._rats = (rat_t *)data;
- if((type == EXIF_RATIONAL) && (count == 1))
- mExifData[index].tag_entry.data._rat = *(rat_t *)data;
- else if(type == EXIF_ASCII)
- mExifData[index].tag_entry.data._ascii = (char *)data;
- else if(type == EXIF_BYTE)
- mExifData[index].tag_entry.data._byte = *(uint8_t *)data;
- else if((type == EXIF_SHORT) && (count > 1))
- mExifData[index].tag_entry.data._shorts = (uint16_t *)data;
- else if((type == EXIF_SHORT) && (count == 1))
- mExifData[index].tag_entry.data._short = *(uint16_t *)data;
- // Increase number of entries
- mExifTableNumEntries++;
-}
-
-rat_t getRational(int num, int denom)
-{
- rat_t temp = {num, denom};
- return temp;
-}
-
-void QCameraHardwareInterface::initExifData(){
- if(mExifValues.dateTime) {
- addExifTag(EXIFTAGID_EXIF_DATE_TIME_ORIGINAL, EXIF_ASCII,
- 20, 1, (void *)mExifValues.dateTime);
- }
- addExifTag(EXIFTAGID_FOCAL_LENGTH, EXIF_RATIONAL, 1, 1, (void *)&(mExifValues.focalLength));
- addExifTag(EXIFTAGID_ISO_SPEED_RATING,EXIF_SHORT,1,1,(void *)&(mExifValues.isoSpeed));
-
- if(mExifValues.mGpsProcess) {
- addExifTag(EXIFTAGID_GPS_PROCESSINGMETHOD, EXIF_ASCII,
- EXIF_ASCII_PREFIX_SIZE + strlen(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE) + 1,
- 1, (void *)mExifValues.gpsProcessingMethod);
- }
-
- if(mExifValues.mLatitude) {
- addExifTag(EXIFTAGID_GPS_LATITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.latitude);
-
- if(mExifValues.latRef) {
- addExifTag(EXIFTAGID_GPS_LATITUDE_REF, EXIF_ASCII, 2,
- 1, (void *)mExifValues.latRef);
- }
- }
-
- if(mExifValues.mLongitude) {
- addExifTag(EXIFTAGID_GPS_LONGITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.longitude);
-
- if(mExifValues.lonRef) {
- addExifTag(EXIFTAGID_GPS_LONGITUDE_REF, EXIF_ASCII, 2,
- 1, (void *)mExifValues.lonRef);
- }
- }
-
- if(mExifValues.mAltitude) {
- addExifTag(EXIFTAGID_GPS_ALTITUDE, EXIF_RATIONAL, 1,
- 1, (void *)&(mExifValues.altitude));
-
- addExifTag(EXIFTAGID_GPS_ALTITUDE_REF, EXIF_BYTE, 1, 1, (void *)&mExifValues.mAltitude_ref);
- }
-
- if(mExifValues.mTimeStamp) {
- time_t unixTime;
- struct tm *UTCTimestamp;
-
- unixTime = (time_t)mExifValues.mGPSTimestamp;
- UTCTimestamp = gmtime(&unixTime);
-
- strftime(mExifValues.gpsDateStamp, sizeof(mExifValues.gpsDateStamp), "%Y:%m:%d", UTCTimestamp);
- addExifTag(EXIFTAGID_GPS_DATESTAMP, EXIF_ASCII,
- strlen(mExifValues.gpsDateStamp)+1 , 1, (void *)mExifValues.gpsDateStamp);
-
- mExifValues.gpsTimeStamp[0] = getRational(UTCTimestamp->tm_hour, 1);
- mExifValues.gpsTimeStamp[1] = getRational(UTCTimestamp->tm_min, 1);
- mExifValues.gpsTimeStamp[2] = getRational(UTCTimestamp->tm_sec, 1);
-
- addExifTag(EXIFTAGID_GPS_TIMESTAMP, EXIF_RATIONAL,
- 3, 1, (void *)mExifValues.gpsTimeStamp);
- ALOGE("EXIFTAGID_GPS_TIMESTAMP set");
- }
-
-}
-
-//Add all exif tags in this function
-void QCameraHardwareInterface::setExifTags()
-{
- const char *str;
-
- //set TimeStamp
- str = mParameters.get(QCameraParameters::KEY_QC_EXIF_DATETIME);
- if(str != NULL) {
- strncpy(mExifValues.dateTime, str, 19);
- mExifValues.dateTime[19] = '\0';
- }
-
- //Set focal length
- int focalLengthValue = (int) (mParameters.getFloat(
- QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION);
-
- mExifValues.focalLength = getRational(focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION);
-
- //Set ISO Speed
- mExifValues.isoSpeed = getISOSpeedValue();
-
- //get time and date from system
- time_t rawtime;
- struct tm * timeinfo;
- time(&rawtime);
- timeinfo = localtime (&rawtime);
- //Write datetime according to EXIF Spec
- //"YYYY:MM:DD HH:MM:SS" (20 chars including \0)
- snprintf(mExifValues.dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d",
- timeinfo->tm_year + 1900, timeinfo->tm_mon + 1,
- timeinfo->tm_mday, timeinfo->tm_hour,
- timeinfo->tm_min, timeinfo->tm_sec);
-
- //set gps tags
- setExifTagsGPS();
-}
-
-void QCameraHardwareInterface::setExifTagsGPS()
-{
- const char *str = NULL;
-
- //Set GPS processing method
- str = mParameters.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
- if(str != NULL) {
- memcpy(mExifValues.gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE);
- strncpy(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str,
- GPS_PROCESSING_METHOD_SIZE - 1);
- mExifValues.gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE + GPS_PROCESSING_METHOD_SIZE-1] = '\0';
- ALOGE("EXIFTAGID_GPS_PROCESSINGMETHOD = %s %s", mExifValues.gpsProcessingMethod,
- mExifValues.gpsProcessingMethod+8);
- mExifValues.mGpsProcess = true;
- }else{
- mExifValues.mGpsProcess = false;
- }
- str = NULL;
-
- //Set Latitude
- str = mParameters.get(QCameraParameters::KEY_GPS_LATITUDE);
- if(str != NULL) {
- parseGPSCoordinate(str, mExifValues.latitude);
- ALOGE("EXIFTAGID_GPS_LATITUDE = %s", str);
-
- //set Latitude Ref
- float latitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LATITUDE);
- if(latitudeValue < 0.0f) {
- mExifValues.latRef[0] = 'S';
- } else {
- mExifValues.latRef[0] = 'N';
- }
- mExifValues.latRef[1] = '\0';
- mExifValues.mLatitude = true;
- mParameters.set(QCameraParameters::KEY_QC_GPS_LATITUDE_REF,mExifValues.latRef);
- ALOGE("EXIFTAGID_GPS_LATITUDE_REF = %s", mExifValues.latRef);
- }else{
- mExifValues.mLatitude = false;
- }
-
- //set Longitude
- str = NULL;
- str = mParameters.get(QCameraParameters::KEY_GPS_LONGITUDE);
- if(str != NULL) {
- parseGPSCoordinate(str, mExifValues.longitude);
- ALOGE("EXIFTAGID_GPS_LONGITUDE = %s", str);
-
- //set Longitude Ref
- float longitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LONGITUDE);
- if(longitudeValue < 0.0f) {
- mExifValues.lonRef[0] = 'W';
- } else {
- mExifValues.lonRef[0] = 'E';
- }
- mExifValues.lonRef[1] = '\0';
- mExifValues.mLongitude = true;
- ALOGE("EXIFTAGID_GPS_LONGITUDE_REF = %s", mExifValues.lonRef);
- mParameters.set(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF, mExifValues.lonRef);
- }else{
- mExifValues.mLongitude = false;
- }
-
- //set Altitude
- str = mParameters.get(QCameraParameters::KEY_GPS_ALTITUDE);
- if(str != NULL) {
- double value = atof(str);
- mExifValues.mAltitude_ref = 0;
- if(value < 0){
- mExifValues.mAltitude_ref = 1;
- value = -value;
- }
- mExifValues.altitude = getRational(value*1000, 1000);
- mExifValues.mAltitude = true;
- //set AltitudeRef
- mParameters.set(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF, mExifValues.mAltitude_ref);
- ALOGE("EXIFTAGID_GPS_ALTITUDE = %f", value);
- }else{
- mExifValues.mAltitude = false;
- }
-
- //set Gps TimeStamp
- str = NULL;
- str = mParameters.get(QCameraParameters::KEY_GPS_TIMESTAMP);
- if(str != NULL) {
- mExifValues.mTimeStamp = true;
- mExifValues.mGPSTimestamp = atol(str);
- }else{
- mExifValues.mTimeStamp = false;
- }
-}
-
-//latlonString is string formatted coordinate
-//coord is rat_t[3]
-void QCameraHardwareInterface::parseGPSCoordinate(const char *latlonString, rat_t* coord)
-{
- if(coord == NULL) {
- ALOGE("%s: error, invalid argument coord == NULL", __func__);
- return;
- }
- float degF = fabs(atof(latlonString));
- float minF = (degF- (int) degF) * 60;
- float secF = (minF - (int) minF) * 60;
-
- coord[0] = getRational((int) degF, 1);
- coord[1] = getRational((int) minF, 1);
- coord[2] = getRational((int) (secF * 10000), 10000);
-}
-
-bool QCameraHardwareInterface::isLowPowerCamcorder() {
-
- if (mPowerMode == LOW_POWER)
- return true;
-
- if(mHFRLevel > 1) /* hard code the value now. Need to move tgtcommon to camear.h */
- return true;
-
- return false;
-}
-
-status_t QCameraHardwareInterface::setNoDisplayMode(const QCameraParameters& params)
-{
- char prop[PROPERTY_VALUE_MAX];
- memset(prop, 0, sizeof(prop));
- property_get("persist.camera.nodisplay", prop, "0");
- int prop_val = atoi(prop);
-
- if (prop_val == 0) {
- const char *str_val = params.get("no-display-mode");
- if(str_val && strlen(str_val) > 0) {
- mNoDisplayMode = atoi(str_val);
- } else {
- mNoDisplayMode = 0;
- }
- ALOGD("Param mNoDisplayMode =%d", mNoDisplayMode);
- } else {
- mNoDisplayMode = prop_val;
- ALOGD("prop mNoDisplayMode =%d", mNoDisplayMode);
- }
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setRDIMode(const QCameraParameters& params)
-{
- char prop[PROPERTY_VALUE_MAX];
- memset(prop, 0, sizeof(prop));
- property_get("persist.camera.rdi.mode", prop, "0");
- int prop_val = atoi(prop);
- rdiMode = prop_val;
- ALOGE("RDI Mode = %d",rdiMode);
- return NO_ERROR;
-}
-
-status_t QCameraHardwareInterface::setDimension()
-{
- ALOGV("%s: E", __func__);
- cam_ctrl_dimension_t dim;
- int ret = MM_CAMERA_OK;
- int postviewWidth,postviewHeight;
-
- memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
- ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DIMENSION,&dim);
-
- if (MM_CAMERA_OK != ret) {
- ALOGE("%s: error - can't get preview dimension!", __func__);
- ALOGE("%s: X", __func__);
- return BAD_VALUE;
- }
-
- getPreviewSize(&mPreviewWidth, &mPreviewHeight);
- dim.display_width = mPreviewWidth;
- dim.display_height = mPreviewHeight;
-
- cam_format_t value = getPreviewFormat();
- if(value != NOT_FOUND && value != dim.prev_format ) {
- //Setting to Parameter requested by the Upper layer
- dim.prev_format = value;
- }else{
- //Setting to default Format.
- dim.prev_format = CAMERA_YUV_420_NV21;
- }
- dim.prev_padding_format = getPreviewPadding( );
-
- getVideoSize(&videoWidth, &videoHeight);
- dim.enc_format = CAMERA_YUV_420_NV12;
- dim.orig_video_width = videoWidth;
- dim.orig_video_height = videoHeight;
- dim.video_width = videoWidth;
- dim.video_height = videoHeight;
- dim.video_chroma_width = videoWidth;
- dim.video_chroma_height = videoHeight;
-
- getPictureSize(&mPictureWidth, &mPictureHeight);
- dim.picture_width = mPictureWidth;
- dim.picture_height = mPictureHeight;
-
- getThumbnailSize(&thumbnailWidth,&thumbnailHeight);
- dim.ui_thumbnail_width = thumbnailWidth;
- dim.ui_thumbnail_height = thumbnailHeight;
-
- /* Reset the Main image and thumbnail formats here,
- * since they might have been changed when video size
- * livesnapshot was taken. */
- if (mSnapshotFormat == 1)
- dim.main_img_format = CAMERA_YUV_422_NV61;
- else
- dim.main_img_format = CAMERA_YUV_420_NV21;
- dim.thumb_format = CAMERA_YUV_420_NV21;
-
- //RDI Format
- dim.rdi0_format = CAMERA_BAYER_SBGGR10;
-
- /*Code to handle different limitations*/
- if (mRecordingHint && mFullLiveshotEnabled){
- dim.ui_thumbnail_height = dim.display_height;
- dim.ui_thumbnail_width = dim.display_width;
- }
- if (isZSLMode()){
- postviewWidth = mPreviewWidth;
- postviewHeight = mPreviewHeight;
- } else {
- postviewWidth = thumbnailWidth;
- postviewHeight = thumbnailHeight;
- }
- if (mPictureWidth < postviewWidth || mPictureHeight < postviewHeight)
- {
- //Changes to handle VFE limitation when primary o/p is main image
- dim.picture_width = postviewWidth;
- dim.picture_height = postviewHeight;
- }
-
- //VFE output1 shouldn't be greater than VFE output2.
- if( (dim.display_width > dim.video_width) ||
- (dim.display_height > dim.video_height)) {
- //Set preview sizes as record sizes.
- dim.display_width = dim.video_width;
- dim.display_height = dim.video_height;
- }
- if (mRecordingHint && mFullLiveshotEnabled){
- if( (dim.picture_width < dim.video_width) ||
- (dim.picture_height < dim.video_height)) {
- dim.picture_width = dim.video_width;
- dim.picture_height = dim.video_height;
- }
- }
-
- if(mIs3DModeOn == true) {
- /* As preview and video frames are same in 3D mode,
- * preview size should be same as video size. This
- * cahnge is needed to take of video resolutions
- * like 720P and 1080p where the application can
- * request different preview sizes like 768x432
- */
- ALOGE("3D mod is on");
- dim.display_width = dim.video_width;
- dim.display_height = dim.video_height;
- }
-
- /*End of limitation code*/
-
- ret = mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DIMENSION,&dim);
- if (MM_CAMERA_OK != ret) {
- ALOGE("%s X: error - can't config preview parms!", __func__);
- return BAD_VALUE;
- }
- if(mStreams[MM_CAMERA_PREVIEW]) {
- mStreams[MM_CAMERA_PREVIEW]->mFormat = dim.prev_format;
- mStreams[MM_CAMERA_PREVIEW]->mWidth = dim.display_width;
- mStreams[MM_CAMERA_PREVIEW]->mHeight = dim.display_height;
- }
- if(mStreams[MM_CAMERA_VIDEO]) {
- mStreams[MM_CAMERA_VIDEO]->mFormat = dim.enc_format;
- mStreams[MM_CAMERA_VIDEO]->mWidth = dim.video_width;
- mStreams[MM_CAMERA_VIDEO]->mHeight = dim.video_height;
- }
- if(mStreams[MM_CAMERA_SNAPSHOT_MAIN]) {
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mFormat = dim.main_img_format;
- if (!isRawSnapshot()) {
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mWidth = dim.picture_width;
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mHeight = dim.picture_height;
- } else {
- cam_frame_resolution_t raw_res;
-
- /* the raw_picture_width in dimension is for RDI dump.
- * here, raw snapshot size is from camif. */
- memset(&raw_res, 0, sizeof(raw_res));
- raw_res.image_mode = MSM_V4L2_EXT_CAPTURE_MODE_RAW;
- raw_res.padding_format = CAMERA_PAD_TO_WORD;
- ret = mCameraHandle->ops->get_parm(
- mCameraHandle->camera_handle,
- MM_CAMERA_PARM_FRAME_RESOLUTION,&raw_res);
- if (MM_CAMERA_OK != ret) {
- ALOGE("%s error - config raw snapshot parms, rc = %d",
- __func__, ret);
- return BAD_VALUE;
- }
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mWidth = raw_res.width;
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mHeight = raw_res.height;
- mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mFormat = raw_res.format;
- }
- }
- if(mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]) {
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mFormat = dim.thumb_format;
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mWidth = dim.ui_thumbnail_width;
- mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mHeight = dim.ui_thumbnail_height;
- }
-
- memcpy(&mDimension, &dim, sizeof(mDimension));
- ALOGV("%s: X", __func__);
- return NO_ERROR;
-}
-}; /*namespace android */
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Preview.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Preview.cpp
deleted file mode 100755
index a63c062..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Preview.cpp
+++ /dev/null
@@ -1,1007 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define LOG_TAG "QCameraHWI_Preview"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-#include <genlock.h>
-#include <gralloc_priv.h>
-
-#define UNLIKELY(exp) __builtin_expect(!!(exp), 0)
-
-/* QCameraHWI_Preview class implementation goes here*/
-/* following code implement the preview mode's image capture & display logic of this class*/
-
-namespace android {
-
-status_t QCameraStream_preview::getBufferFromSurface() {
- int err = 0;
- status_t ret = NO_ERROR;
- int gralloc_usage;
- struct ion_fd_data ion_info_fd;
- preview_stream_ops_t *previewWindow = mHalCamCtrl->mPreviewWindow;
-
- ALOGI(" %s : E ", __FUNCTION__);
-
- if( previewWindow == NULL) {
- ALOGE("%s: PreviewWindow = NULL", __func__);
- return INVALID_OPERATION;
- }
-
- mHalCamCtrl->mPreviewMemoryLock.lock();
- mHalCamCtrl->mPreviewMemory.buffer_count = mNumBuffers;
- err = previewWindow->set_buffer_count(previewWindow, mHalCamCtrl->mPreviewMemory.buffer_count );
- if (err != 0) {
- ALOGE("set_buffer_count failed: %s (%d)",
- strerror(-err), -err);
- ret = UNKNOWN_ERROR;
- goto end;
- }
-
- err = previewWindow->set_buffers_geometry(previewWindow, mWidth, mHeight,
- mHalCamCtrl->getPreviewFormatInfo().Hal_format);
- if (err != 0) {
- ALOGE("set_buffers_geometry failed: %s (%d)",
- strerror(-err), -err);
- ret = UNKNOWN_ERROR;
- goto end;
- }
-
- ret = p_mm_ops->ops->get_parm(mCameraHandle, MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, &mVFEOutputs);
- if(ret != MM_CAMERA_OK) {
- ALOGE("get parm MM_CAMERA_PARM_VFE_OUTPUT_ENABLE failed");
- ret = BAD_VALUE;
- goto end;
- }
-
- //as software encoder is used to encode 720p, to enhance the performance
- //cashed pmem is used here
- if(mVFEOutputs == 1)
- gralloc_usage = CAMERA_GRALLOC_HEAP_ID | CAMERA_GRALLOC_FALLBACK_HEAP_ID;
- else
- gralloc_usage = CAMERA_GRALLOC_HEAP_ID | CAMERA_GRALLOC_FALLBACK_HEAP_ID |
- CAMERA_GRALLOC_CACHING_ID;
- err = previewWindow->set_usage(previewWindow, gralloc_usage);
- if(err != 0) {
- /* set_usage error out */
- ALOGE("%s: set_usage rc = %d", __func__, err);
- ret = UNKNOWN_ERROR;
- goto end;
- }
- ret = p_mm_ops->ops->get_parm(mCameraHandle, MM_CAMERA_PARM_HFR_FRAME_SKIP, &mHFRFrameSkip);
- if(ret != MM_CAMERA_OK) {
- ALOGE("get parm MM_CAMERA_PARM_HFR_FRAME_SKIP failed");
- ret = BAD_VALUE;
- goto end;
- }
- for (int cnt = 0; cnt < mHalCamCtrl->mPreviewMemory.buffer_count; cnt++) {
- int stride;
- err = previewWindow->dequeue_buffer(previewWindow,
- &mHalCamCtrl->mPreviewMemory.buffer_handle[cnt],
- &mHalCamCtrl->mPreviewMemory.stride[cnt]);
- if(!err) {
- ALOGV("%s: dequeue buf hdl =%p", __func__, *mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
- err = previewWindow->lock_buffer(previewWindow,
- mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
- // lock the buffer using genlock
- ALOGV("%s: camera call genlock_lock, hdl=%p",
- __FUNCTION__, (*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]));
- if (GENLOCK_NO_ERROR != genlock_lock_buffer((native_handle_t *)(*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]),
- GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT)) {
- ALOGE("%s: genlock_lock_buffer(WRITE) failed", __func__);
- mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_UNLOCKED;
- } else {
- ALOGV("%s: genlock_lock_buffer hdl =%p", __func__, *mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
- mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_LOCKED;
- }
- } else {
- mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_NOT_OWNED;
- ALOGE("%s: dequeue_buffer idx = %d err = %d", __func__, cnt, err);
- }
-
- ALOGV("%s: dequeue buf: %p\n", __func__, mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
-
- if(err != 0) {
- ALOGE("%s: dequeue_buffer failed: %s (%d)", __func__,
- strerror(-err), -err);
- ret = UNKNOWN_ERROR;
- for(int i = 0; i < cnt; i++) {
- if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[i]) {
- ALOGD("%s: camera call genlock_unlock", __func__);
- if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t *)
- (*(mHalCamCtrl->mPreviewMemory.buffer_handle[i])))) {
- ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__, (*(mHalCamCtrl->mPreviewMemory.buffer_handle[i])) );
- } else {
- mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_UNLOCKED;
- }
- }
- if( mHalCamCtrl->mPreviewMemory.local_flag[i] != BUFFER_NOT_OWNED) {
- err = previewWindow->cancel_buffer(previewWindow,
- mHalCamCtrl->mPreviewMemory.buffer_handle[i]);
- }
- mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_NOT_OWNED;
- ALOGD("%s: cancel_buffer: hdl =%p", __func__, (*mHalCamCtrl->mPreviewMemory.buffer_handle[i]));
- mHalCamCtrl->mPreviewMemory.buffer_handle[i] = NULL;
- }
- memset(&mHalCamCtrl->mPreviewMemory, 0, sizeof(mHalCamCtrl->mPreviewMemory));
- goto end;
- }
-
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt] =
- (struct private_handle_t *)(*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
-#ifdef USE_ION
- mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd = open("/dev/ion", O_RDONLY);
- if (mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd < 0) {
- ALOGE("%s: failed: could not open ion device\n", __func__);
- } else {
- memset(&ion_info_fd, 0, sizeof(ion_info_fd));
- ion_info_fd.fd = mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd;
- if (ioctl(mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd,
- ION_IOC_IMPORT, &ion_info_fd) < 0) {
- ALOGE("ION import failed\n");
- }
- }
-#endif
- mHalCamCtrl->mPreviewMemory.camera_memory[cnt] =
- mHalCamCtrl->mGetMemory(mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd,
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->size,
- 1,
- (void *)this);
- ALOGD("%s: idx = %d, fd = %d, size = %d, offset = %d", __func__,
- cnt, mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd,
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->size,
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->offset);
-
- mHalCamCtrl->mPreviewMemory.mem_info[cnt].fd =
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd;
- mHalCamCtrl->mPreviewMemory.mem_info[cnt].size =
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->size;
- mHalCamCtrl->mPreviewMemory.mem_info[cnt].handle = ion_info_fd.handle;
- }
-
- memset(&mHalCamCtrl->mMetadata, 0, sizeof(mHalCamCtrl->mMetadata));
- memset(mHalCamCtrl->mFace, 0, sizeof(mHalCamCtrl->mFace));
-
-end:
- mHalCamCtrl->mPreviewMemoryLock.unlock();
-
- ALOGI(" %s : X ",__func__);
- return ret;
-}
-
-status_t QCameraStream_preview::putBufferToSurface() {
- int err = 0;
- status_t ret = NO_ERROR;
-
- ALOGI(" %s : E ", __FUNCTION__);
-
- mHalCamCtrl->mPreviewMemoryLock.lock();
- for (int cnt = 0; cnt < mHalCamCtrl->mPreviewMemory.buffer_count; cnt++) {
- mHalCamCtrl->mPreviewMemory.camera_memory[cnt]->release(mHalCamCtrl->mPreviewMemory.camera_memory[cnt]);
-#ifdef USE_ION
- struct ion_handle_data ion_handle;
- memset(&ion_handle, 0, sizeof(ion_handle));
- ion_handle.handle = mHalCamCtrl->mPreviewMemory.mem_info[cnt].handle;
- if (ioctl(mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) {
- ALOGE("%s: ion free failed\n", __func__);
- }
- close(mHalCamCtrl->mPreviewMemory.mem_info[cnt].main_ion_fd);
-#endif
- if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[cnt]) {
- ALOGD("%s: camera call genlock_unlock", __FUNCTION__);
- if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t *)
- (*(mHalCamCtrl->mPreviewMemory.buffer_handle[cnt])))) {
- ALOGE("%s: genlock_unlock_buffer failed, handle =%p", __FUNCTION__, (*(mHalCamCtrl->mPreviewMemory.buffer_handle[cnt])));
- continue;
- } else {
-
- ALOGD("%s: genlock_unlock_buffer, handle =%p", __FUNCTION__, (*(mHalCamCtrl->mPreviewMemory.buffer_handle[cnt])));
- mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_UNLOCKED;
- }
- }
- if( mHalCamCtrl->mPreviewMemory.local_flag[cnt] != BUFFER_NOT_OWNED) {
- if (mHalCamCtrl->mPreviewWindow) {
- err = mHalCamCtrl->mPreviewWindow->cancel_buffer(mHalCamCtrl->mPreviewWindow,
- mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
- ALOGD("%s: cancel_buffer: hdl =%p", __func__, (*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]));
- } else {
- ALOGE("%s: Preview window is NULL, cannot cancel_buffer: hdl =%p",
- __func__, (*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]));
- }
- }
- mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_NOT_OWNED;
- ALOGD(" put buffer %d successfully", cnt);
- }
- mHalCamCtrl->mPreviewMemoryLock.unlock();
- memset(&mHalCamCtrl->mPreviewMemory, 0, sizeof(mHalCamCtrl->mPreviewMemory));
- ALOGI(" %s : X ",__FUNCTION__);
- return NO_ERROR;
-}
-
-status_t QCameraStream_preview::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
- int format = 0;
- status_t ret = NO_ERROR;
- int numMinUndequeuedBufs;
- int err = 0;
-
- ALOGI(" %s : E ", __FUNCTION__);
- if (mHalCamCtrl->isNoDisplayMode()) {
- mNumBuffers = PREVIEW_BUFFER_COUNT;
- if(mHalCamCtrl->isZSLMode()) {
- if(mNumBuffers < mHalCamCtrl->getZSLQueueDepth() + 3) {
- mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
- }
- }
- } else {
- if( mHalCamCtrl->mPreviewWindow == NULL) {
- ALOGE("%s: PreviewWindow = NULL", __func__);
- return INVALID_OPERATION;
- }
- numMinUndequeuedBufs = 0;
- if(mHalCamCtrl->mPreviewWindow->get_min_undequeued_buffer_count) {
- err = mHalCamCtrl->mPreviewWindow->get_min_undequeued_buffer_count(
- mHalCamCtrl->mPreviewWindow, &numMinUndequeuedBufs);
- if (err != 0) {
- ALOGE("get_min_undequeued_buffer_count failed: %s (%d)",
- strerror(-err), -err);
- ret = UNKNOWN_ERROR;
- goto end;
- }
- }
- mNumBuffers = PREVIEW_BUFFER_COUNT + numMinUndequeuedBufs;
- if(mHalCamCtrl->isZSLMode()) {
- if(mHalCamCtrl->getZSLQueueDepth() > numMinUndequeuedBufs)
- mNumBuffers += mHalCamCtrl->getZSLQueueDepth() - numMinUndequeuedBufs;
- }
- }
- ret = QCameraStream::initStream(no_cb_needed, stream_on);
-end:
- ALOGI(" %s : X ", __FUNCTION__);
- return ret;
-}
-
-
-status_t QCameraStream_preview::getBufferNoDisplay( )
-{
- status_t ret = NO_ERROR;
- uint32_t planes[VIDEO_MAX_PLANES];
-
- ALOGI("%s : E ", __FUNCTION__);
-
- mHalCamCtrl->mPreviewMemoryLock.lock();
- memset(mDisplayBuf, 0, sizeof(mDisplayBuf));
- if (mHalCamCtrl->initHeapMem(&mHalCamCtrl->mNoDispPreviewMemory,
- mNumBuffers,
- mFrameOffsetInfo.frame_len,
- MSM_PMEM_MAINIMG,
- &mFrameOffsetInfo,
- mDisplayBuf) < 0) {
- ret = NO_MEMORY;
- goto end;
- }
-
- memset(&mHalCamCtrl->mMetadata, 0, sizeof(mHalCamCtrl->mMetadata));
- memset(mHalCamCtrl->mFace, 0, sizeof(mHalCamCtrl->mFace));
-
- ALOGI(" %s : X ",__FUNCTION__);
-end:
- mHalCamCtrl->mPreviewMemoryLock.unlock();
- return ret;
-}
-
-status_t QCameraStream_preview::freeBufferNoDisplay()
-{
- ALOGI(" %s : E ", __FUNCTION__);
- mHalCamCtrl->mPreviewMemoryLock.lock();
- mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mNoDispPreviewMemory);
- memset(&mHalCamCtrl->mNoDispPreviewMemory, 0, sizeof(mHalCamCtrl->mNoDispPreviewMemory));
- mHalCamCtrl->mPreviewMemoryLock.unlock();
- ALOGI(" %s : X ",__FUNCTION__);
- return NO_ERROR;
-}
-
-void QCameraStream_preview::notifyROIEvent(fd_roi_t roi)
-{
- switch (roi.type) {
- case FD_ROI_TYPE_HEADER:
- {
- mDisplayLock.lock();
- mNumFDRcvd = 0;
- memset(mHalCamCtrl->mFace, 0, sizeof(mHalCamCtrl->mFace));
- mHalCamCtrl->mMetadata.faces = mHalCamCtrl->mFace;
- mHalCamCtrl->mMetadata.number_of_faces = roi.d.hdr.num_face_detected;
- if(mHalCamCtrl->mMetadata.number_of_faces > MAX_ROI)
- mHalCamCtrl->mMetadata.number_of_faces = MAX_ROI;
- mDisplayLock.unlock();
-
- if (mHalCamCtrl->mMetadata.number_of_faces == 0) {
- // Clear previous faces
- if (mHalCamCtrl->mDataCb && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA)){
- ALOGE("%s: Face detection RIO callback", __func__);
- mHalCamCtrl->mDataCb(CAMERA_MSG_PREVIEW_METADATA, NULL, 0,
- &mHalCamCtrl->mMetadata, mHalCamCtrl->mCallbackCookie);
- }
- }
- }
- break;
- case FD_ROI_TYPE_DATA:
- {
- mDisplayLock.lock();
- int idx = roi.d.data.idx;
- if (idx >= mHalCamCtrl->mMetadata.number_of_faces) {
- mDisplayLock.unlock();
- ALOGE("%s: idx %d out of boundary %d",
- __func__, idx, mHalCamCtrl->mMetadata.number_of_faces);
- break;
- }
-
- mHalCamCtrl->mFace[idx].id = roi.d.data.face.id;
- mHalCamCtrl->mFace[idx].score = roi.d.data.face.score;
-
- // top
- mHalCamCtrl->mFace[idx].rect[0] =
- roi.d.data.face.face_boundary.x*2000/mHalCamCtrl->mDimension.display_width - 1000;
- //right
- mHalCamCtrl->mFace[idx].rect[1] =
- roi.d.data.face.face_boundary.y*2000/mHalCamCtrl->mDimension.display_height - 1000;
- //bottom
- mHalCamCtrl->mFace[idx].rect[2] = mHalCamCtrl->mFace[idx].rect[0] +
- roi.d.data.face.face_boundary.dx*2000/mHalCamCtrl->mDimension.display_width;
- //left
- mHalCamCtrl->mFace[idx].rect[3] = mHalCamCtrl->mFace[idx].rect[1] +
- roi.d.data.face.face_boundary.dy*2000/mHalCamCtrl->mDimension.display_height;
-
- // Center of left eye
- mHalCamCtrl->mFace[idx].left_eye[0] =
- roi.d.data.face.left_eye_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000;
- mHalCamCtrl->mFace[idx].left_eye[1] =
- roi.d.data.face.left_eye_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000;
-
- // Center of right eye
- mHalCamCtrl->mFace[idx].right_eye[0] =
- roi.d.data.face.right_eye_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000;
- mHalCamCtrl->mFace[idx].right_eye[1] =
- roi.d.data.face.right_eye_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000;
-
- // Center of mouth
- mHalCamCtrl->mFace[idx].mouth[0] =
- roi.d.data.face.mouth_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000;
- mHalCamCtrl->mFace[idx].mouth[1] =
- roi.d.data.face.mouth_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000;
-
- mHalCamCtrl->mFace[idx].smile_degree = roi.d.data.face.smile_degree;
- mHalCamCtrl->mFace[idx].smile_score = roi.d.data.face.smile_confidence;
- mHalCamCtrl->mFace[idx].blink_detected = roi.d.data.face.blink_detected;
- mHalCamCtrl->mFace[idx].face_recognised = roi.d.data.face.is_face_recognised;
- mHalCamCtrl->mFace[idx].gaze_angle = roi.d.data.face.gaze_angle;
-
- /* newly added */
- // upscale by 2 to recover from demaen downscaling
- mHalCamCtrl->mFace[idx].updown_dir = roi.d.data.face.updown_dir * 2;
- mHalCamCtrl->mFace[idx].leftright_dir = roi.d.data.face.leftright_dir * 2;
- mHalCamCtrl->mFace[idx].roll_dir = roi.d.data.face.roll_dir * 2;
-
- mHalCamCtrl->mFace[idx].leye_blink = roi.d.data.face.left_blink;
- mHalCamCtrl->mFace[idx].reye_blink = roi.d.data.face.right_blink;
- mHalCamCtrl->mFace[idx].left_right_gaze = roi.d.data.face.left_right_gaze;
- mHalCamCtrl->mFace[idx].top_bottom_gaze = roi.d.data.face.top_bottom_gaze;
- ALOGE("%s: Face(%d, %d, %d, %d), leftEye(%d, %d), rightEye(%d, %d), mouth(%d, %d), smile(%d, %d), face_recg(%d)", __func__,
- mHalCamCtrl->mFace[idx].rect[0], mHalCamCtrl->mFace[idx].rect[1],
- mHalCamCtrl->mFace[idx].rect[2], mHalCamCtrl->mFace[idx].rect[3],
- mHalCamCtrl->mFace[idx].left_eye[0], mHalCamCtrl->mFace[idx].left_eye[1],
- mHalCamCtrl->mFace[idx].right_eye[0], mHalCamCtrl->mFace[idx].right_eye[1],
- mHalCamCtrl->mFace[idx].mouth[0], mHalCamCtrl->mFace[idx].mouth[1],
- mHalCamCtrl->mFace[idx].smile_degree, mHalCamCtrl->mFace[idx].smile_score,
- mHalCamCtrl->mFace[idx].face_recognised);
- ALOGE("%s: gaze(%d, %d, %d), updown(%d), leftright(%d), roll(%d), blink(%d, %d, %d)", __func__,
- mHalCamCtrl->mFace[idx].gaze_angle, mHalCamCtrl->mFace[idx].left_right_gaze,
- mHalCamCtrl->mFace[idx].top_bottom_gaze, mHalCamCtrl->mFace[idx].updown_dir,
- mHalCamCtrl->mFace[idx].leftright_dir, mHalCamCtrl->mFace[idx].roll_dir,
- mHalCamCtrl->mFace[idx].blink_detected,
- mHalCamCtrl->mFace[idx].leye_blink, mHalCamCtrl->mFace[idx].reye_blink);
-
- mNumFDRcvd++;
- mDisplayLock.unlock();
-
- if (mNumFDRcvd == mHalCamCtrl->mMetadata.number_of_faces) {
- if (mHalCamCtrl->mDataCb && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA)){
- ALOGE("%s: Face detection RIO callback with %d faces detected (score=%d)", __func__, mNumFDRcvd, mHalCamCtrl->mFace[idx].score);
- mHalCamCtrl->mDataCb(CAMERA_MSG_PREVIEW_METADATA, NULL,
- 0, &mHalCamCtrl->mMetadata, mHalCamCtrl->mCallbackCookie);
- }
- }
- }
- break;
- }
-}
-
-status_t QCameraStream_preview::initDisplayBuffers()
-{
- status_t ret = NO_ERROR;
- uint8_t num_planes = mFrameOffsetInfo.num_planes;
- uint32_t planes[VIDEO_MAX_PLANES];
-
- ALOGI("%s:BEGIN",__func__);
- memset(&mHalCamCtrl->mMetadata, 0, sizeof(camera_frame_metadata_t));
- mHalCamCtrl->mPreviewMemoryLock.lock();
- memset(&mHalCamCtrl->mPreviewMemory, 0, sizeof(mHalCamCtrl->mPreviewMemory));
- mHalCamCtrl->mPreviewMemoryLock.unlock();
- memset(mNotifyBuffer, 0, sizeof(mNotifyBuffer));
-
- ret = getBufferFromSurface();
- if(ret != NO_ERROR) {
- ALOGE("%s: cannot get memory from surface texture client, ret = %d", __func__, ret);
- return ret;
- }
-
- /* set 4 buffers for display */
- mHalCamCtrl->mPreviewMemoryLock.lock();
- for(int i=0; i < num_planes; i++)
- planes[i] = mFrameOffsetInfo.mp[i].len;
- memset(mDisplayBuf, 0, sizeof(mm_camera_buf_def_t) * 2 * PREVIEW_BUFFER_COUNT);
- /*allocate memory for the buffers*/
- for(int i = 0; i < mNumBuffers; i++){
- if (mHalCamCtrl->mPreviewMemory.private_buffer_handle[i] == NULL)
- continue;
- mHalCamCtrl->mPreviewMemory.addr_offset[i] =
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->offset;
- ALOGD("%s: idx = %d, fd = %d, size = %d, cbcr_offset = %d, y_offset = %d, "
- "offset = %d, vaddr = 0x%lx", __func__, i, mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd,
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->size,
- planes[0], 0,
- mHalCamCtrl->mPreviewMemory.addr_offset[i],
- (long unsigned int)mHalCamCtrl->mPreviewMemory.camera_memory[i]->data);
- mDisplayBuf[i].num_planes = num_planes;
-
- /* Plane 0 needs to be set seperately. Set other planes
- * in a loop. */
- mDisplayBuf[i].planes[0].length = planes[0];
- mDisplayBuf[i].planes[0].m.userptr = mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd;
- mDisplayBuf[i].planes[0].data_offset = mFrameOffsetInfo.mp[0].offset;
- mDisplayBuf[i].planes[0].reserved[0] =0;// mHalCamCtrl->mPreviewMemory.addr_offset[i]; // mDisplayBuf.preview.buf.mp[i].frame_offset;
- for (int j = 1; j < num_planes; j++) {
- mDisplayBuf[i].planes[j].length = planes[j];
- mDisplayBuf[i].planes[j].m.userptr = mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd;
- mDisplayBuf[i].planes[j].data_offset = mFrameOffsetInfo.mp[j].offset;
- mDisplayBuf[i].planes[j].reserved[0] =
- mDisplayBuf[i].planes[j-1].reserved[0] +
- mDisplayBuf[i].planes[j-1].length;
- }
-
- for (int j = 0; j < num_planes; j++)
- ALOGD("Planes: %d length: %d userptr: %lu offset: %d\n", j,
- mDisplayBuf[i].planes[j].length,
- mDisplayBuf[i].planes[j].m.userptr,
- mDisplayBuf[i].planes[j].reserved[0]);
-
- mDisplayBuf[i].fd = mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd;
- ALOGD("DEBUG2:Display buf[%d] fd:%d",i,mDisplayBuf[i].fd);
- mDisplayBuf[i].frame_len = mFrameOffsetInfo.frame_len;
- mDisplayBuf[i].buffer = (void *)mHalCamCtrl->mPreviewMemory.camera_memory[i]->data;
- mDisplayBuf[i].mem_info = (void *)&mHalCamCtrl->mPreviewMemory.mem_info[i];
- }/*end of for loop*/
-
- /* register the streaming buffers for the channel*/
- mHalCamCtrl->mPreviewMemoryLock.unlock();
- ALOGI("%s:END",__func__);
- return NO_ERROR;
-
-error:
- mHalCamCtrl->mPreviewMemoryLock.unlock();
- putBufferToSurface();
-
- ALOGV("%s: X", __func__);
- return ret;
-}
-
-status_t QCameraStream_preview::initPreviewOnlyBuffers()
-{
- status_t ret = NO_ERROR;
- uint8_t num_planes = mFrameOffsetInfo.num_planes;
- uint32_t planes[VIDEO_MAX_PLANES];
-
- ALOGI("%s:BEGIN",__func__);
- memset(&mHalCamCtrl->mMetadata, 0, sizeof(camera_frame_metadata_t));
- mHalCamCtrl->mPreviewMemoryLock.lock();
- memset(&mHalCamCtrl->mNoDispPreviewMemory, 0, sizeof(mHalCamCtrl->mNoDispPreviewMemory));
- mHalCamCtrl->mPreviewMemoryLock.unlock();
-
- memset(mNotifyBuffer, 0, sizeof(mNotifyBuffer));
- memset(mDisplayBuf, 0, sizeof(mDisplayBuf));
-
- ret = getBufferNoDisplay( );
- if(ret != NO_ERROR) {
- ALOGE("%s: cannot get memory from surface texture client, ret = %d", __func__, ret);
- return ret;
- }
-
- ALOGI("%s:END",__func__);
- return NO_ERROR;
-}
-
-
-void QCameraStream_preview::dumpFrameToFile(mm_camera_buf_def_t *newFrame)
-{
- int32_t enabled = 0;
- int frm_num;
- uint32_t skip_mode;
- char value[PROPERTY_VALUE_MAX];
- char buf[32];
- int w, h;
- static int count = 0;
- cam_ctrl_dimension_t dim;
- int file_fd;
- int rc = 0;
- int len;
- unsigned long addr;
- unsigned long * tmp = (unsigned long *)newFrame->buffer;
- addr = *tmp;
- status_t ret = p_mm_ops->ops->get_parm(mCameraHandle,
- MM_CAMERA_PARM_DIMENSION, &dim);
-
- w = dim.display_width;
- h = dim.display_height;
- len = (w * h)*3/2;
- count++;
- if(count < 100) {
- snprintf(buf, sizeof(buf), "/data/mzhu%d.yuv", count);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-
- rc = write(file_fd, (const void *)addr, len);
- ALOGE("%s: file='%s', vaddr_old=0x%x, addr_map = 0x%p, len = %d, rc = %d",
- __func__, buf, (uint32_t)newFrame->buffer, (void *)addr, len, rc);
- close(file_fd);
- ALOGE("%s: dump %s, rc = %d, len = %d", __func__, buf, rc, len);
- }
-}
-
-status_t QCameraStream_preview::processPreviewFrameWithDisplay(mm_camera_super_buf_t *frame)
-{
- ALOGV("%s",__func__);
- int err = 0;
- int msgType = 0;
- int i;
- camera_memory_t *data = NULL;
- camera_frame_metadata_t *metadata = NULL;
- int preview_buf_idx = frame->bufs[0]->buf_idx;
-
- if(!mActive) {
- ALOGE("Preview Stopped. Returning callback");
- return NO_ERROR;
- }
-
- if(mHalCamCtrl==NULL) {
- ALOGE("%s: X: HAL control object not set",__func__);
- /*Call buf done*/
- return BAD_VALUE;
- }
-
- if(mFirstFrameRcvd == false) {
- mFirstFrameRcvd = true;
- }
-
- if (UNLIKELY(mHalCamCtrl->mDebugFps)) {
- mHalCamCtrl->debugShowPreviewFPS();
- }
- mHalCamCtrl->dumpFrameToFile(frame->bufs[0], HAL_DUMP_FRM_PREVIEW);
-
- mHalCamCtrl->mPreviewMemoryLock.lock();
- mNotifyBuffer[preview_buf_idx] = *frame;
-
- ALOGD("<DEBUG2>: Received Frame fd:%d placed in index:%d db[index].fd:%d",
- frame->bufs[0]->fd, preview_buf_idx,
- mHalCamCtrl->mPreviewMemory.private_buffer_handle[preview_buf_idx]->fd);
-
- ALOGI("Enqueue buf handle %p\n",
- mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
- ALOGD("%s: camera call genlock_unlock", __FUNCTION__);
- if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[preview_buf_idx]) {
- ALOGD("%s: genlock_unlock_buffer hdl =%p", __FUNCTION__, (*mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]));
- if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t*)
- (*mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]))) {
- ALOGE("%s: genlock_unlock_buffer failed", __FUNCTION__);
- } else {
- mHalCamCtrl->mPreviewMemory.local_flag[preview_buf_idx] = BUFFER_UNLOCKED;
- }
- } else {
- ALOGE("%s: buffer to be enqueued is not locked", __FUNCTION__);
- }
-
- mHalCamCtrl->cache_ops(&mHalCamCtrl->mPreviewMemory.mem_info[preview_buf_idx],
- (void *)mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx]->data,
- ION_IOC_CLEAN_CACHES);
- mHalCamCtrl->cache_ops(&mHalCamCtrl->mPreviewMemory.mem_info[preview_buf_idx],
- (void *)mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx]->data,
- ION_IOC_CLEAN_INV_CACHES);
-
- if(mHFRFrameSkip == 1)
- {
- ALOGE("In HFR Frame skip");
- const char *str = mHalCamCtrl->mParameters.get(
- QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE);
- if(str != NULL){
- int is_hfr_off = 0;
- mHFRFrameCnt++;
- if(!strcmp(str, QCameraParameters::VIDEO_HFR_OFF)) {
- is_hfr_off = 1;
- err = mHalCamCtrl->mPreviewWindow->enqueue_buffer(mHalCamCtrl->mPreviewWindow,
- (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
- } else if (!strcmp(str, QCameraParameters::VIDEO_HFR_2X)) {
- mHFRFrameCnt %= 2;
- } else if (!strcmp(str, QCameraParameters::VIDEO_HFR_3X)) {
- mHFRFrameCnt %= 3;
- } else if (!strcmp(str, QCameraParameters::VIDEO_HFR_4X)) {
- mHFRFrameCnt %= 4;
- }
- if(mHFRFrameCnt == 0)
- err = mHalCamCtrl->mPreviewWindow->enqueue_buffer(mHalCamCtrl->mPreviewWindow,
- (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
- else if(!is_hfr_off)
- err = mHalCamCtrl->mPreviewWindow->cancel_buffer(mHalCamCtrl->mPreviewWindow,
- (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
- } else
- err = mHalCamCtrl->mPreviewWindow->enqueue_buffer(mHalCamCtrl->mPreviewWindow,
- (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
- } else {
- err = mHalCamCtrl->mPreviewWindow->enqueue_buffer(mHalCamCtrl->mPreviewWindow,
- (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
- }
- if(err != 0) {
- ALOGE("%s: enqueue_buffer failed, err = %d", __func__, err);
- } else {
- ALOGD("%s: enqueue_buffer hdl=%p", __func__, *mHalCamCtrl->mPreviewMemory.buffer_handle[preview_buf_idx]);
- mHalCamCtrl->mPreviewMemory.local_flag[preview_buf_idx] = BUFFER_NOT_OWNED;
- }
- buffer_handle_t *buffer_handle = NULL;
- int tmp_stride = 0;
- err = mHalCamCtrl->mPreviewWindow->dequeue_buffer(mHalCamCtrl->mPreviewWindow,
- &buffer_handle, &tmp_stride);
- if (err == NO_ERROR && buffer_handle != NULL) {
-
- ALOGD("%s: dequed buf hdl =%p", __func__, *buffer_handle);
- for(i = 0; i < mHalCamCtrl->mPreviewMemory.buffer_count; i++) {
- if(mHalCamCtrl->mPreviewMemory.buffer_handle[i] == buffer_handle) {
- ALOGE("<DEBUG2>:Found buffer in idx:%d",i);
- mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_UNLOCKED;
- break;
- }
- }
- if (i < mHalCamCtrl->mPreviewMemory.buffer_count ) {
- err = mHalCamCtrl->mPreviewWindow->lock_buffer(mHalCamCtrl->mPreviewWindow, buffer_handle);
- ALOGD("%s: camera call genlock_lock: hdl =%p", __func__, *buffer_handle);
- if (GENLOCK_FAILURE == genlock_lock_buffer((native_handle_t*)(*buffer_handle), GENLOCK_WRITE_LOCK,
- GENLOCK_MAX_TIMEOUT)) {
- ALOGE("%s: genlock_lock_buffer(WRITE) failed", __func__);
- } else {
- mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_LOCKED;
-
- if(MM_CAMERA_OK != p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mNotifyBuffer[i].bufs[0])) {
-
- ALOGE("BUF DONE FAILED");
- }
- mHalCamCtrl->cache_ops((QCameraHalMemInfo_t *)(mNotifyBuffer[i].bufs[0]->mem_info),
- mNotifyBuffer[i].bufs[0]->buffer,
- ION_IOC_INV_CACHES);
- }
- }
- } else
- ALOGE("%s: enqueue_buffer idx = %d, no free buffer from display now", __func__, frame->bufs[0]->buf_idx);
- /* Save the last displayed frame. We'll be using it to fill the gap between
- when preview stops and postview start during snapshot.*/
- mLastQueuedFrame = &(mDisplayBuf[preview_buf_idx]);
- mHalCamCtrl->mPreviewMemoryLock.unlock();
-
- nsecs_t timeStamp = seconds_to_nanoseconds(frame->bufs[0]->ts.tv_sec) ;
- timeStamp += frame->bufs[0]->ts.tv_nsec;
- ALOGD("Message enabled = 0x%x", mHalCamCtrl->mMsgEnabled);
-
- camera_memory_t *previewMem = NULL;
-
- if (mHalCamCtrl->mDataCb != NULL) {
- ALOGD("%s: mMsgEnabled =0x%x, preview format =%d", __func__,
- mHalCamCtrl->mMsgEnabled, mHalCamCtrl->mPreviewFormat);
- //Sending preview callback if corresponding Msgs are enabled
- if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
- ALOGE("Q%s: PCB callback enabled", __func__);
- msgType |= CAMERA_MSG_PREVIEW_FRAME;
- int previewBufSize;
- /* The preview buffer size sent back in the callback should be (width*height*bytes_per_pixel)
- * As all preview formats we support, use 12 bits per pixel, buffer size = previewWidth * previewHeight * 3/2.
- * We need to put a check if some other formats are supported in future. (punits) */
- if ((mHalCamCtrl->mPreviewFormat == CAMERA_YUV_420_NV21) ||
- (mHalCamCtrl->mPreviewFormat == CAMERA_YUV_420_NV12) ||
- (mHalCamCtrl->mPreviewFormat == CAMERA_YUV_420_YV12))
- {
- if(mHalCamCtrl->mPreviewFormat == CAMERA_YUV_420_YV12) {
- previewBufSize = ((mHalCamCtrl->mPreviewWidth+15)/16) * 16 * mHalCamCtrl->mPreviewHeight +
- ((mHalCamCtrl->mPreviewWidth/2+15)/16) * 16* mHalCamCtrl->mPreviewHeight;
- } else {
- previewBufSize = mHalCamCtrl->mPreviewWidth * mHalCamCtrl->mPreviewHeight * 3/2;
- }
- if(previewBufSize != mHalCamCtrl->mPreviewMemory.private_buffer_handle[preview_buf_idx]->size) {
- previewMem = mHalCamCtrl->mGetMemory(mHalCamCtrl->mPreviewMemory.private_buffer_handle[preview_buf_idx]->fd,
- previewBufSize, 1, mHalCamCtrl->mCallbackCookie);
- if (!previewMem || !previewMem->data) {
- ALOGE("%s: mGetMemory failed.\n", __func__);
- } else {
- data = previewMem;
- }
- } else
- data = mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx];
- } else {
- data = mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx];
- ALOGE("Invalid preview format, buffer size in preview callback may be wrong.");
- }
- } else {
- data = NULL;
- }
- if(msgType && mActive) {
- mHalCamCtrl->mDataCb(msgType, data, 0, metadata, mHalCamCtrl->mCallbackCookie);
- }
- if (previewMem) {
- previewMem->release(previewMem);
- }
- ALOGD("end of cb");
- } else {
- ALOGD("%s PCB is not enabled", __func__);
- }
- if(mHalCamCtrl->mDataCbTimestamp != NULL && mVFEOutputs == 1)
- {
- int flagwait = 1;
- if(mHalCamCtrl->mStartRecording == true &&
- ( mHalCamCtrl->mMsgEnabled & CAMERA_MSG_VIDEO_FRAME))
- {
- if (mHalCamCtrl->mStoreMetaDataInFrame)
- {
- if(mHalCamCtrl->mRecordingMemory.metadata_memory[preview_buf_idx])
- {
- flagwait = 1;
- mHalCamCtrl->mDataCbTimestamp(timeStamp, CAMERA_MSG_VIDEO_FRAME,
- mHalCamCtrl->mRecordingMemory.metadata_memory[preview_buf_idx],
- 0, mHalCamCtrl->mCallbackCookie);
- }else
- flagwait = 0;
- }
- else
- {
- mHalCamCtrl->mDataCbTimestamp(timeStamp, CAMERA_MSG_VIDEO_FRAME,
- mHalCamCtrl->mPreviewMemory.camera_memory[preview_buf_idx],
- 0, mHalCamCtrl->mCallbackCookie);
- }
-
- if(flagwait){
- Mutex::Autolock rLock(&mHalCamCtrl->mRecordFrameLock);
- if (mHalCamCtrl->mReleasedRecordingFrame != true) {
- mHalCamCtrl->mRecordWait.wait(mHalCamCtrl->mRecordFrameLock);
- }
- mHalCamCtrl->mReleasedRecordingFrame = false;
- }
- }
- }
- return NO_ERROR;
-}
-
-
-status_t QCameraStream_preview::processPreviewFrameWithOutDisplay(
- mm_camera_super_buf_t *frame)
-{
- ALOGV("%s",__func__);
- int err = 0;
- int msgType = 0;
- int i;
- camera_memory_t *data = NULL;
- camera_frame_metadata_t *metadata = NULL;
- int preview_buf_idx = frame->bufs[0]->buf_idx;
-
- if(mHalCamCtrl==NULL) {
- ALOGE("%s: X: HAL control object not set",__func__);
- /*Call buf done*/
- return BAD_VALUE;
- }
-
- if (UNLIKELY(mHalCamCtrl->mDebugFps)) {
- mHalCamCtrl->debugShowPreviewFPS();
- }
- mHalCamCtrl->dumpFrameToFile(frame->bufs[0], HAL_DUMP_FRM_PREVIEW);
-
- mHalCamCtrl->mPreviewMemoryLock.lock();
- mNotifyBuffer[preview_buf_idx] = *frame;
-
- /* Save the last displayed frame. We'll be using it to fill the gap between
- when preview stops and postview start during snapshot.*/
- mLastQueuedFrame = &(mDisplayBuf[frame->bufs[0]->buf_idx]);
- mHalCamCtrl->mPreviewMemoryLock.unlock();
-
- ALOGD("Message enabled = 0x%x", mHalCamCtrl->mMsgEnabled);
-
- mHalCamCtrl->cache_ops(&mHalCamCtrl->mNoDispPreviewMemory.mem_info[preview_buf_idx],
- (void *)mHalCamCtrl->mNoDispPreviewMemory.camera_memory[preview_buf_idx]->data,
- ION_IOC_CLEAN_CACHES);
-
- if (mHalCamCtrl->mDataCb != NULL) {
- //Sending preview callback if corresponding Msgs are enabled
- if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
- msgType |= CAMERA_MSG_PREVIEW_FRAME;
- int previewBufSize;
- /* For CTS : Forcing preview memory buffer lenth to be
- 'previewWidth * previewHeight * 3/2'.
- Needed when gralloc allocated extra memory.*/
- //Can add this check for other formats as well.
- data = mHalCamCtrl->mNoDispPreviewMemory.camera_memory[preview_buf_idx];//mPreviewHeap->mBuffers[frame->bufs[0]->buf_idx];
- } else {
- data = NULL;
- }
-
- if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA){
- msgType |= CAMERA_MSG_PREVIEW_METADATA;
- metadata = &mHalCamCtrl->mMetadata;
- } else {
- metadata = NULL;
- }
- if(mActive && msgType) {
- mHalCamCtrl->mDataCb(msgType, data, 0, metadata, mHalCamCtrl->mCallbackCookie);
- }
-
- if(MM_CAMERA_OK !=p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mNotifyBuffer[preview_buf_idx].bufs[0])) {
- ALOGE("BUF DONE FAILED");
- }
- mHalCamCtrl->cache_ops((QCameraHalMemInfo_t *)(mNotifyBuffer[preview_buf_idx].bufs[0]->mem_info),
- mNotifyBuffer[preview_buf_idx].bufs[0]->buffer,
- ION_IOC_INV_CACHES);
- ALOGD("end of cb");
- }
-
- return NO_ERROR;
-}
-
-status_t QCameraStream_preview::processPreviewFrame (
- mm_camera_super_buf_t *frame)
-{
- if (mHalCamCtrl->isNoDisplayMode()) {
- return processPreviewFrameWithOutDisplay(frame);
- } else {
- return processPreviewFrameWithDisplay(frame);
- }
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-QCameraStream_preview::QCameraStream_preview(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl)
- :QCameraStream(CameraHandle,
- ChannelId,
- Width,
- Height,
- Format,
- NumBuffers,
- mm_ops,
- imgmode,
- mode,
- camCtrl),
- mLastQueuedFrame(NULL),
- mNumFDRcvd(0)
- {
- }
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-QCameraStream_preview::~QCameraStream_preview() {
- ALOGV("%s: E", __func__);
- release();
- ALOGV("%s: X", __func__);
-
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-void QCameraStream_preview::release() {
- streamOff(0);
- deinitStream();
-}
-
-void *QCameraStream_preview::getLastQueuedFrame(void)
-{
- return mLastQueuedFrame;
-}
-
-int32_t QCameraStream_preview::setCrop()
-{
- int32_t rc = QCameraStream::setCrop();
- if (0 == rc) {
- if (!mHalCamCtrl->mSmoothZoomRunning && mHalCamCtrl->mPreviewWindow) {
- rc = mHalCamCtrl->mPreviewWindow->set_crop(
- mHalCamCtrl->mPreviewWindow,
- mCrop.offset_x,
- mCrop.offset_y,
- mCrop.offset_x + mCrop.width,
- mCrop.offset_y + mCrop.height);
- }
- }
- return rc;
-}
-
-int QCameraStream_preview::getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- int ret = 0;
- ALOGE("%s:BEGIN",__func__);
-
- if (num_bufs > mNumBuffers) {
- mNumBuffers = num_bufs;
- }
- if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
- ALOGE("%s: Invalid number of buffers (=%d) requested!",
- __func__, mNumBuffers);
- return BAD_VALUE;
- }
-
- memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
- if (mHalCamCtrl->isNoDisplayMode()) {
- ret = initPreviewOnlyBuffers();
- } else {
- ret = initDisplayBuffers();
- }
- ALOGD("Debug : %s : initDisplayBuffers",__func__);
- for(int i = 0; i < num_bufs; i++) {
- bufs[i] = mDisplayBuf[i];
- initial_reg_flag[i] = true;
- }
-
- ALOGV("%s: X - ret = %d ", __func__, ret);
- return ret;
-}
-
-int QCameraStream_preview::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
- int ret = 0;
- ALOGE(" %s : E ", __func__);
- if (mHalCamCtrl->isNoDisplayMode()) {
- ret = freeBufferNoDisplay();
- } else {
- ret = putBufferToSurface();
- }
- ALOGI(" %s : X ",__func__);
- return ret;
-}
-
-// ---------------------------------------------------------------------------
-// No code beyone this line
-// ---------------------------------------------------------------------------
-}; // namespace android
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Rdi.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Rdi.cpp
deleted file mode 100755
index cbbe988..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Rdi.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define LOG_TAG "QCameraHWI_Rdi"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-#include <gralloc_priv.h>
-#include <genlock.h>
-
-#define UNLIKELY(exp) __builtin_expect(!!(exp), 0)
-
-/* QCameraHWI_Raw class implementation goes here*/
-/* following code implement the RDI logic of this class*/
-
-namespace android {
-status_t QCameraStream_Rdi::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
- status_t ret = NO_ERROR;
-
- ALOGI(" %s : E ", __FUNCTION__);
- mNumBuffers = PREVIEW_BUFFER_COUNT;
- if(mHalCamCtrl->isZSLMode()) {
- if(mNumBuffers < mHalCamCtrl->getZSLQueueDepth() + 3) {
- mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
- }
- }
- ret = QCameraStream::initStream(no_cb_needed, stream_on);
-end:
- ALOGI(" %s : X ", __FUNCTION__);
- return ret;
-}
-
-int QCameraStream_Rdi::getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- int ret = 0;
- ALOGE("%s:BEGIN",__func__);
-
- if (num_bufs > mNumBuffers) {
- mNumBuffers = num_bufs;
- }
- if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
- ALOGE("%s: Invalid number of buffers (=%d) requested!",
- __func__, mNumBuffers);
- return BAD_VALUE;
- }
-
- memset(mRdiBuf, 0, sizeof(mRdiBuf));
- memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
- ret = mHalCamCtrl->initHeapMem(&mHalCamCtrl->mRdiMemory,
- mNumBuffers,
- mFrameOffsetInfo.frame_len,
- MSM_PMEM_MAINIMG,
- &mFrameOffsetInfo,
- mRdiBuf);
- if(MM_CAMERA_OK == ret) {
- for(int i = 0; i < num_bufs; i++) {
- bufs[i] = mRdiBuf[i];
- initial_reg_flag[i] = true;
- }
- }
-
- ALOGV("%s: X - ret = %d ", __func__, ret);
- return ret;
-}
-
-int QCameraStream_Rdi::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
- int ret = 0;
- ALOGE(" %s : E ", __FUNCTION__);
- ret = mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mRdiMemory);
- ALOGI(" %s : X ",__FUNCTION__);
- return ret;
-}
-
-void QCameraStream_Rdi::dumpFrameToFile(mm_camera_buf_def_t* newFrame)
-{
- char buf[32];
- int file_fd;
- int i;
- char *ext = "yuv";
- int w,h,main_422;
- static int count = 0;
- char *name = "rdi";
-
- w = mHalCamCtrl->mRdiWidth;
- h = mHalCamCtrl->mRdiHeight;
- main_422 = 1;
-
- if ( newFrame != NULL) {
- char * str;
- snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name,count,ext);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- if (file_fd < 0) {
- ALOGE("%s: cannot open file\n", __func__);
- } else {
- void* y_off = newFrame->buffer + newFrame->planes[0].data_offset;
- void* cbcr_off = newFrame->buffer + newFrame->planes[0].length;
-
- write(file_fd, (const void *)(y_off), newFrame->planes[0].length);
- write(file_fd, (const void *)(cbcr_off),
- (newFrame->planes[1].length * newFrame->num_planes));
- close(file_fd);
- }
- count++;
- }
-}
-
-status_t QCameraStream_Rdi::processRdiFrame(
- mm_camera_super_buf_t *frame)
-{
- ALOGE("%s",__func__);
- status_t err = NO_ERROR;
- int msgType = 0;
- camera_memory_t *data = NULL;
-
- if(!mActive) {
- ALOGE("RDI Streaming Stopped. Returning callback");
- return NO_ERROR;
- }
-
- if(mHalCamCtrl==NULL) {
- ALOGE("%s: X: HAL control object not set",__func__);
- /*Call buf done*/
- return BAD_VALUE;
- }
-
- mHalCamCtrl->dumpFrameToFile(frame->bufs[0], HAL_DUMP_FRM_RDI);
-
- if (mHalCamCtrl->mDataCb != NULL) {
- //Sending rdi callback if corresponding Msgs are enabled
- if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
- msgType |= CAMERA_MSG_PREVIEW_FRAME;
- data = mHalCamCtrl->mRdiMemory.camera_memory[frame->bufs[0]->buf_idx];
- } else {
- data = NULL;
- }
-
- ALOGD("Message enabled = 0x%x", msgType);
- if(mActive && msgType) {
- mHalCamCtrl->mDataCb(msgType, data, 0, NULL, mHalCamCtrl->mCallbackCookie);
- }
- ALOGD("end of cb");
- }
- if (MM_CAMERA_OK != p_mm_ops->ops->qbuf(mCameraHandle, mChannelId,
- frame->bufs[0])) {
- ALOGE("%s: Failed in Preview Qbuf\n", __func__);
- err = BAD_VALUE;
- }
- mHalCamCtrl->cache_ops((QCameraHalMemInfo_t *)(frame->bufs[0]->mem_info),
- frame->bufs[0]->buffer,
- ION_IOC_INV_CACHES);
-
- return err;
-}
-
-
-// ---------------------------------------------------------------------------
-// QCameraStream_Rdi
-// ---------------------------------------------------------------------------
-
-QCameraStream_Rdi::
-QCameraStream_Rdi(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl)
- : QCameraStream(CameraHandle,
- ChannelId,
- Width,
- Height,
- Format,
- NumBuffers,
- mm_ops,
- imgmode,
- mode,
- camCtrl)
-{
- ALOGE("%s: E", __func__);
- ALOGE("%s: X", __func__);
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_Rdi
-// ---------------------------------------------------------------------------
-
-QCameraStream_Rdi::~QCameraStream_Rdi() {
- ALOGV("%s: E", __func__);
- release();
- ALOGV("%s: X", __func__);
-
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_Rdi
-// ---------------------------------------------------------------------------
- void QCameraStream_Rdi::release() {
-
- ALOGE("%s : BEGIN",__func__);
- streamOff(0);
- deinitStream();
- ALOGE("%s: END", __func__);
- }
-
-// ---------------------------------------------------------------------------
-// No code beyone this line
-// ---------------------------------------------------------------------------
-}; // namespace android
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Record.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Record.cpp
deleted file mode 100755
index 73d26d1..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Record.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHWI_Record"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraStream.h"
-
-
-#define LIKELY(exp) __builtin_expect(!!(exp), 1)
-#define UNLIKELY(exp) __builtin_expect(!!(exp), 0)
-
-/* QCameraStream_record class implementation goes here*/
-/* following code implement the video streaming capture & encoding logic of this class*/
-// ---------------------------------------------------------------------------
-// QCameraStream_record createInstance()
-// ---------------------------------------------------------------------------
-namespace android {
-
-
-// ---------------------------------------------------------------------------
-// QCameraStream_record Constructor
-// ---------------------------------------------------------------------------
-QCameraStream_record::QCameraStream_record(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl)
-// : QCameraStream(cameraId,mode),
- :QCameraStream(CameraHandle,
- ChannelId,
- Width,
- Height,
- Format,
- NumBuffers,
- mm_ops,
- imgmode,
- mode,
- camCtrl),
- mDebugFps(false)
-{
- char value[PROPERTY_VALUE_MAX];
- ALOGV("%s: BEGIN", __func__);
-
- property_get("persist.debug.sf.showfps", value, "0");
- mDebugFps = atoi(value);
-
- ALOGV("%s: END", __func__);
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_record Destructor
-// ---------------------------------------------------------------------------
-QCameraStream_record::~QCameraStream_record() {
- ALOGV("%s: BEGIN", __func__);
- release();
- ALOGV("%s: END", __func__);
-}
-
-int QCameraStream_record::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
- for(int cnt = 0; cnt < mHalCamCtrl->mRecordingMemory.buffer_count; cnt++) {
- if (mHalCamCtrl->mStoreMetaDataInFrame) {
- struct encoder_media_buffer_type * packet =
- (struct encoder_media_buffer_type *)mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->data;
- native_handle_delete(const_cast<native_handle_t *>(packet->meta_handle));
- mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->release(
- mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]);
- }
- mHalCamCtrl->mRecordingMemory.camera_memory[cnt]->release(
- mHalCamCtrl->mRecordingMemory.camera_memory[cnt]);
-
-#ifdef USE_ION
- mHalCamCtrl->deallocate_ion_memory(&mHalCamCtrl->mRecordingMemory.mem_info[cnt]);
-#endif
- }
- memset(&mHalCamCtrl->mRecordingMemory, 0, sizeof(mHalCamCtrl->mRecordingMemory));
- return NO_ERROR;
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_record
-// ---------------------------------------------------------------------------
-void QCameraStream_record::release()
-{
- ALOGV("%s: BEGIN", __func__);
- streamOff(0);
- deinitStream();
- ALOGV("%s: END", __func__);
-}
-
-status_t QCameraStream_record::processRecordFrame(mm_camera_super_buf_t *frame)
-{
- ALOGV("%s : BEGIN",__func__);
- int video_buf_idx = frame->bufs[0]->buf_idx;
-
- if(!mActive) {
- ALOGE("Recording Stopped. Returning callback");
- return NO_ERROR;
- }
-
- if (UNLIKELY(mDebugFps)) {
- debugShowVideoFPS();
- }
- ALOGE("DEBUG4:%d",frame->bufs[0]->stream_id);
- ALOGE("<DEBUG4>: Timestamp: %ld %ld",frame->bufs[0]->ts.tv_sec,frame->bufs[0]->ts.tv_nsec);
- mHalCamCtrl->dumpFrameToFile(frame->bufs[0], HAL_DUMP_FRM_VIDEO);
- camera_data_timestamp_callback rcb = mHalCamCtrl->mDataCbTimestamp;
- void *rdata = mHalCamCtrl->mCallbackCookie;
- nsecs_t timeStamp = nsecs_t(frame->bufs[0]->ts.tv_sec)*1000000000LL + \
- frame->bufs[0]->ts.tv_nsec;
-
- ALOGE("Send Video frame to services/encoder TimeStamp : %lld",timeStamp);
- mRecordedFrames[video_buf_idx] = *frame;
-
- mHalCamCtrl->cache_ops(&mHalCamCtrl->mRecordingMemory.mem_info[video_buf_idx],
- (void *)mHalCamCtrl->mRecordingMemory.camera_memory[video_buf_idx]->data,
- ION_IOC_CLEAN_CACHES);
-
- if (mHalCamCtrl->mStoreMetaDataInFrame) {
- if((rcb != NULL) && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) {
- ALOGE("Calling video callback:%d", video_buf_idx);
- rcb(timeStamp, CAMERA_MSG_VIDEO_FRAME,
- mHalCamCtrl->mRecordingMemory.metadata_memory[video_buf_idx],
- 0, mHalCamCtrl->mCallbackCookie);
- }
- } else {
- if((rcb != NULL) && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) {
- ALOGE("Calling video callback2");
- rcb(timeStamp, CAMERA_MSG_VIDEO_FRAME,
- mHalCamCtrl->mRecordingMemory.camera_memory[video_buf_idx],
- 0, mHalCamCtrl->mCallbackCookie);
- }
- }
-
- ALOGV("%s : END",__func__);
- return NO_ERROR;
-}
-
-//Record Related Functions
-status_t QCameraStream_record::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
- status_t ret = NO_ERROR;
-
- ALOGI(" %s : E ", __FUNCTION__);
- mNumBuffers = VIDEO_BUFFER_COUNT;
- if(mHalCamCtrl->isLowPowerCamcorder()) {
- ALOGE("%s: lower power camcorder selected", __func__);
- mNumBuffers = VIDEO_BUFFER_COUNT_LOW_POWER_CAMCORDER;
- }
- ret = QCameraStream::initStream(no_cb_needed, stream_on);
-end:
- ALOGI(" %s : X ", __FUNCTION__);
- return ret;
-}
-
-status_t QCameraStream_record::getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- ALOGE("%s : BEGIN",__func__);
-
- if (num_bufs > mNumBuffers) {
- mNumBuffers = num_bufs;
- }
- if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
- ALOGE("%s: Invalid number of buffers (=%d) requested!",
- __func__, mNumBuffers);
- return BAD_VALUE;
- }
-
- memset(mRecordBuf, 0, sizeof(mRecordBuf));
- memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
- if (mHalCamCtrl->initHeapMem(&mHalCamCtrl->mRecordingMemory,
- mNumBuffers,
- mFrameOffsetInfo.frame_len,
- MSM_PMEM_VIDEO,
- &mFrameOffsetInfo,
- mRecordBuf) < 0) {
- ALOGE("%s: Error getting heap mem for recording", __func__);
- return NO_MEMORY;
- }
-
- if (mHalCamCtrl->mStoreMetaDataInFrame) {
- for (int cnt = 0; cnt < mNumBuffers; cnt++) {
- mHalCamCtrl->mRecordingMemory.metadata_memory[cnt] =
- mHalCamCtrl->mGetMemory(-1,
- sizeof(struct encoder_media_buffer_type),
- 1,
- (void *)this);
- struct encoder_media_buffer_type * packet =
- (struct encoder_media_buffer_type *)mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->data;
- packet->meta_handle = native_handle_create(1, 2); //1 fd, 1 offset and 1 size
- packet->buffer_type = kMetadataBufferTypeCameraSource;
- native_handle_t * nh = const_cast<native_handle_t *>(packet->meta_handle);
- nh->data[0] = mHalCamCtrl->mRecordingMemory.mem_info[cnt].fd;
- nh->data[1] = 0;
- nh->data[2] = mHalCamCtrl->mRecordingMemory.mem_info[cnt].size;
- }
- }
-
- for(int i = 0; i < num_bufs; i++) {
- bufs[i] = mRecordBuf[i];
- initial_reg_flag[i] = true;
- }
-
- ALOGE("%s : END",__func__);
- return NO_ERROR;
-}
-
-void QCameraStream_record::releaseRecordingFrame(const void *opaque)
-{
- ALOGV("%s : BEGIN, opaque = 0x%p",__func__, opaque);
- if(!mActive)
- {
- ALOGE("%s : Recording already stopped!!! Leak???",__func__);
- return;
- }
- for(int cnt = 0; cnt < mHalCamCtrl->mRecordingMemory.buffer_count; cnt++) {
- if (mHalCamCtrl->mStoreMetaDataInFrame) {
- if(mHalCamCtrl->mRecordingMemory.metadata_memory[cnt] &&
- mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->data == opaque) {
- /* found the match */
- ALOGE("Releasing video frames:%d",cnt);
- if(MM_CAMERA_OK != p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mRecordedFrames[cnt].bufs[0]))
- ALOGE("%s : Buf Done Failed",__func__);
- mHalCamCtrl->cache_ops(&mHalCamCtrl->mRecordingMemory.mem_info[cnt],
- (void *)mRecordedFrames[cnt].bufs[0]->buffer,
- ION_IOC_INV_CACHES);
- ALOGV("%s : END",__func__);
- return;
- }
- } else {
- if(mHalCamCtrl->mRecordingMemory.camera_memory[cnt] &&
- mHalCamCtrl->mRecordingMemory.camera_memory[cnt]->data == opaque) {
- /* found the match */
- ALOGE("Releasing video frames2");
- if(MM_CAMERA_OK != p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mRecordedFrames[cnt].bufs[0]))
- ALOGE("%s : Buf Done Failed",__func__);
- mHalCamCtrl->cache_ops(&mHalCamCtrl->mRecordingMemory.mem_info[cnt],
- (void *)mRecordedFrames[cnt].bufs[0]->buffer,
- ION_IOC_INV_CACHES);
- ALOGV("%s : END",__func__);
- return;
- }
- }
- }
- ALOGE("%s: cannot find the matched frame with opaue = 0x%p", __func__, opaque);
-}
-
-void QCameraStream_record::debugShowVideoFPS() const
-{
- static int mFrameCount;
- static int mLastFrameCount = 0;
- static nsecs_t mLastFpsTime = 0;
- static float mFps = 0;
- mFrameCount++;
- nsecs_t now = systemTime();
- nsecs_t diff = now - mLastFpsTime;
- if (diff > ms2ns(250)) {
- mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
- ALOGI("Video Frames Per Second: %.4f", mFps);
- mLastFpsTime = now;
- mLastFrameCount = mFrameCount;
- }
-}
-
-}//namespace android
-
diff --git a/camera/QCamera/HAL/core/src/QCameraHWI_Still.cpp b/camera/QCamera/HAL/core/src/QCameraHWI_Still.cpp
deleted file mode 100755
index 091de43..0000000
--- a/camera/QCamera/HAL/core/src/QCameraHWI_Still.cpp
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define LOG_NDEBUG 0
-#define LOG_NDDEBUG 0
-#define LOG_NIDEBUG 0
-#define LOG_TAG "QCameraHWI_Still"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <media/mediarecorder.h>
-#include <math.h>
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-#include "mm_jpeg_interface.h"
-
-
-/* following code implement the still image capture & encoding logic of this class*/
-namespace android {
-
-QCameraStream_SnapshotMain::
-QCameraStream_SnapshotMain(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl)
- :QCameraStream(CameraHandle,
- ChannelId,
- Width,
- Height,
- Format,
- NumBuffers,
- mm_ops,
- imgmode,
- mode,
- camCtrl)
-{
-}
-
-QCameraStream_SnapshotMain::~QCameraStream_SnapshotMain()
-{
- release();
-}
-
-void QCameraStream_SnapshotMain::release()
-{
- streamOff(0);
- deinitStream();
-
-}
-
-status_t QCameraStream_SnapshotMain::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
- status_t ret = NO_ERROR;
-
- if(mHalCamCtrl->isZSLMode()) {
- mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
- } else if (mHalCamCtrl->mHdrInfo.hdr_on) {
- mNumBuffers = mHalCamCtrl->mHdrInfo.num_frame;
- } else {
- mNumBuffers = mHalCamCtrl->getNumOfSnapshots();
- }
- ret = QCameraStream::initStream(no_cb_needed, stream_on);
- return ret;;
-}
-
-int QCameraStream_SnapshotMain::getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- int ret = MM_CAMERA_OK;
- ALOGE("%s : E", __func__);
-
- if (mNumBuffers < num_bufs) {
- mNumBuffers = num_bufs;
- }
- if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
- ALOGE("%s: Invalid number of buffers (=%d) requested!",
- __func__, mNumBuffers);
- return BAD_VALUE;
- }
-
- memset(mSnapshotStreamBuf, 0, sizeof(mSnapshotStreamBuf));
- memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
- ret = mHalCamCtrl->initHeapMem(&mHalCamCtrl->mSnapshotMemory,
- mNumBuffers,
- mFrameOffsetInfo.frame_len,
- MSM_PMEM_MAINIMG,
- &mFrameOffsetInfo,
- mSnapshotStreamBuf);
-
- if(MM_CAMERA_OK == ret) {
- for(int i = 0; i < num_bufs; i++) {
- bufs[i] = mSnapshotStreamBuf[i];
- initial_reg_flag[i] = (TRUE == m_flag_stream_on)? TRUE : FALSE;
- }
- }
-
- /* If we have reached here successfully, we have allocated buffer.
- Set state machine.*/
- ALOGD("%s: X", __func__);
- return ret;
-
-}
-
-int QCameraStream_SnapshotMain::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
- ALOGE("%s: Release Snapshot main Memory",__func__);
- return mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mSnapshotMemory);
-}
-
-int QCameraStream_SnapshotThumbnail::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
-{
- ALOGE("%s: Release Snapshot thumbnail Memory",__func__);
- return mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mThumbnailMemory);
-}
-
-QCameraStream_SnapshotThumbnail::
-QCameraStream_SnapshotThumbnail(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl)
- :QCameraStream(CameraHandle,
- ChannelId,
- Width,
- Height,
- Format,
- NumBuffers,
- mm_ops,
- imgmode,
- mode,
- camCtrl)
-{
-
-}
-
-QCameraStream_SnapshotThumbnail::~QCameraStream_SnapshotThumbnail()
-{
- release();
-}
-
-void QCameraStream_SnapshotThumbnail::release()
-{
- streamOff(0);
- deinitStream();
-}
-
-status_t QCameraStream_SnapshotThumbnail::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
- status_t ret = NO_ERROR;
-
- if(mHalCamCtrl->isZSLMode()) {
- mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
- } else if (mHalCamCtrl->mHdrInfo.hdr_on) {
- mNumBuffers = mHalCamCtrl->mHdrInfo.num_frame;
- } else {
- mNumBuffers = mHalCamCtrl->getNumOfSnapshots();
- }
- ret = QCameraStream::initStream(no_cb_needed, stream_on);
- return ret;;
-}
-
-status_t QCameraStream_SnapshotThumbnail::getBuf(mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- int ret = MM_CAMERA_OK;
-
- if (mNumBuffers < num_bufs) {
- mNumBuffers = num_bufs;
- }
- if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
- ALOGE("%s: Invalid number of buffers (=%d) requested!",
- __func__, mNumBuffers);
- return BAD_VALUE;
- }
-
- memset(mPostviewStreamBuf, 0, sizeof(mPostviewStreamBuf));
- memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
- ret = mHalCamCtrl->initHeapMem(
- &mHalCamCtrl->mThumbnailMemory,
- mNumBuffers,
- mFrameOffsetInfo.frame_len,
- MSM_PMEM_THUMBNAIL,
- &mFrameOffsetInfo,
- mPostviewStreamBuf);
- if(MM_CAMERA_OK == ret) {
- for(int i = 0; i < num_bufs; i++) {
- bufs[i] = mPostviewStreamBuf[i];
- initial_reg_flag[i] = true;
- }
- }
-
- return ret;
-}
-
-
-}; // namespace android
-
diff --git a/camera/QCamera/HAL/core/src/QCameraParameters.cpp b/camera/QCamera/HAL/core/src/QCameraParameters.cpp
deleted file mode 100755
index db253fa..0000000
--- a/camera/QCamera/HAL/core/src/QCameraParameters.cpp
+++ /dev/null
@@ -1,408 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-
-#define LOG_TAG "QCameraParams"
-#include <utils/Log.h>
-#include <string.h>
-#include <stdlib.h>
-#include <camera/QCameraParameters.h>
-
-namespace android {
-// Parameter keys to communicate between camera application and driver.
-const char QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES[] = "hfr-size-values";
-const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_MODE[] = "preview-frame-rate-mode";
-const char QCameraParameters::KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[] = "preview-frame-rate-modes";
-const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[] = "frame-rate-auto";
-const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[] = "frame-rate-fixed";
-const char QCameraParameters::KEY_QC_TOUCH_AF_AEC[] = "touch-af-aec";
-const char QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC[] = "touch-af-aec-values";
-const char QCameraParameters::KEY_QC_TOUCH_INDEX_AEC[] = "touch-index-aec";
-const char QCameraParameters::KEY_QC_TOUCH_INDEX_AF[] = "touch-index-af";
-const char QCameraParameters::KEY_QC_SCENE_DETECT[] = "scene-detect";
-const char QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT[] = "scene-detect-values";
-const char QCameraParameters::KEY_QC_ISO_MODE[] = "iso";
-const char QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES[] = "iso-values";
-const char QCameraParameters::KEY_QC_LENSSHADE[] = "lensshade";
-const char QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES[] = "lensshade-values";
-const char QCameraParameters::KEY_QC_AUTO_EXPOSURE[] = "auto-exposure";
-const char QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE[] = "auto-exposure-values";
-const char QCameraParameters::KEY_QC_DENOISE[] = "denoise";
-const char QCameraParameters::KEY_QC_SUPPORTED_DENOISE[] = "denoise-values";
-const char QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF[] = "selectable-zone-af";
-const char QCameraParameters::KEY_QC_SUPPORTED_SELECTABLE_ZONE_AF[] = "selectable-zone-af-values";
-const char QCameraParameters::KEY_QC_FACE_DETECTION[] = "face-detection";
-const char QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION[] = "face-detection-values";
-const char QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT[] = "mce";
-const char QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[] = "mce-values";
-const char QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE[] = "video-hfr";
-const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[] = "video-hfr-values";
-const char QCameraParameters::KEY_QC_REDEYE_REDUCTION[] = "redeye-reduction";
-const char QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION[] = "redeye-reduction-values";
-const char QCameraParameters::KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[] = "hdr";
-const char QCameraParameters::KEY_QC_SUPPORTED_HDR_IMAGING_MODES[] = "hdr-values";
-const char QCameraParameters::KEY_QC_POWER_MODE_SUPPORTED[] = "power-mode-supported";
-const char QCameraParameters::KEY_QC_ZSL[] = "zsl";
-const char QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES[] = "zsl-values";
-const char QCameraParameters::KEY_QC_CAMERA_MODE[] = "camera-mode";
-const char QCameraParameters::KEY_QC_AE_BRACKET_HDR[] = "ae-bracket-hdr";
-const char QCameraParameters::KEY_QC_POWER_MODE[] = "power-mode";
-/*only effective when KEY_QC_AE_BRACKET_HDR set to ae_bracketing*/
-//const char QCameraParameters::KEY_QC_AE_BRACKET_SETTING_KEY[] = "ae-bracket-setting";
-
-// Values for effect settings.
-const char QCameraParameters::EFFECT_EMBOSS[] = "emboss";
-const char QCameraParameters::EFFECT_SKETCH[] = "sketch";
-const char QCameraParameters::EFFECT_NEON[] = "neon";
-
-// Values for auto exposure settings.
-const char QCameraParameters::TOUCH_AF_AEC_OFF[] = "touch-off";
-const char QCameraParameters::TOUCH_AF_AEC_ON[] = "touch-on";
-
-// Values for scene mode settings.
-const char QCameraParameters::SCENE_MODE_ASD[] = "asd"; // corresponds to CAMERA_BESTSHOT_AUTO in HAL
-const char QCameraParameters::SCENE_MODE_BACKLIGHT[] = "backlight";
-const char QCameraParameters::SCENE_MODE_FLOWERS[] = "flowers";
-const char QCameraParameters::SCENE_MODE_AR[] = "AR";
-
-// Values for auto scene detection settings.
-const char QCameraParameters::SCENE_DETECT_OFF[] = "off";
-const char QCameraParameters::SCENE_DETECT_ON[] = "on";
-
-// Formats for setPreviewFormat and setPictureFormat.
-const char QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO[] = "yuv420sp-adreno";
-const char QCameraParameters::PIXEL_FORMAT_RAW[] = "raw";
-const char QCameraParameters::PIXEL_FORMAT_YV12[] = "yuv420p";
-const char QCameraParameters::PIXEL_FORMAT_NV12[] = "nv12";
-
-// Values for focus mode settings.
-const char QCameraParameters::FOCUS_MODE_NORMAL[] = "normal";
-const char QCameraParameters::KEY_QC_SKIN_TONE_ENHANCEMENT[] = "skinToneEnhancement";
-const char QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] = "skinToneEnhancement-values";
-
-// Values for ISO Settings
-const char QCameraParameters::ISO_AUTO[] = "auto";
-const char QCameraParameters::ISO_HJR[] = "ISO_HJR";
-const char QCameraParameters::ISO_100[] = "ISO100";
-const char QCameraParameters::ISO_200[] = "ISO200";
-const char QCameraParameters::ISO_400[] = "ISO400";
-const char QCameraParameters::ISO_800[] = "ISO800";
-const char QCameraParameters::ISO_1600[] = "ISO1600";
-
- //Values for Lens Shading
-const char QCameraParameters::LENSSHADE_ENABLE[] = "enable";
-const char QCameraParameters::LENSSHADE_DISABLE[] = "disable";
-
-// Values for auto exposure settings.
-const char QCameraParameters::AUTO_EXPOSURE_FRAME_AVG[] = "frame-average";
-const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED[] = "center-weighted";
-const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING[] = "spot-metering";
-
-const char QCameraParameters::KEY_QC_GPS_LATITUDE_REF[] = "gps-latitude-ref";
-const char QCameraParameters::KEY_QC_GPS_LONGITUDE_REF[] = "gps-longitude-ref";
-const char QCameraParameters::KEY_QC_GPS_ALTITUDE_REF[] = "gps-altitude-ref";
-const char QCameraParameters::KEY_QC_GPS_STATUS[] = "gps-status";
-const char QCameraParameters::KEY_QC_EXIF_DATETIME[] = "exif-datetime";
-
-const char QCameraParameters::KEY_QC_HISTOGRAM[] = "histogram";
-const char QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES[] = "histogram-values";
-
-//Values for Histogram Shading
-const char QCameraParameters::HISTOGRAM_ENABLE[] = "enable";
-const char QCameraParameters::HISTOGRAM_DISABLE[] = "disable";
-
-//Values for Skin Tone Enhancement Modes
-const char QCameraParameters::SKIN_TONE_ENHANCEMENT_ENABLE[] = "enable";
-const char QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE[] = "disable";
-
-const char QCameraParameters::KEY_QC_SHARPNESS[] = "sharpness";
-const char QCameraParameters::KEY_QC_MAX_SHARPNESS[] = "max-sharpness";
-const char QCameraParameters::KEY_QC_CONTRAST[] = "contrast";
-const char QCameraParameters::KEY_QC_MAX_CONTRAST[] = "max-contrast";
-const char QCameraParameters::KEY_QC_SATURATION[] = "saturation";
-const char QCameraParameters::KEY_QC_MAX_SATURATION[] = "max-saturation";
-
-const char QCameraParameters::KEY_QC_SINGLE_ISP_OUTPUT_ENABLED[] = "single-isp-output-enabled";
-const char QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES[] = "qc-camera-features";
-const char QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES[] = "qc-max-num-requested-faces";
-
-//Values for DENOISE
-const char QCameraParameters::DENOISE_OFF[] = "denoise-off";
-const char QCameraParameters::DENOISE_ON[] = "denoise-on";
-
-// Values for selectable zone af Settings
-const char QCameraParameters::SELECTABLE_ZONE_AF_AUTO[] = "auto";
-const char QCameraParameters::SELECTABLE_ZONE_AF_SPOT_METERING[] = "spot-metering";
-const char QCameraParameters::SELECTABLE_ZONE_AF_CENTER_WEIGHTED[] = "center-weighted";
-const char QCameraParameters::SELECTABLE_ZONE_AF_FRAME_AVERAGE[] = "frame-average";
-
-// Values for Face Detection settings.
-const char QCameraParameters::FACE_DETECTION_OFF[] = "off";
-const char QCameraParameters::FACE_DETECTION_ON[] = "on";
-
-// Values for MCE settings.
-const char QCameraParameters::MCE_ENABLE[] = "enable";
-const char QCameraParameters::MCE_DISABLE[] = "disable";
-
-// Values for HFR settings.
-const char QCameraParameters::VIDEO_HFR_OFF[] = "off";
-const char QCameraParameters::VIDEO_HFR_2X[] = "60";
-const char QCameraParameters::VIDEO_HFR_3X[] = "90";
-const char QCameraParameters::VIDEO_HFR_4X[] = "120";
-
-// Values for Redeye Reduction settings.
-const char QCameraParameters::REDEYE_REDUCTION_ENABLE[] = "enable";
-const char QCameraParameters::REDEYE_REDUCTION_DISABLE[] = "disable";
-
-// Values for HDR settings.
-const char QCameraParameters::HDR_ENABLE[] = "enable";
-const char QCameraParameters::HDR_DISABLE[] = "disable";
-
-// Values for ZSL settings.
-const char QCameraParameters::ZSL_OFF[] = "off";
-const char QCameraParameters::ZSL_ON[] = "on";
-
-// Values for HDR Bracketing settings.
-const char QCameraParameters::AE_BRACKET_HDR_OFF[] = "Off";
-const char QCameraParameters::AE_BRACKET_HDR[] = "HDR";
-const char QCameraParameters::AE_BRACKET[] = "AE-Bracket";
-
-const char QCameraParameters::LOW_POWER[] = "Low_Power";
-const char QCameraParameters::NORMAL_POWER[] = "Normal_Power";
-
-static const char* portrait = "portrait";
-static const char* landscape = "landscape";
-
-//QCameraParameters::QCameraParameters()
-// : mMap()
-//{
-//}
-
-QCameraParameters::~QCameraParameters()
-{
-}
-
-int QCameraParameters::getOrientation() const
-{
- const char* orientation = get("orientation");
- if (orientation && !strcmp(orientation, portrait))
- return CAMERA_ORIENTATION_PORTRAIT;
- return CAMERA_ORIENTATION_LANDSCAPE;
-}
-void QCameraParameters::setOrientation(int orientation)
-{
- if (orientation == CAMERA_ORIENTATION_PORTRAIT) {
- set("orientation", portrait);
- } else {
- set("orientation", landscape);
- }
-}
-
- //XXX ALOGE("Key \"%s\"contains invalid character (= or ;)", key);
- //XXX ALOGE("Value \"%s\"contains invalid character (= or ;)", value);
- //snprintf(str, sizeof(str), "%d", value);
- //ALOGE("Cannot find delimeter (%c) in str=%s", delim, str);
-
-
-// Parse string like "(1, 2, 3, 4, ..., N)"
-// num is pointer to an allocated array of size N
-static int parseNDimVector(const char *str, int *num, int N, char delim = ',')
-{
- char *start, *end;
- if(num == NULL) {
- ALOGE("Invalid output array (num == NULL)");
- return -1;
- }
- //check if string starts and ends with parantheses
- if(str[0] != '(' || str[strlen(str)-1] != ')') {
- ALOGE("Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", str);
- return -1;
- }
- start = (char*) str;
- start++;
- for(int i=0; i<N; i++) {
- *(num+i) = (int) strtol(start, &end, 10);
- if(*end != delim && i < N-1) {
- ALOGE("Cannot find delimeter '%c' in string \"%s\". end = %c", delim, str, *end);
- return -1;
- }
- start = end+1;
- }
- return 0;
-}
-
-
- //ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
- //snprintf(str, sizeof(str), "%dx%d", width, height);
-
-
-
-// Parse string like "640x480" or "10000,20000"
-static int parse_pair(const char *str, int *first, int *second, char delim,
- char **endptr = NULL)
-{
- // Find the first integer.
- char *end;
- int w = (int)strtol(str, &end, 10);
- // If a delimeter does not immediately follow, give up.
- if (*end != delim) {
- ALOGE("Cannot find delimeter (%c) in str=%s", delim, str);
- return -1;
- }
-
- // Find the second integer, immediately after the delimeter.
- int h = (int)strtol(end+1, &end, 10);
-
- *first = w;
- *second = h;
-
- if (endptr) {
- *endptr = end;
- }
-
- return 0;
-}
-
-static void parseSizesList(const char *sizesStr, Vector<Size> &sizes)
-{
- if (sizesStr == 0) {
- return;
- }
-
- char *sizeStartPtr = (char *)sizesStr;
-
- while (true) {
- int width, height;
- int success = parse_pair(sizeStartPtr, &width, &height, 'x',
- &sizeStartPtr);
- if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) {
- ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
- return;
- }
- sizes.push(Size(width, height));
-
- if (*sizeStartPtr == '\0') {
- return;
- }
- sizeStartPtr++;
- }
-}
-
-
-void QCameraParameters::getSupportedHfrSizes(Vector<Size> &sizes) const
-{
- const char *hfrSizesStr = get(KEY_QC_SUPPORTED_HFR_SIZES);
- parseSizesList(hfrSizesStr, sizes);
-}
-
-void QCameraParameters::setPreviewFpsRange(int minFPS, int maxFPS)
-{
- char str[32];
- snprintf(str, sizeof(str), "%d,%d",minFPS,maxFPS);
- set(KEY_PREVIEW_FPS_RANGE,str);
-}
-
-void QCameraParameters::setPreviewFrameRateMode(const char *mode)
-{
- set(KEY_QC_PREVIEW_FRAME_RATE_MODE, mode);
-}
-
-const char *QCameraParameters::getPreviewFrameRateMode() const
-{
- return get(KEY_QC_PREVIEW_FRAME_RATE_MODE);
-}
-
- //ALOGD("dump: mMap.size = %d", mMap.size());
- //ALOGD("%s: %s\n", k.string(), v.string());
-void QCameraParameters::setTouchIndexAec(int x, int y)
-{
- char str[32];
- snprintf(str, sizeof(str), "%dx%d", x, y);
- set(KEY_QC_TOUCH_INDEX_AEC, str);
-}
-
-void QCameraParameters::getTouchIndexAec(int *x, int *y) const
-{
- *x = -1;
- *y = -1;
-
- // Get the current string, if it doesn't exist, leave the -1x-1
- const char *p = get(KEY_QC_TOUCH_INDEX_AEC);
- if (p == 0)
- return;
-
- int tempX, tempY;
- if (parse_pair(p, &tempX, &tempY, 'x') == 0) {
- *x = tempX;
- *y = tempY;
- }
-}
-
-void QCameraParameters::setTouchIndexAf(int x, int y)
-{
- char str[32];
- snprintf(str, sizeof(str), "%dx%d", x, y);
- set(KEY_QC_TOUCH_INDEX_AF, str);
-}
-
-void QCameraParameters::getTouchIndexAf(int *x, int *y) const
-{
- *x = -1;
- *y = -1;
-
- // Get the current string, if it doesn't exist, leave the -1x-1
- const char *p = get(KEY_QC_TOUCH_INDEX_AF);
- if (p == 0)
- return;
-
- int tempX, tempY;
- if (parse_pair(p, &tempX, &tempY, 'x') == 0) {
- *x = tempX;
- *y = tempY;
- }
-}
-
-void QCameraParameters::getMeteringAreaCenter(int *x, int *y) const
-{
- //Default invalid values
- *x = -2000;
- *y = -2000;
-
- const char *p = get(KEY_METERING_AREAS);
- if(p != NULL) {
- int arr[5] = {-2000, -2000, -2000, -2000, 0};
- parseNDimVector(p, arr, 5); //p = "(x1, y1, x2, y2, weight)"
- *x = (arr[0] + arr[2])/2; //center_x = (x1+x2)/2
- *y = (arr[1] + arr[3])/2; //center_y = (y1+y2)/2
- }
-}
-
-
-}; // namespace android
-
diff --git a/camera/QCamera/HAL/core/src/QCameraStream.cpp b/camera/QCamera/HAL/core/src/QCameraStream.cpp
deleted file mode 100755
index 297af3a..0000000
--- a/camera/QCamera/HAL/core/src/QCameraStream.cpp
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
-** Copyright (c) 2012 The Linux Foundation. All rights reserved.
-**
-** Not a Contribution, Apache license notifications and license are retained
-** for attribution purposes only.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG __FILE__
-#include <utils/Log.h>
-
-#include "QCameraHWI.h"
-#include "QCameraStream.h"
-
-/* QCameraStream class implementation goes here*/
-/* following code implement the control logic of this class*/
-
-namespace android {
-
-// ---------------------------------------------------------------------------
-// QCameraStream
-// ---------------------------------------------------------------------------
-
-void stream_cb_routine(mm_camera_super_buf_t *bufs,
- void *userdata)
-{
- ALOGD("%s E ", __func__);
- QCameraStream *p_obj=(QCameraStream*) userdata;
- ALOGD("DEBUG4:ExtMode:%d,streamid:%d",p_obj->mExtImgMode,bufs->bufs[0]->stream_id);
- switch(p_obj->mExtImgMode)
- {
- case MM_CAMERA_PREVIEW:
- ALOGD("%s : callback for MM_CAMERA_PREVIEW", __func__);
- ((QCameraStream_preview *)p_obj)->processPreviewFrame(bufs);
- break;
- case MM_CAMERA_VIDEO:
- ((QCameraStream_record *)p_obj)->processRecordFrame(bufs);
- break;
- case MM_CAMERA_RDI:
- ((QCameraStream_Rdi *)p_obj)->processRdiFrame(bufs);
- break;
- case MM_CAMERA_SNAPSHOT_MAIN:
- break;
- case MM_CAMERA_SNAPSHOT_THUMBNAIL:
- break;
- default:
- break;
-
- }
- ALOGD("%s X ", __func__);
-}
-
-void QCameraStream::dataCallback(mm_camera_super_buf_t *bufs)
-{
-}
-
-
-void QCameraStream::setResolution(mm_camera_dimension_t *res)
-{
- mWidth = res->width;
- mHeight = res->height;
-}
-bool QCameraStream::isResolutionSame(mm_camera_dimension_t *res)
-{
- if (mWidth != res->width || mHeight != res->height)
- return false;
- else
- return true;
-}
-void QCameraStream::getResolution(mm_camera_dimension_t *res)
-{
- res->width = mWidth;
- res->height = mHeight;
-}
-int32_t QCameraStream::streamOn()
-{
- status_t rc = NO_ERROR;
- ALOGD("%s: mActive = %d, streamid = %d, image_mode = %d",__func__, mActive, mStreamId, mExtImgMode);
- if(mActive){
- ALOGE("%s: Stream:%d is already active",
- __func__,mStreamId);
- return rc;
- }
-
- if (mInit == true) {
- /* this is the restart case, for now we need config again */
- rc = setFormat();
- ALOGD("%s: config_stream, rc = %d", __func__, rc);
- }
- rc = p_mm_ops->ops->start_streams(mCameraHandle,
- mChannelId,
- 1,
- &mStreamId);
- if(rc == NO_ERROR) {
- mActive = true;
- }
- ALOGD("%s: X, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
- __func__, mActive, mInit, mStreamId, mExtImgMode);
- return rc;
-}
-
-int32_t QCameraStream::streamOff(bool isAsyncCmd)
-{
- status_t rc = NO_ERROR;
- ALOGD("%s: mActive = %d, streamid = %d, image_mode = %d",__func__, mActive, mStreamId, mExtImgMode);
- if(!mActive) {
- ALOGE("%s: Stream:%d is not active",
- __func__,mStreamId);
- return rc;
- }
- mActive = false;
-
- rc = p_mm_ops->ops->stop_streams(mCameraHandle,
- mChannelId,
- 1,
- &mStreamId);
-
- ALOGD("%s: X, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
- __func__, mActive, mInit, mStreamId, mExtImgMode);
- return rc;
-}
-
-/* initialize a streaming channel*/
-status_t QCameraStream::initStream(uint8_t no_cb_needed, uint8_t stream_on)
-{
-
- int rc = MM_CAMERA_OK;
-
- /* save local copy */
- m_flag_no_cb = no_cb_needed;
- m_flag_stream_on = stream_on;
-
- ALOGD("%s: E, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
- __func__, mActive, mInit, mStreamId, mExtImgMode);
-
- if(mInit == true) {
- ALOGE("%s: alraedy initted, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
- __func__, mActive, mInit, mStreamId, mExtImgMode);
- return rc;
- }
- /***********Allocate Stream**************/
- mStreamId = p_mm_ops->ops->add_stream(mCameraHandle,
- mChannelId,
- no_cb_needed? NULL : stream_cb_routine,
- no_cb_needed? NULL : (void *)this,
- mExtImgMode,
- 0/*sensor_idx*/);
- if (mStreamId == 0) {
- ALOGE("%s: err in add_stream, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
- __func__, mActive, mInit, mStreamId, mExtImgMode);
- return BAD_VALUE;
- }
-
- /***********Config Stream*****************/
- rc = setFormat();
- if(MM_CAMERA_OK != rc) {
- ALOGE("%s: err in config_stream, mActive = %d, streamid = %d, image_mode = %d",
- __func__, mActive, mStreamId, mExtImgMode);
- p_mm_ops->ops->del_stream(mCameraHandle,
- mChannelId,
- mStreamId);
- return BAD_VALUE;
- }
-
- mInit=true;
- ALOGE("%s: X, mActive = %d, streamid = %d, image_mode = %d",
- __func__, mActive, mStreamId, mExtImgMode);
- return NO_ERROR;
-}
-
-status_t QCameraStream::deinitStream()
-{
-
- int rc = MM_CAMERA_OK;
-
- ALOGD("%s: E, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",__func__, mActive, mInit, mStreamId, mExtImgMode);
-
- if(mInit == false) {
- /* stream has not been initted. nop */
- if (mStreamId > 0) {
- ALOGE("%s: bug. mStreamId = %d, mInit = %d", __func__, mStreamId, mInit);
- rc = -1;
- }
- return rc;
- }
- rc= p_mm_ops->ops->del_stream(mCameraHandle,mChannelId,
- mStreamId);
-
- ALOGV("%s: X, Stream = %d\n", __func__, mStreamId);
- mInit = false;
- mStreamId = 0;
- ALOGD("%s: X, mActive = %d, mInit = %d, streamid = %d, image_mode = %d",
- __func__, mActive, mInit, mStreamId, mExtImgMode);
- return NO_ERROR;
-}
-
-status_t QCameraStream::setFormat()
-{
- int rc = MM_CAMERA_OK;
- mm_camera_stream_config_t stream_config;
-
- ALOGV("%s: E, mActive = %d, streamid = %d, image_mode = %d",__func__, mActive, mStreamId, mExtImgMode);
- memset(&stream_config, 0, sizeof(mm_camera_stream_config_t));
-
- switch(mExtImgMode)
- {
- case MM_CAMERA_PREVIEW:
- /* Get mFormat */
- rc = p_mm_ops->ops->get_parm(p_mm_ops->camera_handle,
- MM_CAMERA_PARM_PREVIEW_FORMAT,
- &mFormat);
- if (MM_CAMERA_OK != rc) {
- ALOGE("%s: error - can't get preview format!", __func__);
- ALOGD("%s: X", __func__);
- return rc;
- }
- break;
- case MM_CAMERA_VIDEO:
- break;
- case MM_CAMERA_SNAPSHOT_MAIN:
- stream_config.fmt.rotation = mHalCamCtrl->getJpegRotation();
- break;
- case MM_CAMERA_SNAPSHOT_THUMBNAIL:
- stream_config.fmt.rotation = mHalCamCtrl->getJpegRotation();
- break;
- case MM_CAMERA_RDI:
- mWidth = 0;
- mHeight = 0;
- mFormat = CAMERA_BAYER_SBGGR10;
- default:
- break;
- }
-
- stream_config.fmt.fmt = (cam_format_t)mFormat;
- stream_config.fmt.meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- stream_config.fmt.width = mWidth;
- stream_config.fmt.height = mHeight;
- stream_config.num_of_bufs = mNumBuffers;
- stream_config.need_stream_on = m_flag_stream_on;
- rc = p_mm_ops->ops->config_stream(mCameraHandle,
- mChannelId,
- mStreamId,
- &stream_config);
-
- if(mHalCamCtrl->rdiMode != STREAM_IMAGE) {
- mHalCamCtrl->mRdiWidth = stream_config.fmt.width;
- mHalCamCtrl->mRdiHeight = stream_config.fmt.height;
- }
-
- mWidth = stream_config.fmt.width;
- mHeight = stream_config.fmt.height;
- ALOGD("%s: X",__func__);
- return rc;
-}
-
-QCameraStream::QCameraStream (){
- mInit = false;
- mActive = false;
- /* memset*/
- memset(&mCrop, 0, sizeof(mm_camera_rect_t));
- m_flag_no_cb = FALSE;
- m_flag_stream_on = TRUE;
-}
-
-QCameraStream::QCameraStream(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode,
- QCameraHardwareInterface* camCtrl)
- : mCameraHandle(CameraHandle),
- mChannelId(ChannelId),
- mWidth(Width),
- mHeight(Height),
- mFormat(Format),
- mNumBuffers(NumBuffers),
- p_mm_ops(mm_ops),
- mExtImgMode(imgmode),
- mHalCamCtrl(camCtrl)
-{
- mInit = false;
- mActive = false;
-
- mStreamId = 0;
- m_flag_no_cb = FALSE;
- m_flag_stream_on = TRUE;
-
- /* memset*/
- memset(&mCrop, 0, sizeof(mm_camera_rect_t));
-}
-
-QCameraStream::~QCameraStream ()
-{
-}
-
-void QCameraStream::release() {
- return;
-}
-
-int32_t QCameraStream::setCrop()
-{
- mm_camera_rect_t v4l2_crop;
- int32_t rc = 0;
- memset(&v4l2_crop,0,sizeof(v4l2_crop));
-
- if(!mActive) {
- ALOGE("%s: Stream:%d is not active", __func__, mStreamId);
- return -1;
- }
-
- rc = p_mm_ops->ops->get_stream_parm(mCameraHandle,
- mChannelId,
- mStreamId,
- MM_CAMERA_STREAM_CROP,
- &v4l2_crop);
- ALOGI("%s: Crop info received: %d, %d, %d, %d ",
- __func__,
- v4l2_crop.left,
- v4l2_crop.top,
- v4l2_crop.width,
- v4l2_crop.height);
- if (rc == 0) {
- mCrop.offset_x = v4l2_crop.left;
- mCrop.offset_y = v4l2_crop.top;
- mCrop.width = v4l2_crop.width;
- mCrop.height = v4l2_crop.height;
- }
- return rc;
-}
-
-}; // namespace android
diff --git a/camera/QCamera/HAL/test/Android.mk b/camera/QCamera/HAL/test/Android.mk
deleted file mode 100755
index d3f5a12..0000000
--- a/camera/QCamera/HAL/test/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/camera/QCamera/HAL/usbcamcore/inc/QCameraMjpegDecode.h b/camera/QCamera/HAL/usbcamcore/inc/QCameraMjpegDecode.h
deleted file mode 100755
index b04182b..0000000
--- a/camera/QCamera/HAL/usbcamcore/inc/QCameraMjpegDecode.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
-
-#ifndef __QCAMERA_MJPEG_DECODE_H
-#define __QCAMERA_MJPEG_DECODE_H
-
-typedef int MJPEGD_ERR;
-#define MJPEGD_NO_ERROR 0
-#define MJPEGD_ERROR -1
-#define MJPEGD_INSUFFICIENT_MEM -2
-
-MJPEGD_ERR mjpegDecoderInit(void**);
-
-MJPEGD_ERR mjpegDecoderDestroy(void* mjpegd);
-
-MJPEGD_ERR mjpegDecode(
- void* mjpegd,
- char* mjpegBuffer,
- int mjpegBufferSize,
- char* outputYptr,
- char* outputUVptr,
- int outputFormat);
-
-#endif /* __QCAMERA_MJPEG_DECODE_H */
diff --git a/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbParm.h b/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbParm.h
deleted file mode 100755
index 595bf42..0000000
--- a/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbParm.h
+++ /dev/null
@@ -1,178 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
-
-#ifndef ANDROID_HARDWARE_QCAMERA_USB_PARM_H
-#define ANDROID_HARDWARE_QCAMERA_USB_PARM_H
-
-
-#include <utils/threads.h>
-#include <hardware/camera.h>
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <camera/Camera.h>
-#include <camera/QCameraParameters.h>
-#include <system/window.h>
-#include <system/camera.h>
-#include <hardware/camera.h>
-#include <gralloc_priv.h>
-#include <hardware/power.h>
-
-extern "C" {
-#include <linux/android_pmem.h>
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include <camera_defs_i.h>
-} //extern C
-
-//Error codes
-#define NOT_FOUND -1
-
-/******************************************************************************
-* Macro definitions
-******************************************************************************/
-/* enum definitions for picture formats */
-static const int PICTURE_FORMAT_JPEG = 1;
-static const int PICTURE_FORMAT_RAW = 2;
-
-/* Default preview width in pixels */
-#define DEFAULT_USBCAM_PRVW_WD 1280//640
-
-/* Default preview height in pixels */
-#define DEFAULT_USBCAM_PRVW_HT 720//480
-
-/* Default picture format */
-#define DEFAULT_USBCAM_PICT_FMT PICTURE_FORMAT_JPEG
-
-/* Default picture width in pixels */
-#define DEFAULT_USBCAM_PICT_WD 640
-
-/* Default picture height in pixels */
-#define DEFAULT_USBCAM_PICT_HT 480
-
-/* Default picture JPEG quality 0-100 */
-#define DEFAULT_USBCAM_PICT_QLTY 85
-
-/* Default thumbnail width in pixels */
-#define DEFAULT_USBCAM_THUMBNAIL_WD 432
-
-/* Default thumbnail height in pixels */
-#define DEFAULT_USBCAM_THUMBNAIL_HT 288
-
-/* Default thumbnail JPEG quality 0-100 */
-#define DEFAULT_USBCAM_THUMBNAIL_QLTY 85
-
-/* Default preview format */
-#define DEFAULT_USBCAM_PRVW_FMT HAL_PIXEL_FORMAT_YCrCb_420_SP
-
-/* minimum of the default preview fps range in milli-Hz */
-#define MIN_PREV_FPS 5000
-
-/* maximum of the default preview fps range in milli-Hz */
-#define MAX_PREV_FPS 121000
-
-//for histogram stats
-#define HISTOGRAM_STATS_SIZE 257
-#define NUM_HISTOGRAM_BUFFERS 3
-
-namespace android {
-
-/******************************************************************************
-* Structure definitions
-******************************************************************************/
-typedef struct {
- uint32_t aspect_ratio;
- uint32_t width;
- uint32_t height;
-} thumbnail_size_type;
-
-/******************************************************************************
- * Function: usbCamInitDefaultParameters
- * Description: This function sets default parameters to camera HAL context
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-int usbCamInitDefaultParameters(camera_hardware_t *camHal);
-
-/******************************************************************************
- * Function: usbCamSetParameters
- * Description: This function parses the parameter string and stores the
- * parameters in the camera HAL handle
- *
- * Input parameters:
- * camHal - camera HAL handle
- * params - pointer to parameter string
- *
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-int usbCamSetParameters(camera_hardware_t *camHal, const char *params);
-
-/******************************************************************************
- * Function: usbCamGetParameters
- * Description: This function allocates memory for parameter string,
- * composes and returns the parameter string
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * Address to the parameter string
- *
- * Notes: none
- *****************************************************************************/
-char* usbCamGetParameters(camera_hardware_t *camHal);
-
-/******************************************************************************
- * Function: usbCamPutParameters
- * Description: This function frees the memory allocated for parameter string
- *
- * Input parameters:
- * camHal - camera HAL handle
- * parms - Parameter string
- *
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-void usbCamPutParameters(camera_hardware_t *camHal, char *parms);
-
-}; // namespace android
-
-#endif /* ANDROID_HARDWARE_QCAMERA_USB_PARM_H */
diff --git a/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbPriv.h b/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbPriv.h
deleted file mode 100755
index 9b60c11..0000000
--- a/camera/QCamera/HAL/usbcamcore/inc/QCameraUsbPriv.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
-
-#ifndef ANDROID_HARDWARE_QCAMERA_USB_PRIV_H
-#define ANDROID_HARDWARE_QCAMERA_USB_PRIV_H
-
-namespace android {
-
-/* File name length in number of characters */
-#define FILENAME_LENGTH (256)
-
-/* Number of display buffers (in addition to minimum number of undequed buffers */
-#define PRVW_DISP_BUF_CNT 2
-
-/* Number of V4L2 capture buffers. */
-#define PRVW_CAP_BUF_CNT 4
-
-/* Maximum buffer size for JPEG output in number of bytes */
-#define MAX_JPEG_BUFFER_SIZE (1024 * 1024)
-
-/* Preview loop commands */
-#define USB_CAM_PREVIEW_EXIT (0x100)
-#define USB_CAM_PREVIEW_PAUSE (0x101)
-#define USB_CAM_PREVIEW_TAKEPIC (0x200)
-
-/******************************************************************************
- * Macro function to input validate device handle
- *****************************************************************************/
-#define VALIDATE_DEVICE_HDL(camHal, device, ret_err_code) {\
- if(device && device->priv){\
- camHal = (camera_hardware_t *)device->priv;\
- }else{\
- ALOGE("%s: Null device or device->priv", __func__);\
- return ret_err_code;\
- }\
-}\
-
-/******************************************************************************
- * Macro function to check return status of a function, log and exit the thread
- *****************************************************************************/
-#define ERROR_CHECK_EXIT_THREAD(rc, string) {\
- if(rc < 0) {\
- ALOGE("%s: Error %s", __func__, string);\
- return (void *)-1;\
- }\
-}
-
-/******************************************************************************
- * Macro function to check return status of a function, log and exit
- *****************************************************************************/
-#define ERROR_CHECK_EXIT(rc, string) {\
- if(rc < 0) {\
- ALOGE("%s: Error %s", __func__, string);\
- return -1;\
- }\
-}
-
-/******************************************************************************
-* Macro function to Print the parameter string 1000 characters at a time
-******************************************************************************/
-#define PRINT_PARAM_STR(parms) {\
- char temp[1001] = {0};\
- int n=0;\
- while(1) {\
- strlcpy(temp,parms+n,1000);\
- ALOGD("parms = %s", temp);\
- if (strlen(temp) < 1000) break;\
- n += 1000;\
- }\
- }\
-
-/******************************************************************************
- * Macro function to open camera
- *****************************************************************************/
-#define USB_CAM_OPEN(camHal) {\
- camHal->fd = open(camHal->dev_name, O_RDWR | O_NONBLOCK, 0);\
- if(!camHal->fd)\
- ALOGE("%s: Error in open", __func__);\
- else\
- ALOGD("%s: Successfully opened", __func__);\
- }\
-
-/******************************************************************************
- * Macro function to close camera
- *****************************************************************************/
-#define USB_CAM_CLOSE(camHal) {\
- int rc;\
- if(camHal->fd){\
- rc = close(camHal->fd);\
- if(0 > rc){\
- ALOGE("%s: close failed ", __func__);\
- }\
- else{\
- camHal->fd = 0;\
- ALOGD("%s: close successful", __func__);\
- }\
- }\
- }\
-
-struct bufObj {
- void *data;
- int len;
-};
-
-typedef struct {
- camera_device hw_dev;
- Mutex lock;
- int previewEnabledFlag;
- int prvwStoppedForPicture;
- int msgEnabledFlag;
- volatile int prvwCmdPending;
- volatile int prvwCmd;
- pthread_t previewThread;
- pthread_t takePictureThread;
-
- camera_notify_callback notify_cb;
- camera_data_callback data_cb;
- camera_data_timestamp_callback data_cb_timestamp;
- camera_request_memory get_memory;
- void* cb_ctxt;
-
- /* capture related members */
- /* prevFormat is pixel format of preview buffers that are exported */
- int prevFormat;
- int prevFps;
- int prevWidth;
- int prevHeight;
- /* captureFormat is internal setting for USB camera buffers */
- int captureFormat;
- char dev_name[FILENAME_LENGTH];
- int fd;
- unsigned int n_buffers;
- struct v4l2_buffer curCaptureBuf;
- struct bufObj *buffers;
-
- /* Display related members */
- preview_stream_ops* window;
- QCameraHalMemory_t previewMem;
- /* dispFormat is preview display format.Same as preview buffer format*/
- int dispFormat;
- int dispWidth;
- int dispHeight;
-
- /* MJPEG decoder related members */
- /* MJPEG decoder object */
- void* mjpegd;
-
- /* JPEG picture and thumbnail related members */
- int pictFormat;
- int pictWidth;
- int pictHeight;
- int pictJpegQlty;
- int thumbnailWidth;
- int thumbnailHeight;
- int thumbnailJpegQlty;
- QCameraHalMemory_t pictMem;
- int takePictInProgress;
- int jpegEncInProgress;
- pthread_mutex_t jpegEncMutex;
- pthread_cond_t jpegEncCond;
-
- /* */
- QCameraParameters qCamParams;
- String8 prevSizeValues;
- String8 pictSizeValues;
- String8 thumbnailSizeValues;
- String8 vidSizeValues;
- String8 pictFormatValues;
- String8 prevFormatValues;
- String8 prevFpsRangesValues;
-
-} camera_hardware_t;
-
-
-}; // namespace android
-
-#endif /* ANDROID_HARDWARE_QCAMERA_USB_PRIV_H */
diff --git a/camera/QCamera/HAL/usbcamcore/inc/QualcommUsbCamera.h b/camera/QCamera/HAL/usbcamcore/inc/QualcommUsbCamera.h
deleted file mode 100755
index e389c76..0000000
--- a/camera/QCamera/HAL/usbcamcore/inc/QualcommUsbCamera.h
+++ /dev/null
@@ -1,243 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
-
-#ifndef ANDROID_HARDWARE_QUALCOMM_CAMERA_USBCAM_H
-#define ANDROID_HARDWARE_QUALCOMM_CAMERA_USBCAM_H
-
-extern "C" {
-#include <sys/time.h>
-}
-
-#include "QCameraHWI.h"
-
-extern "C" {
-
-/*#include <hardware/camera.h>*/
-
- int usbcam_get_number_of_cameras();
- int usbcam_get_camera_info(int camera_id, struct camera_info *info);
-
- int usbcam_camera_device_open(const struct hw_module_t* module, const char* id,
- struct hw_device_t** device);
-
- hw_device_t * usbcam_open_camera_device(int cameraId);
-
- int usbcam_close_camera_device( hw_device_t *);
-
-namespace android {
-
- /** Set the ANativeWindow to which preview frames are sent */
- int usbcam_set_preview_window(struct camera_device *,
- struct preview_stream_ops *window);
-
- /** Set the notification and data callbacks */
- void usbcam_set_CallBacks(struct camera_device *,
- camera_notify_callback notify_cb,
- camera_data_callback data_cb,
- camera_data_timestamp_callback data_cb_timestamp,
- camera_request_memory get_memory,
- void *user);
-
- /**
- * The following three functions all take a msg_type, which is a bitmask of
- * the messages defined in include/ui/Camera.h
- */
-
- /**
- * Enable a message, or set of messages.
- */
- void usbcam_enable_msg_type(struct camera_device *, int32_t msg_type);
-
- /**
- * Disable a message, or a set of messages.
- *
- * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
- * HAL should not rely on its client to call releaseRecordingFrame() to
- * release video recording frames sent out by the cameral HAL before and
- * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
- * clients must not modify/access any video recording frame after calling
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
- */
- void usbcam_disable_msg_type(struct camera_device *, int32_t msg_type);
-
- /**
- * Query whether a message, or a set of messages, is enabled. Note that
- * this is operates as an AND, if any of the messages queried are off, this
- * will return false.
- */
- int usbcam_msg_type_enabled(struct camera_device *, int32_t msg_type);
-
- /**
- * Start preview mode.
- */
- int usbcam_start_preview(struct camera_device *);
-
- /**
- * Stop a previously started preview.
- */
- void usbcam_stop_preview(struct camera_device *);
-
- /**
- * Returns true if preview is enabled.
- */
- int usbcam_preview_enabled(struct camera_device *);
-
- /**
- * Request the camera HAL to store meta data or real YUV data in the video
- * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
- * it is not called, the default camera HAL behavior is to store real YUV
- * data in the video buffers.
- *
- * This method should be called before startRecording() in order to be
- * effective.
- *
- * If meta data is stored in the video buffers, it is up to the receiver of
- * the video buffers to interpret the contents and to find the actual frame
- * data with the help of the meta data in the buffer. How this is done is
- * outside of the scope of this method.
- *
- * Some camera HALs may not support storing meta data in the video buffers,
- * but all camera HALs should support storing real YUV data in the video
- * buffers. If the camera HAL does not support storing the meta data in the
- * video buffers when it is requested to do do, INVALID_OPERATION must be
- * returned. It is very useful for the camera HAL to pass meta data rather
- * than the actual frame data directly to the video encoder, since the
- * amount of the uncompressed frame data can be very large if video size is
- * large.
- *
- * @param enable if true to instruct the camera HAL to store
- * meta data in the video buffers; false to instruct
- * the camera HAL to store real YUV data in the video
- * buffers.
- *
- * @return OK on success.
- */
- int usbcam_store_meta_data_in_buffers(struct camera_device *, int enable);
-
- /**
- * Start record mode. When a record image is available, a
- * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding
- * frame. Every record frame must be released by a camera HAL client via
- * releaseRecordingFrame() before the client calls
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
- * responsibility to manage the life-cycle of the video recording frames,
- * and the client must not modify/access any video recording frames.
- */
- int usbcam_start_recording(struct camera_device *);
-
- /**
- * Stop a previously started recording.
- */
- void usbcam_stop_recording(struct camera_device *);
-
- /**
- * Returns true if recording is enabled.
- */
- int usbcam_recording_enabled(struct camera_device *);
-
- /**
- * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
- *
- * It is camera HAL client's responsibility to release video recording
- * frames sent out by the camera HAL before the camera HAL receives a call
- * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
- * responsibility to manage the life-cycle of the video recording frames.
- */
- void usbcam_release_recording_frame(struct camera_device *,
- const void *opaque);
-
- /**
- * Start auto focus, the notification callback routine is called with
- * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be
- * called again if another auto focus is needed.
- */
- int usbcam_auto_focus(struct camera_device *);
-
- /**
- * Cancels auto-focus function. If the auto-focus is still in progress,
- * this function will cancel it. Whether the auto-focus is in progress or
- * not, this function will return the focus position to the default. If
- * the camera does not support auto-focus, this is a no-op.
- */
- int usbcam_cancel_auto_focus(struct camera_device *);
-
- /**
- * Take a picture.
- */
- int usbcam_take_picture(struct camera_device *);
-
- /**
- * Cancel a picture that was started with takePicture. Calling this method
- * when no picture is being taken is a no-op.
- */
- int usbcam_cancel_picture(struct camera_device *);
-
- /**
- * Set the camera parameters. This returns BAD_VALUE if any parameter is
- * invalid or not supported.
- */
- int usbcam_set_parameters(struct camera_device *, const char *parms);
-
- //status_t setParameters(const QCameraParameters& params);
- /** Retrieve the camera parameters. The buffer returned by the camera HAL
- must be returned back to it with put_parameters, if put_parameters
- is not NULL.
- */
- char* usbcam_get_parameters(struct camera_device *);
-
- /** The camera HAL uses its own memory to pass us the parameters when we
- call get_parameters. Use this function to return the memory back to
- the camera HAL, if put_parameters is not NULL. If put_parameters
- is NULL, then you have to use free() to release the memory.
- */
- void usbcam_put_parameters(struct camera_device *, char *);
-
- /**
- * Send command to camera driver.
- */
- int usbcam_send_command(struct camera_device *,
- int32_t cmd, int32_t arg1, int32_t arg2);
-
- /**
- * Release the hardware resources owned by this object. Note that this is
- * *not* done in the destructor.
- */
- void usbcam_release(struct camera_device *);
-
- /**
- * Dump state of the camera hardware
- */
- int usbcam_dump(struct camera_device *, int fd);
-
-}; // namespace android
-
-} //extern "C"
-
-#endif
diff --git a/camera/QCamera/HAL/usbcamcore/src/QCameraMjpegDecode.cpp b/camera/QCamera/HAL/usbcamcore/src/QCameraMjpegDecode.cpp
deleted file mode 100755
index dcf0aa2..0000000
--- a/camera/QCamera/HAL/usbcamcore/src/QCameraMjpegDecode.cpp
+++ /dev/null
@@ -1,701 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraMjpegDecode"
-#include <utils/Log.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-
-extern "C" {
-#include "jpeg_buffer.h"
-#include "jpeg_common.h"
-#include "jpegd.h"
-}
-
-#include "QCameraMjpegDecode.h"
-
-/* TBDJ: Can be removed */
-#define MIN(a,b) (((a) < (b)) ? (a) : (b))
-
-// Abstract the return type of the function to be run as a thread
-#define OS_THREAD_FUNC_RET_T void *
-
-// Abstract the argument type to the thread function
-#define OS_THREAD_FUNC_ARG_T void *
-
-// Helpful constants for return values in the thread functions
-#define OS_THREAD_FUNC_RET_SUCCEEDED (OS_THREAD_FUNC_RET_T)0
-#define OS_THREAD_FUNC_RET_FAILED (OS_THREAD_FUNC_RET_T)1
-
-// Abstract the function modifier placed in the beginning of the thread
-// declaration (empty for Linux)
-#define OS_THREAD_FUNC_MODIFIER
-
-#define os_mutex_init(a) pthread_mutex_init(a, NULL)
-#define os_cond_init(a) pthread_cond_init(a, NULL)
-#define os_mutex_lock pthread_mutex_lock
-#define os_mutex_unlock pthread_mutex_unlock
-#define os_cond_wait pthread_cond_wait
-#define os_cond_signal pthread_cond_signal
-
-const char event_to_string[4][14] =
-{
- "EVENT_DONE",
- "EVENT_WARNING",
- "EVENT_ERROR",
-};
-
-typedef struct
-{
- uint32_t width;
- uint32_t height;
- uint32_t format;
- uint32_t preference;
- uint32_t abort_time;
- uint16_t back_to_back_count;
- /* TBDJ: Is this required */
- int32_t rotation;
- /* TBDJ: Is this required */
- jpeg_rectangle_t region;
- /* TBDJ: Is this required */
- jpegd_scale_type_t scale_factor;
- uint32_t hw_rotation;
-
- char* inputMjpegBuffer;
- int inputMjpegBufferSize;
- char* outputYptr;
- char* outputUVptr;
-
-} test_args_t;
-
-typedef struct
-{
- int tid;
- pthread_t thread;
- jpegd_obj_t decoder;
- uint8_t decoding;
- uint8_t decode_success;
- pthread_mutex_t mutex;
- pthread_cond_t cond;
- test_args_t *p_args;
- jpegd_output_buf_t *p_whole_output_buf;
-
-} thread_ctrl_blk_t;
-
-OS_THREAD_FUNC_RET_T OS_THREAD_FUNC_MODIFIER decoder_test(OS_THREAD_FUNC_ARG_T p_thread_args);
-void decoder_event_handler(void *p_user_data,
- jpeg_event_t event,
- void *p_arg);
-int decoder_output_handler(void *p_user_data,
- jpegd_output_buf_t *p_output_buffer,
- uint32_t first_row_id,
- uint8_t is_last_buffer);
-uint32_t decoder_input_req_handler(void *p_user_data,
- jpeg_buffer_t buffer,
- uint32_t start_offset,
- uint32_t length);
-static void* insertHuffmanTable(void *p, int size);
-
-static int mjpegd_timer_start(timespec *p_timer);
-static int mjpegd_timer_get_elapsed(timespec *p_timer, int *elapsed_in_ms, uint8_t reset_start);
-static int mjpegd_cond_timedwait(pthread_cond_t *p_cond, pthread_mutex_t *p_mutex, uint32_t ms);
-
-// Global variables
-/* TBDJ: can be removed */
-thread_ctrl_blk_t *thread_ctrl_blks = NULL;
-
-/*
- * This function initializes the mjpeg decoder and returns the object
- */
-MJPEGD_ERR mjpegDecoderInit(void** mjpegd_obj)
-{
- test_args_t* mjpegd;
-
- ALOGD("%s: E", __func__);
-
- mjpegd = (test_args_t *)malloc(sizeof(test_args_t));
- if(!mjpegd)
- return MJPEGD_INSUFFICIENT_MEM;
-
- memset(mjpegd, 0, sizeof(test_args_t));
-
- /* Defaults */
- /* Due to current limitation, s/w decoder is selected always */
- mjpegd->preference = JPEG_DECODER_PREF_HW_ACCELERATED_PREFERRED;
- mjpegd->back_to_back_count = 1;
- mjpegd->rotation = 0;
- mjpegd->hw_rotation = 0;
- mjpegd->scale_factor = (jpegd_scale_type_t)1;
-
- /* TBDJ: can be removed */
- mjpegd->width = 640;
- mjpegd->height = 480;
- mjpegd->abort_time = 0;
-
- *mjpegd_obj = (void *)mjpegd;
-
- ALOGD("%s: X", __func__);
- return MJPEGD_NO_ERROR;
-}
-
-MJPEGD_ERR mjpegDecode(
- void* mjpegd_obj,
- char* inputMjpegBuffer,
- int inputMjpegBufferSize,
- char* outputYptr,
- char* outputUVptr,
- int outputFormat)
-{
- int rc, c, i;
- test_args_t* mjpegd;
- test_args_t test_args;
-
- ALOGD("%s: E", __func__);
- /* store input arguments in the context */
- mjpegd = (test_args_t*) mjpegd_obj;
- mjpegd->inputMjpegBuffer = inputMjpegBuffer;
- mjpegd->inputMjpegBufferSize = inputMjpegBufferSize;
- mjpegd->outputYptr = outputYptr;
- mjpegd->outputUVptr = outputUVptr;
- mjpegd->format = outputFormat;
-
- /* TBDJ: can be removed */
- memcpy(&test_args, mjpegd, sizeof(test_args_t));
-
- // check the formats
- if (((test_args.format == YCRCBLP_H1V2) || (test_args.format == YCBCRLP_H1V2) ||
- (test_args.format == YCRCBLP_H1V1) || (test_args.format == YCBCRLP_H1V1)) &&
- !(test_args.preference == JPEG_DECODER_PREF_HW_ACCELERATED_ONLY)) {
- ALOGE("%s:These formats are not supported by SW format %d", __func__, test_args.format);
- return 1;
- }
-
- // Create thread control blocks
- thread_ctrl_blks = (thread_ctrl_blk_t *)malloc( sizeof(thread_ctrl_blk_t));
- if (!thread_ctrl_blks)
- {
- ALOGE("%s: decoder_test failed: insufficient memory in creating thread control blocks", __func__);
- return 1;
- }
- memset(thread_ctrl_blks, 0, sizeof(thread_ctrl_blk_t));
- // Initialize the blocks and kick off the threads
- thread_ctrl_blks[i].tid = i;
- thread_ctrl_blks[i].p_args = &test_args;
- os_mutex_init(&thread_ctrl_blks[i].mutex);
- os_cond_init(&thread_ctrl_blks[i].cond);
-
- rc = (int)decoder_test(&thread_ctrl_blks[i]);
-
- if (!rc)
- ALOGD("%s: decoder_test finished successfully ", __func__);
- else
- ALOGE("%s: decoder_test failed",__func__);
-
- ALOGD("%s: X rc: %d", __func__, rc);
-
- return rc;
-}
-
-OS_THREAD_FUNC_RET_T OS_THREAD_FUNC_MODIFIER decoder_test(OS_THREAD_FUNC_ARG_T arg)
-{
- int rc, i;
- jpegd_obj_t decoder;
- jpegd_src_t source;
- jpegd_dst_t dest;
- jpegd_cfg_t config;
- jpeg_hdr_t header;
- jpegd_output_buf_t p_output_buffers;
- uint32_t output_buffers_count = 1; // currently only 1 buffer a time is supported
- uint8_t use_pmem = true;
- timespec os_timer;
- thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)arg;
- test_args_t *p_args = p_thread_arg->p_args;
- uint32_t output_width;
- uint32_t output_height;
- uint32_t total_time = 0;
-
- ALOGD("%s: E", __func__);
-
- // Determine whether pmem should be used (useful for pc environment testing where
- // pmem is not available)
- if ((jpegd_preference_t)p_args->preference == JPEG_DECODER_PREF_SOFTWARE_PREFERRED ||
- (jpegd_preference_t)p_args->preference == JPEG_DECODER_PREF_SOFTWARE_ONLY) {
- use_pmem = false;
- }
-
- if (((jpegd_preference_t)p_args->preference !=
- JPEG_DECODER_PREF_HW_ACCELERATED_ONLY) &&
- ((jpegd_preference_t)p_args->scale_factor > 0)) {
- ALOGI("%s: Setting scale factor to 1x", __func__);
- }
-
- ALOGD("%s: before jpegd_init p_thread_arg: %p", __func__, p_thread_arg);
-
- // Initialize decoder
- rc = jpegd_init(&decoder,
- &decoder_event_handler,
- &decoder_output_handler,
- p_thread_arg);
-
- if (JPEG_FAILED(rc)) {
- ALOGE("%s: decoder_test: jpegd_init failed", __func__);
- goto fail;
- }
- p_thread_arg->decoder = decoder;
-
- // Set source information
- source.p_input_req_handler = &decoder_input_req_handler;
- source.total_length = p_args->inputMjpegBufferSize & 0xffffffff;
-
- rc = jpeg_buffer_init(&source.buffers[0]);
- if (JPEG_SUCCEEDED(rc)) {
- /* TBDJ: why buffer [1] */
- rc = jpeg_buffer_init(&source.buffers[1]);
- }
- if (JPEG_SUCCEEDED(rc)) {
-#if 1
- rc = jpeg_buffer_allocate(source.buffers[0], 0xA000, use_pmem);
-#else
- rc = jpeg_buffer_use_external_buffer(source.buffers[0],
- (uint8_t *)p_args->inputMjpegBuffer,
- p_args->inputMjpegBufferSize,
- 0);
-#endif
- ALOGD("%s: source.buffers[0]:%p compressed buffer ptr = %p", __func__,
- source.buffers[0], p_args->inputMjpegBuffer);
- }
- if (JPEG_SUCCEEDED(rc)) {
-#if 1
- rc = jpeg_buffer_allocate(source.buffers[1], 0xA000, use_pmem);
-#else
- rc = jpeg_buffer_use_external_buffer(source.buffers[1],
- (uint8_t *)p_args->inputMjpegBuffer,
- p_args->inputMjpegBufferSize,
- 0);
-#endif
- ALOGD("%s: source.buffers[1]:%p compressed buffer ptr = %p", __func__,
- source.buffers[1], p_args->inputMjpegBuffer);
- }
- if (JPEG_FAILED(rc)) {
- jpeg_buffer_destroy(&source.buffers[0]);
- jpeg_buffer_destroy(&source.buffers[1]);
- goto fail;
- }
-
- ALOGI("%s: *** Starting back-to-back decoding of %d frame(s)***\n",
- __func__, p_args->back_to_back_count);
-
- // Loop to perform n back-to-back decoding (to the same output file)
- for(i = 0; i < p_args->back_to_back_count; i++) {
- if(mjpegd_timer_start(&os_timer) < 0) {
- ALOGE("%s: failed to get start time", __func__);
- }
-
- /* TBDJ: Every frame? */
- ALOGD("%s: before jpegd_set_source source.p_arg:%p", __func__, source.p_arg);
- rc = jpegd_set_source(decoder, &source);
- if (JPEG_FAILED(rc))
- {
- ALOGE("%s: jpegd_set_source failed", __func__);
- goto fail;
- }
-
- rc = jpegd_read_header(decoder, &header);
- if (JPEG_FAILED(rc))
- {
- ALOGE("%s: jpegd_read_header failed", __func__);
- goto fail;
- }
- p_args->width = header.main.width;
- p_args->height = header.main.height;
- ALOGD("%s: main dimension: (%dx%d) subsampling: (%d)", __func__,
- header.main.width, header.main.height, (int)header.main.subsampling);
-
- // main image decoding:
- // Set destination information
- dest.width = (p_args->width) ? (p_args->width) : header.main.width;
- dest.height = (p_args->height) ? (p_args->height) : header.main.height;
- dest.output_format = (jpeg_color_format_t) p_args->format;
- dest.region = p_args->region;
-
- // if region is defined, re-assign the output width/height
- output_width = dest.width;
- output_height = dest.height;
-
- if (p_args->region.right || p_args->region.bottom)
- {
- if (0 == p_args->rotation || 180 == p_args->rotation)
- {
- output_width = MIN((dest.width),
- (uint32_t)(dest.region.right - dest.region.left + 1));
- output_height = MIN((dest.height),
- (uint32_t)(dest.region.bottom - dest.region.top + 1));
- }
- // Swap output width/height for 90/270 rotation cases
- else if (90 == p_args->rotation || 270 == p_args->rotation)
- {
- output_height = MIN((dest.height),
- (uint32_t)(dest.region.right - dest.region.left + 1));
- output_width = MIN((dest.width),
- (uint32_t)(dest.region.bottom - dest.region.top + 1));
- }
- // Unsupported rotation cases
- else
- {
- goto fail;
- }
- }
-
- if (dest.output_format == YCRCBLP_H2V2 || dest.output_format == YCBCRLP_H2V2 ||
- dest.output_format == YCRCBLP_H2V1 || dest.output_format == YCBCRLP_H2V1 ||
- dest.output_format == YCRCBLP_H1V2 || dest.output_format == YCBCRLP_H1V2 ||
- dest.output_format == YCRCBLP_H1V1 || dest.output_format == YCBCRLP_H1V1) {
- jpeg_buffer_init(&p_output_buffers.data.yuv.luma_buf);
- jpeg_buffer_init(&p_output_buffers.data.yuv.chroma_buf);
- } else {
- jpeg_buffer_init(&p_output_buffers.data.rgb.rgb_buf);
-
- }
-
- {
- // Assign 0 to tile width and height
- // to indicate that no tiling is requested.
- p_output_buffers.tile_width = 0;
- p_output_buffers.tile_height = 0;
- }
- p_output_buffers.is_in_q = 0;
-
- switch (dest.output_format)
- {
- case YCRCBLP_H2V2:
- case YCBCRLP_H2V2:
-// case YCRCBLP_H2V1:
-// case YCBCRLP_H2V1:
-// case YCRCBLP_H1V2:
-// case YCBCRLP_H1V2:
-// case YCRCBLP_H1V1:
-// case YCBCRLP_H1V1:
- jpeg_buffer_use_external_buffer(
- p_output_buffers.data.yuv.luma_buf,
- (uint8_t*)p_args->outputYptr,
- p_args->width * p_args->height * SQUARE(p_args->scale_factor),
- 0);
- jpeg_buffer_use_external_buffer(
- p_output_buffers.data.yuv.chroma_buf,
- (uint8_t*)p_args->outputUVptr,
- p_args->width * p_args->height / 2 * SQUARE(p_args->scale_factor),
- 0);
- break;
-
- default:
- ALOGE("%s: decoder_test: unsupported output format", __func__);
- goto fail;
- }
-
- // Set up configuration
- memset(&config, 0, sizeof(jpegd_cfg_t));
- config.preference = (jpegd_preference_t) p_args->preference;
- config.decode_from = JPEGD_DECODE_FROM_AUTO;
- config.rotation = p_args->rotation;
- config.scale_factor = p_args->scale_factor;
- config.hw_rotation = p_args->hw_rotation;
- dest.back_to_back_count = p_args->back_to_back_count;
-
- // Start decoding
- p_thread_arg->decoding = true;
-
- rc = jpegd_start(decoder, &config, &dest, &p_output_buffers, output_buffers_count);
- dest.back_to_back_count--;
-
- if(JPEG_FAILED(rc)) {
- ALOGE("%s: decoder_test: jpegd_start failed (rc=%d)\n",
- __func__, rc);
- goto fail;
- }
-
- ALOGD("%s: decoder_test: jpegd_start succeeded", __func__);
-
- // Do abort
- if (p_args->abort_time) {
- os_mutex_lock(&p_thread_arg->mutex);
- while (p_thread_arg->decoding)
- {
- rc = mjpegd_cond_timedwait(&p_thread_arg->cond, &p_thread_arg->mutex, p_args->abort_time);
- if (rc == JPEGERR_ETIMEDOUT)
- {
- // Do abort
- os_mutex_unlock(&p_thread_arg->mutex);
- rc = jpegd_abort(decoder);
- if (rc)
- {
- ALOGE("%s: decoder_test: jpegd_abort failed: %d", __func__, rc);
- goto fail;
- }
- break;
- }
- }
- if (p_thread_arg->decoding)
- os_mutex_unlock(&p_thread_arg->mutex);
- } else {
- // Wait until decoding is done or stopped due to error
- os_mutex_lock(&p_thread_arg->mutex);
- while (p_thread_arg->decoding)
- {
- os_cond_wait(&p_thread_arg->cond, &p_thread_arg->mutex);
- }
- os_mutex_unlock(&p_thread_arg->mutex);
- }
-
- int diff;
- // Display the time elapsed
- if (mjpegd_timer_get_elapsed(&os_timer, &diff, 0) < 0) {
- ALOGE("%s: decoder_test: failed to get elapsed time", __func__);
- } else {
- if(p_args->abort_time) {
- if(p_thread_arg->decoding) {
- ALOGI("%s: decoder_test: decoding aborted successfully after %d ms", __func__, diff);
- goto buffer_clean_up;
- }
- else
- {
- ALOGI("%s: decoder_test: decoding stopped before abort is issued. "
- "decode time: %d ms", __func__, diff);
- }
- }
- else {
- if(p_thread_arg->decode_success) {
- total_time += diff;
- ALOGI("%s: decode time: %d ms (%d frame(s), total=%dms, avg=%dms/frame)",
- __func__, diff, i+1, total_time, total_time/(i+1));
- }
- else
- {
- fprintf(stderr, "decoder_test: decode failed\n");
- }
- }
- }
- }
-
- if(p_thread_arg->decode_success) {
- ALOGD("%s: Frame(s) = %d, Total Time = %dms, Avg. decode time = %dms/frame)\n",
- __func__, p_args->back_to_back_count, total_time, total_time/p_args->back_to_back_count);
- }
-
-buffer_clean_up:
- // Clean up decoder and allocate buffers
- jpeg_buffer_destroy(&source.buffers[0]);
- jpeg_buffer_destroy(&source.buffers[1]);
- switch (dest.output_format)
- {
- case YCRCBLP_H2V2:
- case YCBCRLP_H2V2:
- case YCRCBLP_H2V1:
- case YCBCRLP_H2V1:
- case YCRCBLP_H1V2:
- case YCBCRLP_H1V2:
- case YCRCBLP_H1V1:
- case YCBCRLP_H1V1:
- jpeg_buffer_destroy(&p_output_buffers.data.yuv.luma_buf);
- jpeg_buffer_destroy(&p_output_buffers.data.yuv.chroma_buf);
- break;
- default:
- break;
- }
- jpegd_destroy(&decoder);
-
- if (!p_thread_arg->decode_success)
- {
- goto fail;
- }
-
- ALOGD("%s: X", __func__);
- return OS_THREAD_FUNC_RET_SUCCEEDED;
-fail:
-
- ALOGD("%s: X", __func__);
- return OS_THREAD_FUNC_RET_FAILED;
-}
-
-void decoder_event_handler(void *p_user_data,
- jpeg_event_t event,
- void *p_arg)
-{
- thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
-
- ALOGD("%s: E", __func__);
-
- ALOGD("%s: Event: %s\n", __func__, event_to_string[event]);
- if (event == JPEG_EVENT_DONE)
- {
- p_thread_arg->decode_success = true;
- ALOGD("%s: decode_success: %d\n", __func__, p_thread_arg->decode_success);
- }
- // If it is not a warning event, decoder has stopped; Signal
- // main thread to clean up
- if (event != JPEG_EVENT_WARNING)
- {
- os_mutex_lock(&p_thread_arg->mutex);
- p_thread_arg->decoding = false;
- os_cond_signal(&p_thread_arg->cond);
- os_mutex_unlock(&p_thread_arg->mutex);
- }
- ALOGD("%s: X", __func__);
-
-}
-
-// consumes the output buffer.
-/*TBDJ: Can be removed. Is this related to tiling */
-int decoder_output_handler(void *p_user_data,
- jpegd_output_buf_t *p_output_buffer,
- uint32_t first_row_id,
- uint8_t is_last_buffer)
-{
- uint8_t* whole_output_buf_ptr, *tiling_buf_ptr;
-
- ALOGD("%s: E", __func__);
-
- thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
-
- jpeg_buffer_get_addr(p_thread_arg->p_whole_output_buf->data.rgb.rgb_buf, &whole_output_buf_ptr);
- jpeg_buffer_get_addr(p_output_buffer->data.rgb.rgb_buf, &tiling_buf_ptr);
-
- if (p_output_buffer->tile_height != 1)
- return JPEGERR_EUNSUPPORTED;
-
- // testing purpose only
- // This is to simulate that the user needs to bail out when error happens
- // in the middle of decoding
- //if (first_row_id == 162)
- // return JPEGERR_EFAILED;
-
- // do not enqueue any buffer if it reaches the last buffer
- if (!is_last_buffer)
- {
- jpegd_enqueue_output_buf(p_thread_arg->decoder, p_output_buffer, 1);
- }
- ALOGD("%s: X", __func__);
-
- return JPEGERR_SUCCESS;
-}
-
-// p_reader->p_input_req_handler(p_reader->decoder,
-// p_reader->p_input_buf,
-// p_reader->next_byte_offset,
-// MAX_BYTES_TO_FETCH);
-
-uint32_t decoder_input_req_handler(void *p_user_data,
- jpeg_buffer_t buffer,
- uint32_t start_offset,
- uint32_t length)
-{
- uint32_t buf_size;
- uint8_t *buf_ptr;
- int bytes_to_read, bytes_read, rc;
- thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
- thread_ctrl_blk_t *thread_ctrl_blk = (thread_ctrl_blk_t *)p_user_data;
- test_args_t* mjpegd = (test_args_t*) thread_ctrl_blk->p_args;
-
- ALOGD("%s: E", __func__);
-
- jpeg_buffer_get_max_size(buffer, &buf_size);
- jpeg_buffer_get_addr(buffer, &buf_ptr);
- bytes_to_read = (length < buf_size) ? length : buf_size;
- bytes_read = 0;
-
- ALOGD("%s: buf_ptr = %p, start_offset = %d, length = %d buf_size = %d bytes_to_read = %d", __func__, buf_ptr, start_offset, length, buf_size, bytes_to_read);
- if (bytes_to_read)
- {
- /* TBDJ: Should avoid this Mem copy */
-#if 1
- memcpy(buf_ptr, (char *)mjpegd->inputMjpegBuffer + start_offset, bytes_to_read);
-#else
- if(JPEGERR_SUCCESS != jpeg_buffer_set_start_offset(buffer, start_offset))
- ALOGE("%s: jpeg_buffer_set_start_offset failed", __func__);
-#endif
- bytes_read = bytes_to_read;
- }
-
- ALOGD("%s: X", __func__);
- return bytes_read;
-}
-
-static int mjpegd_timer_start(timespec *p_timer)
-{
- if (!p_timer)
- return JPEGERR_ENULLPTR;
-
- if (clock_gettime(CLOCK_REALTIME, p_timer))
- return JPEGERR_EFAILED;
-
- return JPEGERR_SUCCESS;
-}
-
-static int mjpegd_timer_get_elapsed(timespec *p_timer, int *elapsed_in_ms, uint8_t reset_start)
-{
- timespec now;
- long diff;
- int rc = mjpegd_timer_start(&now);
-
- if (JPEG_FAILED(rc))
- return rc;
-
- diff = (long)(now.tv_sec - p_timer->tv_sec) * 1000;
- diff += (long)(now.tv_nsec - p_timer->tv_nsec) / 1000000;
- *elapsed_in_ms = (int)diff;
-
- if (reset_start)
- *p_timer = now;
-
- return JPEGERR_SUCCESS;
-}
-
-int mjpegd_cond_timedwait(pthread_cond_t *p_cond, pthread_mutex_t *p_mutex, uint32_t ms)
-{
- struct timespec ts;
- int rc = clock_gettime(CLOCK_REALTIME, &ts);
- if (rc < 0) return rc;
-
- if (ms >= 1000) {
- ts.tv_sec += (ms/1000);
- ts.tv_nsec += ((ms%1000) * 1000000);
- } else {
- ts.tv_nsec += (ms * 1000000);
- }
-
- rc = pthread_cond_timedwait(p_cond, p_mutex, &ts);
- if (rc == ETIMEDOUT)
- {
- rc = JPEGERR_ETIMEDOUT;
- }
- return rc;
-}
-
diff --git a/camera/QCamera/HAL/usbcamcore/src/QCameraUsbParm.cpp b/camera/QCamera/HAL/usbcamcore/src/QCameraUsbParm.cpp
deleted file mode 100755
index fda6e9d..0000000
--- a/camera/QCamera/HAL/usbcamcore/src/QCameraUsbParm.cpp
+++ /dev/null
@@ -1,683 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraUsbParm"
-#include <utils/Log.h>
-
-#include <utils/Errors.h>
-#include <utils/threads.h>
-#include <utils/String16.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <cutils/properties.h>
-#include <math.h>
-#if HAVE_ANDROID_OS
-#include <linux/android_pmem.h>
-#endif
-#include <linux/ioctl.h>
-#include <camera/QCameraParameters.h>
-#include <media/mediarecorder.h>
-#include <gralloc_priv.h>
-
-#include "linux/msm_mdp.h"
-#include <linux/fb.h>
-#include <limits.h>
-
-
-extern "C" {
-#include <fcntl.h>
-#include <time.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <termios.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <signal.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/system_properties.h>
-#include <sys/time.h>
-#include <stdlib.h>
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include <cam_fifo.h>
-#include <jpege.h>
-
-} // extern "C"
-
-#include "QCameraHWI.h"
-#include "QualcommUsbCamera.h"
-#include "QCameraUsbPriv.h"
-#include "QCameraUsbParm.h"
-
-namespace android {
-
-/********************************************************************/
-static const str_map preview_formats[] = {
- {QCameraParameters::PIXEL_FORMAT_YUV420SP, HAL_PIXEL_FORMAT_YCrCb_420_SP},
-};
-
-static const preview_format_info_t preview_format_info_list[] = {
- {HAL_PIXEL_FORMAT_YV12, CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3}
-};
-
-static struct camera_size_type previewSizes[] = {
- { 1920, 1088}, //1080p
- { 1280, 720}, // 720P,
- { 640, 480}, // VGA
- { 512, 384},
- { 480, 320},
- { 320, 240}, // QVGA
-};
-
-// All fps ranges which can be supported. This list will be filtered according
-// to the min and max fps supported by hardware
-// this list must be sorted first by max_fps and then min_fps
-// fps values are multiplied by 1000
-static android::FPSRange prevFpsRanges[] = {
- android::FPSRange(5000, 121000),
-};
-
-/* TBR: Is frame rate mode mandatory */
-static const str_map frame_rate_modes[] = {
- {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO},
- {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED}
-};
-
-static const str_map picture_formats[] = {
- {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG},
- //{QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW}
-};
-
-static camera_size_type picture_sizes[] = {
- { 1920, 1088}, //HD1080
- { 1280, 720}, //HD720
- { 640, 480}, // VGA
- { 320, 240}, // QVGA
-};
-
-/* aspect ratio removed */
-static camera_size_type thumbnail_sizes[] = {
- { 512, 288 }, //1.777778
- { 480, 288 }, //1.666667
- { 256, 154 }, //1.66233
- { 432, 288 }, //1.5
- { 512, 384 }, //1.333333
- { 352, 288 }, //1.222222
- { 320, 240 }, //1.33333
- { 176, 144 }, //1.222222
-};
-
-static const str_map recording_Hints[] = {
- {"false", FALSE},
- {"true", TRUE}
-};
-
-/* Static functions list */
-static String8 create_sizes_str(const camera_size_type *sizes, int len);
-static String8 create_values_str(const str_map *values, int len);
-static String8 create_fps_str(const android:: FPSRange* fps, int len);
-static String8 create_values_range_str(int min, int max);
-static int usbCamSetPrvwSize( camera_hardware_t *camHal,
- const QCameraParameters& params);
-static int usbCamSetPictSize( camera_hardware_t *camHal,
- const QCameraParameters& params);
-static int usbCamSetThumbnailSize( camera_hardware_t *camHal,
- const QCameraParameters& params);
-static int usbCamSetJpegQlty( camera_hardware_t *camHal,
- const QCameraParameters& params);
-
-/******************************************************************************
- * Function: usbCamInitDefaultParameters
- * Description: This function sets default parameters to camera HAL context
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * None
- *
- * Notes: none
- *****************************************************************************/
-int usbCamInitDefaultParameters(camera_hardware_t *camHal)
-{
- ALOGD("%s: E", __func__);
- int rc = 0;
- char tempStr[FILENAME_LENGTH];
-
- /* Default initializations */
- camHal->prevFormat = DEFAULT_USBCAM_PRVW_FMT;
- camHal->prevWidth = DEFAULT_USBCAM_PRVW_WD;
- camHal->prevHeight = DEFAULT_USBCAM_PRVW_HT;
- camHal->dispFormat = camHal->prevFormat;
- camHal->dispWidth = camHal->prevWidth;
- camHal->dispHeight = camHal->prevHeight;
- camHal->pictFormat = DEFAULT_USBCAM_PICT_FMT;
- camHal->pictWidth = DEFAULT_USBCAM_PICT_WD;
- camHal->pictHeight = DEFAULT_USBCAM_PICT_HT;
- camHal->pictJpegQlty = DEFAULT_USBCAM_PICT_QLTY;
- camHal->thumbnailWidth = DEFAULT_USBCAM_THUMBNAIL_WD;
- camHal->thumbnailHeight = DEFAULT_USBCAM_THUMBNAIL_HT;
- camHal->thumbnailJpegQlty = DEFAULT_USBCAM_THUMBNAIL_QLTY;
- camHal->previewEnabledFlag = 0;
- camHal->prvwStoppedForPicture = 0;
- camHal->prvwCmdPending = 0;
- camHal->takePictInProgress = 0;
-
- //Set picture size values
- camHal->pictSizeValues = create_sizes_str(
- picture_sizes, sizeof(picture_sizes) / sizeof(camera_size_type));
- camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
- camHal->pictSizeValues.string());
- camHal->qCamParams.setPictureSize(camHal->pictWidth, camHal->pictHeight);
-
- //Set picture format
- camHal->pictFormatValues = create_values_str(
- picture_formats, sizeof(picture_formats) / sizeof(str_map));
- camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
- camHal->pictFormatValues.string());
- if(PICTURE_FORMAT_JPEG == camHal->pictFormat)
- camHal->qCamParams.setPictureFormat(QCameraParameters::PIXEL_FORMAT_JPEG);
-
- //Set picture quality
- sprintf(tempStr, "%d", camHal->pictJpegQlty);
- camHal->qCamParams.set(QCameraParameters::KEY_JPEG_QUALITY, tempStr);
-
- //Set Thumbnail size
- camHal->thumbnailSizeValues = create_sizes_str(
- thumbnail_sizes, sizeof(thumbnail_sizes) /sizeof(camera_size_type));
- camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
- camHal->thumbnailSizeValues.string());
- sprintf(tempStr, "%d", camHal->thumbnailWidth);
- camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
- tempStr);
- sprintf(tempStr, "%d", camHal->thumbnailHeight);
- camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
- tempStr);
-
- //Set Thumbnail quality
- sprintf(tempStr, "%d", camHal->thumbnailJpegQlty);
- camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
- tempStr);
-
- //Set Preview Format
- camHal->prevFormatValues = create_values_str(
- preview_formats, sizeof(preview_formats) / sizeof(str_map));
- camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
- camHal->prevFormatValues.string());
- if(HAL_PIXEL_FORMAT_YCrCb_420_SP == camHal->prevFormat)
- camHal->qCamParams.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP);
-
- //Set Preview size
- camHal->prevSizeValues = create_sizes_str(
- previewSizes, sizeof(previewSizes) / sizeof(camera_size_type));
- camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
- camHal->prevSizeValues.string());
- camHal->qCamParams.setPreviewSize(camHal->prevWidth, camHal->prevHeight);
-
- //Set Preivew fps range
- camHal->prevFpsRangesValues = create_fps_str(
- prevFpsRanges, sizeof(prevFpsRanges) / sizeof(android::FPSRange));
-
- camHal->qCamParams.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
- camHal->prevFpsRangesValues);
- camHal->qCamParams.setPreviewFpsRange(MIN_PREV_FPS, MAX_PREV_FPS);
-
- ALOGD("%s: X", __func__);
-
- return rc;
-} /* usbCamInitDefaultParameters */
-
-/******************************************************************************
- * Function: usbCamSetParameters
- * Description: This function parses the parameter string and stores the
- * parameters in the camera HAL handle
- *
- * Input parameters:
- * camHal - camera HAL handle
- * params - pointer to parameter string
- *
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-int usbCamSetParameters(camera_hardware_t *camHal, const char *params)
-{
- int rc = 0;
- String8 str = String8(params);
- QCameraParameters qParam;
-
- ALOGD("%s: E", __func__);
-
- if(params)
- PRINT_PARAM_STR(params);
-
- qParam.unflatten(str);
-
- if(usbCamSetPrvwSize(camHal, qParam))
- rc = -1;
- if(usbCamSetPictSize(camHal, qParam))
- rc = -1;
- if(usbCamSetThumbnailSize(camHal, qParam))
- rc = -1;
- if(usbCamSetJpegQlty(camHal, qParam))
- rc = -1;
-
- ALOGD("%s: X", __func__);
- return rc;
-} /* usbCamSetParameters */
-
-/******************************************************************************
- * Function: usbCamGetParameters
- * Description: This function allocates memory for parameter string,
- * composes and returns the parameter string
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * Address to the parameter string
- *
- * Notes: none
- *****************************************************************************/
-char* usbCamGetParameters(camera_hardware_t *camHal)
-{
- ALOGD("%s: E", __func__);
- char *parms = NULL;
- char* rc = NULL;
- String8 str;
-
- QCameraParameters qParam = camHal->qCamParams;
- //qParam.dump();
- str = qParam.flatten( );
- rc = (char *)malloc(sizeof(char)*(str.length()+1));
- if(rc != NULL){
- memset(rc, 0, sizeof(char)*(str.length()+1));
- strncpy(rc, str.string(), str.length());
- rc[str.length()] = 0;
- parms = rc;
- }
-
- PRINT_PARAM_STR(parms);
-
- ALOGD("%s: X", __func__);
- return (parms);
-} /* usbCamGetParameters */
-
-/******************************************************************************
- * Function: usbCamPutParameters
- * Description: This function frees the memory allocated for parameter string
- *
- * Input parameters:
- * camHal - camera HAL handle
- * parms - Parameter string
- *
- * Return values:
- * None
- *
- * Notes: none
- *****************************************************************************/
-void usbCamPutParameters(camera_hardware_t *camHal, char *parms)
-{
- ALOGD("%s: E", __func__);
- if(parms)
- free(parms);
- parms = NULL;
- ALOGD("%s: X", __func__);
-} /* usbCamPutParameters */
-
-/******************************************************************************
- * Function: create_sizes_str
- * Description: This function loops through /dev/video entries and probes with
- * UVCIOC query. If the device responds to the query, then it is
- * detected as UVC webcam
- * Input parameters:
- * devname - String pointer. The function return dev entry
- * name in this string
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-static String8 create_sizes_str(const camera_size_type *sizes, int len) {
- String8 str;
- char buffer[32];
-
- if (len > 0) {
- snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
- str.append(buffer);
- }
- for (int i = 1; i < len; i++) {
- snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height);
- str.append(buffer);
- }
- return str;
-}
-
-/******************************************************************************
- * Function: create_values_str
- * Description: This function loops through /dev/video entries and probes with
- * UVCIOC query. If the device responds to the query, then it is
- * detected as UVC webcam
- * Input parameters:
- * devname - String pointer. The function return dev entry
- * name in this string
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-static String8 create_values_str(const str_map *values, int len) {
- String8 str;
-
- if (len > 0) {
- str.append(values[0].desc);
- }
- for (int i = 1; i < len; i++) {
- str.append(",");
- str.append(values[i].desc);
- }
- return str;
-}
-
-/******************************************************************************
- * Function: create_fps_str
- * Description: This function loops through /dev/video entries and probes with
- * UVCIOC query. If the device responds to the query, then it is
- * detected as UVC webcam
- * Input parameters:
- * devname - String pointer. The function return dev entry
- * name in this string
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-static String8 create_fps_str(const android:: FPSRange* fps, int len) {
- String8 str;
- char buffer[32];
-
- if (len > 0) {
- snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS);
- str.append(buffer);
- }
- for (int i = 1; i < len; i++) {
- snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS);
- str.append(buffer);
- }
- return str;
-}
-
-/******************************************************************************
- * Function: create_values_range_str
- * Description: This function loops through /dev/video entries and probes with
- * UVCIOC query. If the device responds to the query, then it is
- * detected as UVC webcam
- * Input parameters:
- * devname - String pointer. The function return dev entry
- * name in this string
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-static String8 create_values_range_str(int min, int max){
- String8 str;
- char buffer[32];
-
- if(min <= max){
- snprintf(buffer, sizeof(buffer), "%d", min);
- str.append(buffer);
-
- for (int i = min + 1; i <= max; i++) {
- snprintf(buffer, sizeof(buffer), ",%d", i);
- str.append(buffer);
- }
- }
- return str;
-}
-
-/******************************************************************************
- * Function: usbCamSetPrvwSize
- * Description: This function parses preview width and height from the input
- * parameters and stores into the context
- *
- * Input parameters:
- * camHal - camera HAL handle
- * params - QCameraParameters reference
- *
- * Return values:
- * 0 If parameters are valid
- * -1 If parameters are invalid
- *
- * Notes: none
- *****************************************************************************/
-static int usbCamSetPrvwSize( camera_hardware_t *camHal,
- const QCameraParameters& params)
-{
- int rc = 0, width, height, i, numPrvwSizes, validSize;
- ALOGD("%s: E", __func__);
-
- params.getPreviewSize(&width, &height);
- ALOGI("%s: Requested preview size %d x %d", __func__, width, height);
-
- // Validate the preview size
- numPrvwSizes = sizeof(previewSizes) / sizeof(camera_size_type);
- for (i = 0, validSize = 0; i < numPrvwSizes; i++) {
- if (width == previewSizes[i].width
- && height == previewSizes[i].height) {
- validSize = 1;
-
- camHal->qCamParams.setPreviewSize(width, height);
- ALOGD("%s: setPreviewSize: width: %d height: %d",
- __func__, width, height);
-
- camHal->prevWidth = width;
- camHal->prevHeight = height;
- camHal->dispWidth = width;
- camHal->dispHeight = height;
-
- /* TBD: restrict pictures size and video to preview size */
- }
- }
- if(!validSize)
- ALOGE("%s: Invalid preview size %dx%d requested", __func__,
- width, height);
-
- rc = (validSize == 0)? -1:0;
- ALOGD("%s: X", __func__);
-
- return rc;
-} /* usbCamSetPrvwSize */
-
-/******************************************************************************
- * Function: usbCamSetPictSize
- * Description: This function parses picture width and height from the input
- * parameters and stores into the context
- *
- * Input parameters:
- * camHal - camera HAL handle
- * params - QCameraParameters reference
- *
- * Return values:
- * 0 If parameters are valid
- * -1 If parameters are invalid
- *
- * Notes: none
- *****************************************************************************/
-static int usbCamSetPictSize( camera_hardware_t *camHal,
- const QCameraParameters& params)
-{
- int rc = 0, width, height, i, numPictSizes, validSize;
- ALOGD("%s: E", __func__);
-
- /* parse for picture width and height */
- params.getPictureSize(&width, &height);
- ALOGI("%s: Requested picture size %d x %d", __func__, width, height);
-
- // Validate the picture size
- numPictSizes = sizeof(picture_sizes) / sizeof(camera_size_type);
- for (i = 0, validSize = 0; i < numPictSizes; i++) {
- if (width == picture_sizes[i].width
- && height == picture_sizes[i].height) {
- validSize = 1;
-
- camHal->qCamParams.setPictureSize(width, height);
- ALOGD("%s: setPictureSize: width: %d height: %d",
- __func__, width, height);
-
- /* TBD: If new pictSize is different from old size, restart prvw */
- camHal->pictWidth = width;
- camHal->pictHeight = height;
- }
- }
- if(!validSize)
- ALOGE("%s: Invalid picture size %dx%d requested", __func__,
- width, height);
- rc = (validSize == 0)? -1:0;
- ALOGD("%s: X", __func__);
-
- return rc;
-} /* usbCamSetPictSize */
-
-/******************************************************************************
- * Function: usbCamSetThumbnailSize
- * Description: This function parses picture width and height from the input
- * parameters and stores into the context
- *
- * Input parameters:
- * camHal - camera HAL handle
- * params - QCameraParameters reference
- *
- * Return values:
- * 0 If parameters are valid
- * -1 If parameters are invalid
- *
- * Notes: none
- *****************************************************************************/
-static int usbCamSetThumbnailSize( camera_hardware_t *camHal,
- const QCameraParameters& params)
-{
- int rc = 0, width, height, i, numThumbnailSizes, validSize;
- char tempStr[FILENAME_LENGTH];
- ALOGD("%s: E", __func__);
-
- /* parse for thumbnail width and height */
- width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
- height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
- ALOGI("%s: Requested thumbnail size %d x %d", __func__, width, height);
-
- // Validate the thumbnail size
- numThumbnailSizes = sizeof(thumbnail_sizes) / sizeof(camera_size_type);
- for (i = 0, validSize = 0; i < numThumbnailSizes; i++) {
- if (width == thumbnail_sizes[i].width
- && height == thumbnail_sizes[i].height) {
- validSize = 1;
-
- camHal->thumbnailWidth = width;
- camHal->thumbnailHeight = height;
- sprintf(tempStr, "%d", camHal->thumbnailWidth);
- camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
- width);
- sprintf(tempStr, "%d", camHal->thumbnailHeight);
- camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
- height);
-
- }
- }
- if(!validSize)
- ALOGE("%s: Invalid picture size %dx%d requested", __func__,
- width, height);
- rc = (validSize == 0)? -1:0;
- ALOGD("%s: X", __func__);
-
- return rc;
-} /* usbCamSetThumbnailSize */
-
-/******************************************************************************
- * Function: usbCamSetJpegQlty
- * Description: This function parses picture and thumbnail JPEG quality and
- * validates before storing in the context
- *
- * Input parameters:
- * camHal - camera HAL handle
- * params - QCameraParameters reference
- *
- * Return values:
- * 0 If parameters are valid
- * -1 If parameters are invalid
- *
- * Notes: none
- *****************************************************************************/
-static int usbCamSetJpegQlty( camera_hardware_t *camHal,
- const QCameraParameters& params)
-{
- int rc = 0, quality = 0;
- char tempStr[FILENAME_LENGTH];
- ALOGD("%s: E", __func__);
-
- /**/
- quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY);
- ALOGI("%s: Requested picture qlty %d", __func__, quality);
-
- if (quality >= 0 && quality <= 100) {
- camHal->pictJpegQlty = quality;
- sprintf(tempStr, "%d", camHal->pictJpegQlty);
- camHal->qCamParams.set(QCameraParameters::KEY_JPEG_QUALITY, quality);
- } else {
- ALOGE("Invalid jpeg quality=%d", quality);
- rc = -1;
- }
-
- quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
- ALOGI("%s: Requested thumbnail qlty %d", __func__, quality);
-
- if (quality >= 0 && quality <= 100) {
- camHal->thumbnailJpegQlty = quality;
- sprintf(tempStr, "%d", camHal->thumbnailJpegQlty);
- camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
- tempStr);
- } else {
- ALOGE("Invalid jpeg thumbnail quality=%d", quality);
- rc = -1;
- }
-
- ALOGD("%s: X rc:%d", __func__, rc);
-
- return rc;
-}
-
-}; /*namespace android */
diff --git a/camera/QCamera/HAL/usbcamcore/src/QualcommUsbCamera.cpp b/camera/QCamera/HAL/usbcamcore/src/QualcommUsbCamera.cpp
deleted file mode 100755
index 6f3c3cd..0000000
--- a/camera/QCamera/HAL/usbcamcore/src/QualcommUsbCamera.cpp
+++ /dev/null
@@ -1,2963 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
- /*#error uncomment this for compiler test!*/
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QualcommUsbCamera"
-
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <sys/prctl.h>
-#include <sys/resource.h>
-#include <pthread.h>
-#include <linux/uvcvideo.h>
-
-#include "QCameraHAL.h"
-#include "QualcommUsbCamera.h"
-#include "QCameraUsbPriv.h"
-#include "QCameraMjpegDecode.h"
-#include "QCameraUsbParm.h"
-#include <gralloc_priv.h>
-#include <genlock.h>
-
-extern "C" {
-#include <sys/time.h>
-}
-
-camera_device_ops_t usbcam_camera_ops = {
- set_preview_window: android::usbcam_set_preview_window,
- set_callbacks: android::usbcam_set_CallBacks,
- enable_msg_type: android::usbcam_enable_msg_type,
- disable_msg_type: android::usbcam_disable_msg_type,
- msg_type_enabled: android::usbcam_msg_type_enabled,
-
- start_preview: android::usbcam_start_preview,
- stop_preview: android::usbcam_stop_preview,
- preview_enabled: android::usbcam_preview_enabled,
- store_meta_data_in_buffers: android::usbcam_store_meta_data_in_buffers,
-
- start_recording: android::usbcam_start_recording,
- stop_recording: android::usbcam_stop_recording,
- recording_enabled: android::usbcam_recording_enabled,
- release_recording_frame: android::usbcam_release_recording_frame,
-
- auto_focus: android::usbcam_auto_focus,
- cancel_auto_focus: android::usbcam_cancel_auto_focus,
-
- take_picture: android::usbcam_take_picture,
- cancel_picture: android::usbcam_cancel_picture,
-
- set_parameters: android::usbcam_set_parameters,
- get_parameters: android::usbcam_get_parameters,
- put_parameters: android::usbcam_put_parameters,
- send_command: android::usbcam_send_command,
-
- release: android::usbcam_release,
- dump: android::usbcam_dump,
-};
-
-#define CAPTURE 1
-#define DISPLAY 1
-#define CALL_BACK 1
-#define MEMSET 0
-#define FREAD_JPEG_PICTURE 0
-#define JPEG_ON_USB_CAMERA 1
-#define FILE_DUMP_CAMERA 0
-#define FILE_DUMP_B4_DISP 0
-
-namespace android {
-
-static int initUsbCamera( camera_hardware_t *camHal,
- int width, int height,
- int pixelFormat);
-static int startUsbCamCapture( camera_hardware_t *camHal);
-static int stopUsbCamCapture( camera_hardware_t *camHal);
-static int initV4L2mmap( camera_hardware_t *camHal);
-static int unInitV4L2mmap( camera_hardware_t *camHal);
-static int launch_preview_thread( camera_hardware_t *camHal);
-static int launchTakePictureThread( camera_hardware_t *camHal);
-static int initDisplayBuffers( camera_hardware_t *camHal);
-static int deInitDisplayBuffers( camera_hardware_t *camHal);
-static int stopPreviewInternal( camera_hardware_t *camHal);
-static int get_buf_from_cam( camera_hardware_t *camHal);
-static int put_buf_to_cam( camera_hardware_t *camHal);
-static int prvwThreadTakePictureInternal(camera_hardware_t *camHal);
-static int get_buf_from_display( camera_hardware_t *camHal, int *buffer_id);
-static int put_buf_to_display( camera_hardware_t *camHal, int buffer_id);
-static int convert_data_frm_cam_to_disp(camera_hardware_t *camHal, int buffer_id);
-static void * previewloop(void *);
-static void * takePictureThread(void *);
-static int convert_YUYV_to_420_NV12(char *in_buf, char *out_buf, int wd, int ht);
-static int get_uvc_device(char *devname);
-static int getPreviewCaptureFmt(camera_hardware_t *camHal);
-static int allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type);
-static int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info);
-static int ioctlLoop(int fd, int ioctlCmd, void *args);
-static int readFromFile(char* fileName, char* buffer, int bufferSize);
-static int fileDump(const char* fileName, char* data, int length, int* frm_cnt);
-static int encodeJpeg( camera_hardware_t *camHal);
-void jpegEncodeCb (jpeg_job_status_t status,
- uint8_t thumbnailDroppedFlag,
- uint32_t client_hdl,
- uint32_t jobId,
- uint8_t* out_data,
- uint32_t data_size,
- void *userData);
-
-/* HAL function implementation goes here*/
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-
-extern "C" int usbcam_get_number_of_cameras()
-{
- /* TBR: This is hardcoded currently to 1 USB camera */
- int numCameras = 1;
- ALOGI("%s: E", __func__);
- ALOGI("%s: X", __func__);
-
- return numCameras;
-}
-
-extern "C" int usbcam_get_camera_info(int camera_id, struct camera_info *info)
-{
- int rc = -1;
- ALOGI("%s: E", __func__);
-
- /* TBR: This info is hardcoded currently irrespective of camera_id */
- if(info) {
- struct CameraInfo camInfo;
- memset(&camInfo, -1, sizeof (struct CameraInfo));
-
- info->facing = CAMERA_FACING_FRONT;//CAMERA_FACING_BACK;
- info->orientation = 0;
- rc = 0;
- }
- ALOGI("%s: X", __func__);
- return rc;
-}
-
-/* HAL should return NULL handle if it fails to open camera hardware. */
-extern "C" int usbcam_camera_device_open(
- const struct hw_module_t* module, const char* id,
- struct hw_device_t** hw_device)
-{
- int rc = -1;
- camera_device *device = NULL;
- camera_hardware_t *camHal;
- char *dev_name;
-
- ALOGI("%s: E", __func__);
-
- /* initialize return handle value to NULL */
- *hw_device = NULL;
-
- camHal = new camera_hardware_t();
- if(!camHal) {
-
- ALOGE("%s: end in no mem", __func__);
- return -1;
- }
-
- rc = usbCamInitDefaultParameters(camHal);
- if(0 != rc)
- {
- ALOGE("%s: usbCamInitDefaultParameters error", __func__);
- return rc;
- }
-#if CAPTURE
-
- dev_name = camHal->dev_name;
-
- rc = get_uvc_device(dev_name);
- if(rc || *dev_name == '\0'){
- ALOGE("%s: No UVC node found \n", __func__);
- return -1;
- }
-
- camHal->fd = open(dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
-
- if (camHal->fd < 0) {
- ALOGE("%s: Cannot open '%s'", __func__, dev_name);
- free(camHal);
- rc = -1;
- }else{
- rc = 0;
- }
-
-#else /* CAPTURE */
- rc = 0;
-#endif /* CAPTURE */
-
- device = &camHal->hw_dev;
- device->common.close = usbcam_close_camera_device;
- device->ops = &usbcam_camera_ops;
- device->priv = (void *)camHal;
- *hw_device = &(device->common);
-
- ALOGD("%s: camHal: %p", __func__, camHal);
- ALOGI("%s: X %d", __func__, rc);
-
- return rc;
-}
-
-extern "C" int usbcam_close_camera_device( hw_device_t *hw_dev)
-{
- ALOGI("%s: device =%p E", __func__, hw_dev);
- int rc = -1;
- camera_device_t *device = (camera_device_t *)hw_dev;
-
- if(device) {
- camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
- if(camHal) {
- rc = close(camHal->fd);
- if(rc < 0) {
- ALOGE("%s: close failed ", __func__);
- }
- camHal->fd = 0;
- delete camHal;
- }else{
- ALOGE("%s: camHal is NULL pointer ", __func__);
- }
- }
- ALOGI("%s: X device =%p, rc = %d", __func__, hw_dev, rc);
- return rc;
-}
-
-int usbcam_set_preview_window(struct camera_device * device,
- struct preview_stream_ops *window)
-{
- ALOGI("%s: E", __func__);
- int rc = 0;
- camera_hardware_t *camHal;
-
- VALIDATE_DEVICE_HDL(camHal, device, -1);
- Mutex::Autolock autoLock(camHal->lock);
-
- /* if window is already set, then de-init previous buffers */
- if(camHal->window){
- rc = deInitDisplayBuffers(camHal);
- if(rc < 0) {
- ALOGE("%s: deInitDisplayBuffers returned error", __func__);
- }
- }
- camHal->window = window;
-
- if(camHal->window){
- rc = initDisplayBuffers(camHal);
- if(rc < 0) {
- ALOGE("%s: initDisplayBuffers returned error", __func__);
- }
- }
- ALOGI("%s: X. rc = %d", __func__, rc);
- return rc;
-}
-
-void usbcam_set_CallBacks(struct camera_device * device,
- camera_notify_callback notify_cb,
- camera_data_callback data_cb,
- camera_data_timestamp_callback data_cb_timestamp,
- camera_request_memory get_memory,
- void *user)
-{
- ALOGI("%s: E", __func__);
- camera_hardware_t *camHal;
-
- if(device && device->priv){
- camHal = (camera_hardware_t *)device->priv;
- }else{
- ALOGE("%s: Null device or device->priv", __func__);
- return;
- }
-
- Mutex::Autolock autoLock(camHal->lock);
-
- camHal->notify_cb = notify_cb;
- camHal->data_cb = data_cb;
- camHal->data_cb_timestamp = data_cb_timestamp;
- camHal->get_memory = get_memory;
- camHal->cb_ctxt = user;
-
- ALOGI("%s: X", __func__);
-}
-
-void usbcam_enable_msg_type(struct camera_device * device, int32_t msg_type)
-{
- ALOGI("%s: E", __func__);
- ALOGI("%s: msg_type: %d", __func__, msg_type);
-
- camera_hardware_t *camHal;
-
- if(device && device->priv){
- camHal = (camera_hardware_t *)device->priv;
- }else{
- ALOGE("%s: Null device or device->priv", __func__);
- return;
- }
-
- Mutex::Autolock autoLock(camHal->lock);
-
- camHal->msgEnabledFlag |= msg_type;
-
- ALOGI("%s: X", __func__);
-}
-
-void usbcam_disable_msg_type(struct camera_device * device, int32_t msg_type)
-{
- ALOGI("%s: E", __func__);
- ALOGI("%s: msg_type: %d", __func__, msg_type);
-
- camera_hardware_t *camHal;
- if(device && device->priv){
- camHal = (camera_hardware_t *)device->priv;
- }else{
- ALOGE("%s: Null device or device->priv", __func__);
- return;
- }
-
- Mutex::Autolock autoLock(camHal->lock);
-
- camHal->msgEnabledFlag &= ~msg_type;
-
- ALOGI("%s: X", __func__);
-}
-
-int usbcam_msg_type_enabled(struct camera_device * device, int32_t msg_type)
-{
- ALOGI("%s: E", __func__);
-
- camera_hardware_t *camHal;
- if(device && device->priv){
- camHal = (camera_hardware_t *)device->priv;
- }else{
- ALOGE("%s: Null device or device->priv", __func__);
- return -1;
- }
-
- Mutex::Autolock autoLock(camHal->lock);
-
- ALOGI("%s: X", __func__);
- return (camHal->msgEnabledFlag & msg_type);
-}
-
-int usbcam_start_preview(struct camera_device * device)
-{
- ALOGI("%s: E", __func__);
-
- int rc = -1;
- camera_hardware_t *camHal = NULL;
-
- VALIDATE_DEVICE_HDL(camHal, device, -1);
- Mutex::Autolock autoLock(camHal->lock);
-
- /* If preivew is already running, nothing to be done */
- if(camHal->previewEnabledFlag){
- ALOGI("%s: Preview is already running", __func__);
- return 0;
- }
-
-#if CAPTURE
- rc = initUsbCamera(camHal, camHal->prevWidth,
- camHal->prevHeight, getPreviewCaptureFmt(camHal));
- if(rc < 0) {
- ALOGE("%s: Failed to intialize the device", __func__);
- }else{
- rc = startUsbCamCapture(camHal);
- if(rc < 0) {
- ALOGE("%s: Failed to startUsbCamCapture", __func__);
- }else{
- rc = launch_preview_thread(camHal);
- if(rc < 0) {
- ALOGE("%s: Failed to launch_preview_thread", __func__);
- }
- }
- }
-#else /* CAPTURE */
- rc = launch_preview_thread(camHal);
- if(rc < 0) {
- ALOGE("%s: Failed to launch_preview_thread", __func__);
- }
-#endif /* CAPTURE */
- /* if no errors, then set the flag */
- if(!rc)
- camHal->previewEnabledFlag = 1;
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-void usbcam_stop_preview(struct camera_device * device)
-{
- ALOGD("%s: E", __func__);
-
- int rc = 0;
- camera_hardware_t *camHal;
-
- if(device && device->priv){
- camHal = (camera_hardware_t *)device->priv;
- }else{
- ALOGE("%s: Null device or device->priv", __func__);
- return;
- }
-
- Mutex::Autolock autoLock(camHal->lock);
-
- rc = stopPreviewInternal(camHal);
- if(rc)
- ALOGE("%s: stopPreviewInternal returned error", __func__);
-
- ALOGI("%s: X", __func__);
- return;
-}
-
-/* This function is equivalent to is_preview_enabled */
-int usbcam_preview_enabled(struct camera_device * device)
-{
- ALOGI("%s: E", __func__);
- camera_hardware_t *camHal;
-
- if(device && device->priv){
- camHal = (camera_hardware_t *)device->priv;
- }else{
- ALOGE("%s: Null device or device->priv", __func__);
- return -1;
- }
- Mutex::Autolock autoLock(camHal->lock);
-
- ALOGI("%s: X", __func__);
- return camHal->previewEnabledFlag;
-}
-
-/* TBD */
-int usbcam_store_meta_data_in_buffers(struct camera_device * device, int enable)
-{
- ALOGI("%s: E", __func__);
- int rc = 0;
-
- ALOGI("%s: X", __func__);
- return rc;
-}
-
-/* TBD */
-int usbcam_start_recording(struct camera_device * device)
-{
- int rc = 0;
- ALOGD("%s: E", __func__);
-
- ALOGD("%s: X", __func__);
-
- return rc;
-}
-
-/* TBD */
-void usbcam_stop_recording(struct camera_device * device)
-{
- ALOGD("%s: E", __func__);
-
- ALOGD("%s: X", __func__);
-}
-
-/* TBD */
-int usbcam_recording_enabled(struct camera_device * device)
-{
- int rc = 0;
- ALOGD("%s: E", __func__);
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/* TBD */
-void usbcam_release_recording_frame(struct camera_device * device,
- const void *opaque)
-{
- ALOGV("%s: E", __func__);
-
- ALOGD("%s: X", __func__);
-}
-
-/* TBD */
-int usbcam_auto_focus(struct camera_device * device)
-{
- ALOGD("%s: E", __func__);
- int rc = 0;
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/* TBD */
-int usbcam_cancel_auto_focus(struct camera_device * device)
-{
- int rc = 0;
- ALOGD("%s: E", __func__);
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-int usbcam_take_picture(struct camera_device * device)
-{
- ALOGI("%s: E", __func__);
- int rc = 0;
- camera_hardware_t *camHal;
-
- VALIDATE_DEVICE_HDL(camHal, device, -1);
-
- Mutex::Autolock autoLock(camHal->lock);
-
- /* If take picture is already in progress, nothing t be done */
- if(camHal->takePictInProgress){
- ALOGI("%s: Take picture already in progress", __func__);
- return 0;
- }
-
- if(camHal->previewEnabledFlag)
- {
- rc = stopPreviewInternal(camHal);
- if(rc){
- ALOGE("%s: stopPreviewInternal returned error", __func__);
- }
- USB_CAM_CLOSE(camHal);
- camHal->prvwStoppedForPicture = 1;
- }
- /* TBD: Need to handle any dependencies on video recording state */
- rc = launchTakePictureThread(camHal);
- if(rc)
- ALOGE("%s: launchTakePictureThread error", __func__);
-
-#if 0
- /* This implementation requests preview thread to take picture */
- if(camHal->previewEnabledFlag)
- {
- camHal->prvwCmdPending++;
- camHal->prvwCmd = USB_CAM_PREVIEW_TAKEPIC;
- ALOGD("%s: Take picture command set ", __func__);
- }else{
- ALOGE("%s: Take picture without preview started!", __func__);
- rc = -1;
- }
-#endif
-
- if(!rc)
- camHal->takePictInProgress = 1;
-
- ALOGI("%s: X", __func__);
- return rc;
-}
-
-/* TBD */
-int usbcam_cancel_picture(struct camera_device * device)
-
-{
- ALOGI("%s: E", __func__);
- int rc = 0;
-
- ALOGI("%s: X", __func__);
- return rc;
-}
-
-int usbcam_set_parameters(struct camera_device * device, const char *params)
-
-{
- ALOGI("%s: E", __func__);
- int rc = 0;
- camera_hardware_t *camHal;
-
- VALIDATE_DEVICE_HDL(camHal, device, -1);
-
- Mutex::Autolock autoLock(camHal->lock);
-
- rc = usbCamSetParameters(camHal, params);
-
- ALOGI("%s: X", __func__);
- return rc;
-}
-
-char* usbcam_get_parameters(struct camera_device * device)
-{
- char *parms;
- ALOGI("%s: E", __func__);
-
- camera_hardware_t *camHal;
- VALIDATE_DEVICE_HDL(camHal, device, NULL);
-
- Mutex::Autolock autoLock(camHal->lock);
-
- parms = usbCamGetParameters(camHal);
-
- ALOGI("%s: X", __func__);
- return parms;
-}
-
-void usbcam_put_parameters(struct camera_device * device, char *parm)
-
-{
- ALOGI("%s: E", __func__);
-
- camera_hardware_t *camHal;
-
- if(device && device->priv){
- camHal = (camera_hardware_t *)device->priv;
- }else{
- ALOGE("%s: Null device or device->priv", __func__);
- return;
- }
-
- usbCamPutParameters(camHal, parm);
-
- ALOGI("%s: X", __func__);
- return;
-}
-
-/* TBD */
-int usbcam_send_command(struct camera_device * device,
- int32_t cmd, int32_t arg1, int32_t arg2)
-{
- int rc = 0;
- ALOGI("%s: E", __func__);
- ALOGI("%d", cmd);
-
- ALOGI("%s: X", __func__);
- return rc;
-}
-
-/* TBD */
-void usbcam_release(struct camera_device * device)
-{
- ALOGI("%s: E", __func__);
-#if 0
- Mutex::Autolock l(&mLock);
-
- switch(mPreviewState) {
- case QCAMERA_HAL_PREVIEW_STOPPED:
- break;
- case QCAMERA_HAL_PREVIEW_START:
- break;
- case QCAMERA_HAL_PREVIEW_STARTED:
- stopPreviewInternal();
- break;
- case QCAMERA_HAL_RECORDING_STARTED:
- stopRecordingInternal();
- stopPreviewInternal();
- break;
- case QCAMERA_HAL_TAKE_PICTURE:
- cancelPictureInternal();
- break;
- default:
- break;
- }
- mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
-#endif
- ALOGI("%s: X", __func__);
-}
-
-/* TBD */
-int usbcam_dump(struct camera_device * device, int fd)
-{
- ALOGI("%s: E", __func__);
- int rc = 0;
-
- ALOGI("%s: X", __func__);
- return rc;
-}
-/*****************************************************************************
-* Static function definitions below
-*****************************************************************************/
-
-/******************************************************************************/
-/* No in place conversion supported. Output buffer and input MUST should be */
-/* different input buffer for a 4x4 pixel video ***/
-/****** YUYVYUYV 00 01 02 03 04 05 06 07 ************/
-/****** YUYVYUYV 08 09 10 11 12 13 14 15 ************/
-/****** YUYVYUYV 16 17 18 19 20 21 22 23 ************/
-/****** YUYVYUYV 24 25 26 27 28 29 30 31 ************/
-/******************************************************************************/
-/* output generated by this function ******************************************/
-/************************** YYYY 00 02 04 06 ************/
-/************************** YYYY 08 10 12 14 ************/
-/************************** YYYY 16 18 20 22 ************/
-/************************** YYYY 24 26 28 30 ************/
-/************************** VUVU 03 01 07 05 ************/
-/************************** VUVU 19 17 23 21 ************/
-/******************************************************************************/
-
-static int convert_YUYV_to_420_NV12(char *in_buf, char *out_buf, int wd, int ht)
-{
- int rc =0;
- int row, col, uv_row;
-
- ALOGD("%s: E", __func__);
- /* Arrange Y */
- for(row = 0; row < ht; row++)
- for(col = 0; col < wd * 2; col += 2)
- {
- out_buf[row * wd + col / 2] = in_buf[row * wd * 2 + col];
- }
-
- /* Arrange UV */
- for(row = 0, uv_row = ht; row < ht; row += 2, uv_row++)
- for(col = 1; col < wd * 2; col += 4)
- {
- out_buf[uv_row * wd + col / 2]= in_buf[row * wd * 2 + col + 2];
- out_buf[uv_row * wd + col / 2 + 1] = in_buf[row * wd * 2 + col];
- }
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: initDisplayBuffers
- * Description: This function initializes the preview buffers
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-static int initDisplayBuffers(camera_hardware_t *camHal)
-{
- preview_stream_ops *mPreviewWindow;
- struct ion_fd_data ion_info_fd;
- int numMinUndequeuedBufs = 0;
- int rc = 0;
- int gralloc_usage = 0;
- int err;
- int color=30;
-
- ALOGD("%s: E", __func__);
-
-#if DISPLAY
- if(camHal == NULL) {
- ALOGE("%s: camHal = NULL", __func__);
- return -1;
- }
-
- mPreviewWindow = camHal->window;
- if(!mPreviewWindow) {
- ALOGE("%s: mPreviewWindow = NULL", __func__);
- return -1;
- }
-
- /************************************************************************/
- /* - get_min_undequeued_buffer_count */
- /* - set_buffer_count */
- /* - set_buffers_geometry */
- /* - set_usage */
- /* - dequeue all the display buffers */
- /* - cancel buffers: release w/o displaying */
- /************************************************************************/
-
- /************************************************************************/
- /* - get_min_undequeued_buffer_count */
- /************************************************************************/
- if(mPreviewWindow->get_min_undequeued_buffer_count) {
- rc = mPreviewWindow->get_min_undequeued_buffer_count(
- mPreviewWindow, &numMinUndequeuedBufs);
- if (0 != rc) {
- ALOGE("%s: get_min_undequeued_buffer_count returned error", __func__);
- }
- else
- ALOGD("%s: get_min_undequeued_buffer_count returned: %d ",
- __func__, numMinUndequeuedBufs);
- }
- else
- ALOGE("%s: get_min_undequeued_buffer_count is NULL pointer", __func__);
-
- /************************************************************************/
- /* - set_buffer_count */
- /************************************************************************/
- if(mPreviewWindow->set_buffer_count) {
- camHal->previewMem.buffer_count = numMinUndequeuedBufs
- + PRVW_DISP_BUF_CNT;
- rc = mPreviewWindow->set_buffer_count(
- mPreviewWindow,
- camHal->previewMem.buffer_count);
- if (rc != 0) {
- ALOGE("%s: set_buffer_count returned error", __func__);
- }else
- ALOGD("%s: set_buffer_count returned success", __func__);
- }else
- ALOGE("%s: set_buffer_count is NULL pointer", __func__);
-
- /************************************************************************/
- /* - set_buffers_geometry */
- /************************************************************************/
- if(mPreviewWindow->set_buffers_geometry) {
- rc = mPreviewWindow->set_buffers_geometry(mPreviewWindow,
- camHal->dispWidth,
- camHal->dispHeight,
- camHal->dispFormat);
- if (rc != 0) {
- ALOGE("%s: set_buffers_geometry returned error. %s (%d)",
- __func__, strerror(-rc), -rc);
- }else
- ALOGD("%s: set_buffers_geometry returned success", __func__);
- }else
- ALOGE("%s: set_buffers_geometry is NULL pointer", __func__);
-
- /************************************************************************/
- /* - set_usage */
- /************************************************************************/
- gralloc_usage = CAMERA_GRALLOC_HEAP_ID | CAMERA_GRALLOC_FALLBACK_HEAP_ID |
- GRALLOC_USAGE_PRIVATE_UNCACHED;
-
- if(mPreviewWindow->set_usage) {
- rc = mPreviewWindow->set_usage(mPreviewWindow, gralloc_usage);
- if (rc != 0) {
- ALOGE("%s: set_usage returned error", __func__);
- }else
- ALOGD("%s: set_usage returned success", __func__);
- }
- else
- ALOGE("%s: set_usage is NULL pointer", __func__);
-
- /************************************************************************/
- /* - dequeue all the display buffers */
- /************************************************************************/
- for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
- int stride;
- err = mPreviewWindow->dequeue_buffer(
- mPreviewWindow,
- &camHal->previewMem.buffer_handle[cnt],
- &camHal->previewMem.stride[cnt]);
- if(!err) {
- ALOGD("%s: dequeue buf: %p\n",
- __func__, camHal->previewMem.buffer_handle[cnt]);
-
- if(mPreviewWindow->lock_buffer) {
- err = mPreviewWindow->lock_buffer(
- mPreviewWindow,
- camHal->previewMem.buffer_handle[cnt]);
- ALOGD("%s: mPreviewWindow->lock_buffer success",
- __func__);
- }
-
- // lock the buffer using genlock
- ALOGD("%s: camera call genlock_lock, hdl=%p",
- __func__, (*camHal->previewMem.buffer_handle[cnt]));
-
- if (GENLOCK_NO_ERROR !=
- genlock_lock_buffer(
- (native_handle_t *) (*camHal->previewMem.buffer_handle[cnt]),
- GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT))
- {
- ALOGE("%s: genlock_lock_buffer(WRITE) failed",
- __func__);
- camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
- }else {
- ALOGD("%s: genlock_lock_buffer hdl =%p",
- __func__, *camHal->previewMem.buffer_handle[cnt]);
- camHal->previewMem.local_flag[cnt] = BUFFER_LOCKED;
- }
-
- /* Store this buffer details in the context */
- camHal->previewMem.private_buffer_handle[cnt] =
- (struct private_handle_t *) (*camHal->previewMem.buffer_handle[cnt]);
-
- ALOGD("%s: idx = %d, fd = %d, size = %d, offset = %d", __func__,
- cnt, camHal->previewMem.private_buffer_handle[cnt]->fd,
- camHal->previewMem.private_buffer_handle[cnt]->size,
- camHal->previewMem.private_buffer_handle[cnt]->offset);
-
- camHal->previewMem.camera_memory[cnt] =
- camHal->get_memory(
- camHal->previewMem.private_buffer_handle[cnt]->fd,
- camHal->previewMem.private_buffer_handle[cnt]->size,
- 1, camHal->cb_ctxt);
-
- ALOGD("%s: data = %p, size = %d, handle = %p", __func__,
- camHal->previewMem.camera_memory[cnt]->data,
- camHal->previewMem.camera_memory[cnt]->size,
- camHal->previewMem.camera_memory[cnt]->handle);
-
-#ifdef USE_ION
- /* In case of ION usage, open ION fd */
- camHal->previewMem.mem_info[cnt].main_ion_fd =
- open("/dev/ion", O_RDONLY);
- if (camHal->previewMem.mem_info[cnt].main_ion_fd < 0) {
- ALOGE("%s: failed: could not open ion device\n", __func__);
- }else{
- memset(&ion_info_fd, 0, sizeof(ion_info_fd));
- ion_info_fd.fd =
- camHal->previewMem.private_buffer_handle[cnt]->fd;
- if (ioctl(camHal->previewMem.mem_info[cnt].main_ion_fd,
- ION_IOC_IMPORT, &ion_info_fd) < 0) {
- ALOGE("ION import failed\n");
- }
- }
- camHal->previewMem.mem_info[cnt].fd =
- camHal->previewMem.private_buffer_handle[cnt]->fd;
- camHal->previewMem.mem_info[cnt].size =
- camHal->previewMem.private_buffer_handle[cnt]->size;
- camHal->previewMem.mem_info[cnt].handle = ion_info_fd.handle;
-
-#endif
- }
- else
- ALOGE("%s: dequeue buf %d failed \n", __func__, cnt);
- }
- /************************************************************************/
- /* - cancel buffers: queue w/o displaying */
- /************************************************************************/
- for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
- if (GENLOCK_FAILURE == genlock_unlock_buffer(
- (native_handle_t *)(*(camHal->previewMem.buffer_handle[cnt])))){
- ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__,
- (*(camHal->previewMem.buffer_handle[cnt])) );
- } else {
- camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
- ALOGD("%s: genlock_unlock_buffer success: hdl = %p",
- __func__, (*(camHal->previewMem.buffer_handle[cnt])));
- }
-
- err = mPreviewWindow->cancel_buffer(mPreviewWindow,
- (buffer_handle_t *)camHal->previewMem.buffer_handle[cnt]);
- if(!err) {
- ALOGD("%s: cancel_buffer successful: %p\n",
- __func__, camHal->previewMem.buffer_handle[cnt]);
- }else
- ALOGE("%s: cancel_buffer failed: %p\n", __func__,
- camHal->previewMem.buffer_handle[cnt]);
- }
-#else
- rc = 0;
-#endif /* #if DISPLAY */
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: deInitDisplayBuffers
- * Description: This function de-initializes all the display buffers allocated
- * in initDisplayBuffers
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-static int deInitDisplayBuffers(camera_hardware_t *camHal)
-{
- int rc = 0;
- preview_stream_ops *previewWindow;
-
- ALOGD("%s: E", __func__);
-
- if(!camHal || !camHal->window) {
- ALOGE("%s: camHal = NULL or window = NULL ", __func__);
- return -1;
- }
-
- previewWindow = camHal->window;
-
- /************************************************************************/
- /* - Release all buffers that were acquired using get_memory */
- /* - If using ION memory, free ION related resources */
- /* - genUnlock if buffer is genLocked */
- /* - Cancel buffers: queue w/o displaying */
- /************************************************************************/
-
-#if DISPLAY
- for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
-
- /* Release all buffers that were acquired using get_memory */
- camHal->previewMem.camera_memory[cnt]->release(
- camHal->previewMem.camera_memory[cnt]);
-
-#ifdef USE_ION
- /* If using ION memory, free ION related resources */
- struct ion_handle_data ion_handle;
- memset(&ion_handle, 0, sizeof(ion_handle));
- ion_handle.handle = camHal->previewMem.mem_info[cnt].handle;
- if (ioctl(camHal->previewMem.mem_info[cnt].main_ion_fd,
- ION_IOC_FREE, &ion_handle) < 0) {
- ALOGE("%s: ion free failed\n", __func__);
- }
- close(camHal->previewMem.mem_info[cnt].main_ion_fd);
-#endif
-
- /* genUnlock if buffer is genLocked */
- if(camHal->previewMem.local_flag[cnt] == BUFFER_LOCKED){
- if (GENLOCK_FAILURE == genlock_unlock_buffer(
- (native_handle_t *)(*(camHal->previewMem.buffer_handle[cnt])))){
- ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__,
- (*(camHal->previewMem.buffer_handle[cnt])) );
- } else {
- camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
- ALOGD("%s: genlock_unlock_buffer success: hdl = %p",
- __func__, (*(camHal->previewMem.buffer_handle[cnt])));
- }
- }
- /* cancel buffers: enqueue w/o displaying */
- rc = previewWindow->cancel_buffer(previewWindow,
- (buffer_handle_t *)camHal->previewMem.buffer_handle[cnt]);
- if(!rc) {
- ALOGD("%s: cancel_buffer successful: %p\n",
- __func__, camHal->previewMem.buffer_handle[cnt]);
- }else
- ALOGE("%s: cancel_buffer failed: %p\n", __func__,
- camHal->previewMem.buffer_handle[cnt]);
- }
-#endif /* #if DISPLAY */
- memset(&camHal->previewMem, 0, sizeof(camHal->previewMem));
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: getPreviewCaptureFmt
- * Description: This function implements the logic to decide appropriate
- * capture format from the USB camera
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * Capture format. Default (V4L2_PIX_FMT_MJPEG)
- *
- * Notes: none
- *****************************************************************************/
-static int getPreviewCaptureFmt(camera_hardware_t *camHal)
-{
- int i = 0, mjpegSupported = 0, h264Supported = 0;
- struct v4l2_fmtdesc fmtdesc;
-
- memset(&fmtdesc, 0, sizeof(v4l2_fmtdesc));
-
- /************************************************************************/
- /* - Query the camera for all supported formats */
- /* - Based on the resolution, pick an apporpriate format */
- /************************************************************************/
-
- /************************************************************************/
- /* - Query the camera for all supported formats */
- /************************************************************************/
- for(i = 0; ; i++) {
- fmtdesc.index = i;
- fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_ENUM_FMT, &fmtdesc)) {
- if (EINVAL == errno) {
- ALOGI("%s: Queried all formats till index %d\n", __func__, i);
- break;
- } else {
- ALOGE("%s: VIDIOC_ENUM_FMT failed", __func__);
- }
- }
- if(V4L2_PIX_FMT_MJPEG == fmtdesc.pixelformat){
- mjpegSupported = 1;
- ALOGI("%s: V4L2_PIX_FMT_MJPEG is supported", __func__ );
- }
- if(V4L2_PIX_FMT_H264 == fmtdesc.pixelformat){
- h264Supported = 1;
- ALOGI("%s: V4L2_PIX_FMT_H264 is supported", __func__ );
- }
-
- }
-
- /************************************************************************/
- /* - Based on the resolution, pick an apporpriate format */
- /************************************************************************/
- //V4L2_PIX_FMT_MJPEG; V4L2_PIX_FMT_YUYV; V4L2_PIX_FMT_H264 = 0x34363248;
- camHal->captureFormat = V4L2_PIX_FMT_YUYV;
- if(camHal->prevWidth > 640){
- if(1 == mjpegSupported)
- camHal->captureFormat = V4L2_PIX_FMT_MJPEG;
- else if(1 == h264Supported)
- camHal->captureFormat = V4L2_PIX_FMT_H264;
- }
- ALOGI("%s: Capture format chosen: 0x%x. 0x%x:YUYV. 0x%x:MJPEG. 0x%x: H264",
- __func__, camHal->captureFormat, V4L2_PIX_FMT_YUYV,
- V4L2_PIX_FMT_MJPEG, V4L2_PIX_FMT_H264);
-
- return camHal->captureFormat;
-}
-
-/******************************************************************************
- * Function: getMjpegdOutputFormat
- * Description: This function maps display pixel format enum to JPEG output
- * format enum
- *
- * Input parameters:
- * dispFormat - Display pixel format
- *
- * Return values:
- * (int)mjpegOutputFormat
- *
- * Notes: none
- *****************************************************************************/
-static int getMjpegdOutputFormat(int dispFormat)
-{
- int mjpegOutputFormat = YCRCBLP_H2V2;
-
- if(HAL_PIXEL_FORMAT_YCrCb_420_SP == dispFormat)
- mjpegOutputFormat = YCRCBLP_H2V2;
-
- return mjpegOutputFormat;
-}
-
-/******************************************************************************
- * Function: ioctlLoop
- * Description: This function is a blocking call around ioctl
- *
- * Input parameters:
- * fd - IOCTL fd
- * ioctlCmd - IOCTL command
- * args - IOCTL arguments
- *
- * Return values:
- * (int)mjpegOutputFormat
- *
- * Notes: none
- *****************************************************************************/
-static int ioctlLoop(int fd, int ioctlCmd, void *args)
-{
- int rc = -1;
-
- while(1)
- {
- rc = ioctl(fd, ioctlCmd, args);
- if(!((-1 == rc) && (EINTR == errno)))
- break;
- }
- return rc;
-}
-
-/******************************************************************************
- * Function: initV4L2mmap
- * Description: This function requests for V4L2 driver allocated buffers
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int initV4L2mmap(camera_hardware_t *camHal)
-{
- int rc = -1;
- struct v4l2_requestbuffers reqBufs;
- struct v4l2_buffer tempBuf;
-
- ALOGD("%s: E", __func__);
- memset(&reqBufs, 0, sizeof(v4l2_requestbuffers));
- reqBufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- reqBufs.memory = V4L2_MEMORY_MMAP;
- reqBufs.count = PRVW_CAP_BUF_CNT;
-
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_REQBUFS, &reqBufs)) {
- if (EINVAL == errno) {
- ALOGE("%s: does not support memory mapping\n", __func__);
- } else {
- ALOGE("%s: VIDIOC_REQBUFS failed", __func__);
- }
- }
- ALOGD("%s: VIDIOC_REQBUFS success", __func__);
-
- if (reqBufs.count < PRVW_CAP_BUF_CNT) {
- ALOGE("%s: Insufficient buffer memory on\n", __func__);
- }
-
- camHal->buffers =
- ( bufObj* ) calloc(reqBufs.count, sizeof(bufObj));
-
- if (!camHal->buffers) {
- ALOGE("%s: Out of memory\n", __func__);
- }
-
- /* Store the indexes in the context. Useful during releasing */
- for (camHal->n_buffers = 0;
- camHal->n_buffers < reqBufs.count;
- camHal->n_buffers++) {
-
- memset(&tempBuf, 0, sizeof(tempBuf));
-
- tempBuf.index = camHal->n_buffers;
- tempBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- tempBuf.memory = V4L2_MEMORY_MMAP;
-
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_QUERYBUF, &tempBuf))
- ALOGE("%s: VIDIOC_QUERYBUF failed", __func__);
-
- ALOGD("%s: VIDIOC_QUERYBUF success", __func__);
-
- camHal->buffers[camHal->n_buffers].len = tempBuf.length;
- camHal->buffers[camHal->n_buffers].data =
- mmap(NULL /* start anywhere */,
- tempBuf.length,
- PROT_READ | PROT_WRITE,
- MAP_SHARED,
- camHal->fd, tempBuf.m.offset);
-
- if (MAP_FAILED == camHal->buffers[camHal->n_buffers].data)
- ALOGE("%s: mmap failed", __func__);
- }
- ALOGD("%s: X", __func__);
- return 0;
-}
-
-/******************************************************************************
- * Function: unInitV4L2mmap
- * Description: This function unmaps the V4L2 driver buffers
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int unInitV4L2mmap(camera_hardware_t *camHal)
-{
- int i, rc = 0;
- ALOGD("%s: E", __func__);
-
- for (i = 0; i < camHal->n_buffers; i++)
- if (-1 == munmap(camHal->buffers[i].data, camHal->buffers[i].len)){
- ALOGE("%s: munmap failed for buffer: %d", __func__, i);
- rc = -1;
- }
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: initUsbCamera
- * Description: This function sets the resolution and pixel format of the
- * USB camera
- *
- * Input parameters:
- * camHal - camera HAL handle
- * width - picture width in pixels
- * height - picture height in pixels
- * pixelFormat - capture format for the camera
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int initUsbCamera(camera_hardware_t *camHal, int width, int height,
- int pixelFormat)
-{
- int rc = -1;
- struct v4l2_capability cap;
- struct v4l2_cropcap cropcap;
- struct v4l2_crop crop;
- struct v4l2_format v4l2format;
- unsigned int min;
-
- ALOGI("%s: E", __func__);
-
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_QUERYCAP, &cap)) {
- if (EINVAL == errno) {
- ALOGE( "%s: This is not V4L2 device\n", __func__);
- return -1;
- } else {
- ALOGE("%s: VIDIOC_QUERYCAP errno: %d", __func__, errno);
- }
- }
- ALOGD("%s: VIDIOC_QUERYCAP success", __func__);
-
- if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
- ALOGE("%s: This is not video capture device\n", __func__);
- return -1;
- }
-
- if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
- ALOGE("%s: This does not support streaming i/o\n", __func__);
- return -1;
- }
-
- /* Select video input, video standard and tune here. */
- memset(&cropcap, 0, sizeof(cropcap));
-
- cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
- if (0 == ioctlLoop(camHal->fd, VIDIOC_CROPCAP, &cropcap)) {
-
- /* reset to default */
- crop.c = cropcap.defrect;
- crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
- ALOGD("%s: VIDIOC_CROPCAP success", __func__);
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_S_CROP, &crop)) {
- switch (errno) {
- case EINVAL:
- /* Cropping not supported. */
- break;
- default:
- /* Errors ignored. */
- break;
- }
- }
- ALOGD("%s: VIDIOC_S_CROP success", __func__);
-
- } else {
- /* Errors ignored. */
- ALOGE("%s: VIDIOC_S_CROP failed", __func__);
- }
-
-
- memset(&v4l2format, 0, sizeof(v4l2format));
-
- v4l2format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- {
- v4l2format.fmt.pix.field = V4L2_FIELD_NONE;
- v4l2format.fmt.pix.pixelformat = pixelFormat;
- v4l2format.fmt.pix.width = width;
- v4l2format.fmt.pix.height = height;
-
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_S_FMT, &v4l2format))
- {
- ALOGE("%s: VIDIOC_S_FMT failed", __func__);
- return -1;
- }
- ALOGD("%s: VIDIOC_S_FMT success", __func__);
-
- /* Note VIDIOC_S_FMT may change width and height. */
- }
-
- /* TBR: In case of user pointer buffers, v4l2format.fmt.pix.sizeimage */
- /* might have to be calculated as per V4L2 sample application due to */
- /* open source driver bug */
-
- rc = initV4L2mmap(camHal);
- ALOGI("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: startUsbCamCapture
- * Description: This function queues buffer objects to the driver and sends
- * STREAM ON command to the USB camera driver
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int startUsbCamCapture(camera_hardware_t *camHal)
-{
- int rc = -1;
- unsigned int i;
- enum v4l2_buf_type v4l2BufType;
- ALOGD("%s: E", __func__);
-
- for (i = 0; i < camHal->n_buffers; ++i) {
- struct v4l2_buffer tempBuf;
-
- memset(&tempBuf, 0, sizeof(tempBuf));
- tempBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- tempBuf.memory = V4L2_MEMORY_MMAP;
- tempBuf.index = i;
-
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_QBUF, &tempBuf))
- ALOGE("%s: VIDIOC_QBUF for %d buffer failed", __func__, i);
- else
- ALOGD("%s: VIDIOC_QBUF for %d buffer success", __func__, i);
- }
-
- v4l2BufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_STREAMON, &v4l2BufType))
- ALOGE("%s: VIDIOC_STREAMON failed", __func__);
- else
- {
- ALOGD("%s: VIDIOC_STREAMON success", __func__);
- rc = 0;
- }
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: stopUsbCamCapture
- * Description: This function sends STREAM OFF command to the USB camera driver
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int stopUsbCamCapture(camera_hardware_t *camHal)
-{
- int rc = -1;
- unsigned int i;
- enum v4l2_buf_type v4l2BufType;
- ALOGD("%s: E", __func__);
-
- if(!camHal->fd){
- ALOGE("%s: camHal->fd = NULL ", __func__);
- return -1;
- }
- v4l2BufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_STREAMOFF, &v4l2BufType)){
- ALOGE("%s: VIDIOC_STREAMOFF failed", __func__);
- rc = -1;
- }else{
- ALOGD("%s: VIDIOC_STREAMOFF success", __func__);
- rc = 0;
- }
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: stopPreviewInternal
- * Description: This function sends EXIT command to prview loop thread,
- * stops usb camera capture and uninitializes MMAP. This function
- * assumes that calling function has locked camHal->lock
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int stopPreviewInternal(camera_hardware_t *camHal)
-{
- int rc = 0;
- ALOGD("%s: E", __func__);
-
- if(camHal->previewEnabledFlag)
- {
- camHal->prvwCmdPending++;
- camHal->prvwCmd = USB_CAM_PREVIEW_EXIT;
-
- /* yield lock while waiting for the preview thread to exit */
- camHal->lock.unlock();
- if(pthread_join(camHal->previewThread, NULL)){
- ALOGE("%s: Error in pthread_join preview thread", __func__);
- }
- camHal->lock.lock();
-
- if(stopUsbCamCapture(camHal)){
- ALOGE("%s: Error in stopUsbCamCapture", __func__);
- rc = -1;
- }
- if(unInitV4L2mmap(camHal)){
- ALOGE("%s: Error in stopUsbCamCapture", __func__);
- rc = -1;
- }
- camHal->previewEnabledFlag = 0;
- }
-
- ALOGD("%s: X, rc: %d", __func__, rc);
- return rc;
-}
-#if 1
-/******************************************************************************
- * Function: prvwThreadTakePictureInternal
- * Description: This function processes one camera frame to get JPEG encoded
- * picture.
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int prvwThreadTakePictureInternal(camera_hardware_t *camHal)
-{
- int rc = 0;
- QCameraHalMemInfo_t *mem_info;
- ALOGD("%s: E", __func__);
-
- /************************************************************************/
- /* - If requested for shutter notfication, callback */
- /* - Dequeue capture buffer from USB camera */
- /* - Send capture buffer to JPEG encoder for JPEG compression */
- /* - If jpeg frames callback is requested, callback with jpeg buffers */
- /* - Enqueue capture buffer back to USB camera */
- /************************************************************************/
-
- /************************************************************************/
- /* - If requested for shutter notfication, callback */
- /************************************************************************/
- if (camHal->msgEnabledFlag & CAMERA_MSG_SHUTTER){
- camHal->lock.unlock();
- camHal->notify_cb(CAMERA_MSG_SHUTTER, 0, 0, camHal->cb_ctxt);
- camHal->lock.lock();
- }
-
-#if CAPTURE
- /************************************************************************/
- /* - Dequeue capture buffer from USB camera */
- /************************************************************************/
- if (0 == get_buf_from_cam(camHal))
- ALOGD("%s: get_buf_from_cam success", __func__);
- else
- ALOGE("%s: get_buf_from_cam error", __func__);
-#endif
-
- /************************************************************************/
- /* - Send capture buffer to JPEG encoder for JPEG compression */
- /************************************************************************/
- /* Optimization: If camera capture is JPEG format, need not compress! */
- /* instead, just data copy from capture buffer to picture buffer */
- if(V4L2_PIX_FMT_MJPEG == camHal->captureFormat){
- /* allocate heap memory for JPEG output */
- mem_info = &camHal->pictMem.mem_info[0];
- mem_info->size = camHal->curCaptureBuf.bytesused;
- /* TBD: allocate_ion_memory
- rc = QCameraHardwareInterface::allocate_ion_memory(mem_info,
- ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
- (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
- */
- if(rc)
- ALOGE("%s: ION memory allocation failed", __func__);
-
- camHal->pictMem.camera_memory[0] = camHal->get_memory(
- mem_info->fd, mem_info->size, 1, camHal->cb_ctxt);
- if(!camHal->pictMem.camera_memory[0])
- ALOGE("%s: get_mem failed", __func__);
-
- memcpy( camHal->pictMem.camera_memory[0]->data,
- (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
- camHal->curCaptureBuf.bytesused);
- }
-
- /************************************************************************/
- /* - If jpeg frames callback is requested, callback with jpeg buffers */
- /************************************************************************/
- if ((camHal->msgEnabledFlag & CAMERA_MSG_COMPRESSED_IMAGE) &&
- (camHal->data_cb)){
- camHal->lock.unlock();
- camHal->data_cb(CAMERA_MSG_COMPRESSED_IMAGE,
- camHal->pictMem.camera_memory[0],
- 0, NULL, camHal->cb_ctxt);
- camHal->lock.lock();
- }
- /* release heap memory after the call back */
- if(camHal->pictMem.camera_memory[0])
- camHal->pictMem.camera_memory[0]->release(
- camHal->pictMem.camera_memory[0]);
-
- /* TBD: deallocate_ion_memory */
- //rc = QCameraHardwareInterface::deallocate_ion_memory(mem_info);
- if(rc)
- ALOGE("%s: ION memory de-allocation failed", __func__);
-
-#if CAPTURE
- /************************************************************************/
- /* - Enqueue capture buffer back to USB camera */
- /************************************************************************/
- if(0 == put_buf_to_cam(camHal)) {
- ALOGD("%s: put_buf_to_cam success", __func__);
- }
- else
- ALOGE("%s: put_buf_to_cam error", __func__);
-#endif
-
- ALOGD("%s: X, rc: %d", __func__, rc);
- return rc;
-}
-#endif //#if 0
-/******************************************************************************
- * Function: cache_ops
- * Description: This function calls ION ioctl for cache related operations
- *
- * Input parameters:
- * mem_info - QCameraHalMemInfo_t structure with ION info
- * buf_ptr - Buffer pointer that needs to be cache operated
- * cmd - Cache command - clean/invalidate
- *
- * Return values:
- * MM_CAMERA_OK No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-int cache_ops(QCameraHalMemInfo_t *mem_info,
- void *buf_ptr,
- unsigned int cmd)
-{
- struct ion_flush_data cache_inv_data;
- struct ion_custom_data custom_data;
- int ret = MM_CAMERA_OK;
-
-#ifdef USE_ION
- if (NULL == mem_info) {
- ALOGE("%s: mem_info is NULL, return here", __func__);
- return -1;
- }
-
- memset(&cache_inv_data, 0, sizeof(cache_inv_data));
- memset(&custom_data, 0, sizeof(custom_data));
- cache_inv_data.vaddr = buf_ptr;
- cache_inv_data.fd = mem_info->fd;
- cache_inv_data.handle = mem_info->handle;
- cache_inv_data.length = mem_info->size;
- custom_data.cmd = cmd;
- custom_data.arg = (unsigned long)&cache_inv_data;
-
- ALOGD("%s: addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d",
- __func__, cache_inv_data.vaddr, cache_inv_data.fd,
- cache_inv_data.handle, cache_inv_data.length,
- mem_info->main_ion_fd);
- if(mem_info->main_ion_fd > 0) {
- if(ioctl(mem_info->main_ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
- ALOGE("%s: Cache Invalidate failed\n", __func__);
- ret = -1;
- }
- }
-#endif
-
- return ret;
-}
-
-/******************************************************************************
- * Function: get_buf_from_cam
- * Description: This funtions gets/acquires 1 capture buffer from the camera
- * driver. The fetched buffer is stored in curCaptureBuf
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int get_buf_from_cam(camera_hardware_t *camHal)
-{
- int rc = -1;
-
- ALOGD("%s: E", __func__);
- {
- memset(&camHal->curCaptureBuf, 0, sizeof(camHal->curCaptureBuf));
-
- camHal->curCaptureBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- camHal->curCaptureBuf.memory = V4L2_MEMORY_MMAP;
-
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_DQBUF, &camHal->curCaptureBuf)){
- switch (errno) {
- case EAGAIN:
- ALOGE("%s: EAGAIN error", __func__);
- return 1;
-
- case EIO:
- /* Could ignore EIO, see spec. */
-
- /* fall through */
-
- default:
- ALOGE("%s: VIDIOC_DQBUF error", __func__);
- }
- }
- else
- {
- rc = 0;
- ALOGD("%s: VIDIOC_DQBUF: %d successful, %d bytes",
- __func__, camHal->curCaptureBuf.index,
- camHal->curCaptureBuf.bytesused);
- }
- }
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: put_buf_to_cam
- * Description: This funtion puts/releases 1 capture buffer back to the camera
- * driver
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int put_buf_to_cam(camera_hardware_t *camHal)
-{
- ALOGD("%s: E", __func__);
-
- camHal->curCaptureBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- camHal->curCaptureBuf.memory = V4L2_MEMORY_MMAP;
-
-
- if (-1 == ioctlLoop(camHal->fd, VIDIOC_QBUF, &camHal->curCaptureBuf))
- {
- ALOGE("%s: VIDIOC_QBUF failed ", __func__);
- return 1;
- }
- ALOGD("%s: X", __func__);
- return 0;
-}
-
-/******************************************************************************
- * Function: put_buf_to_cam
- * Description: This funtion gets/acquires 1 display buffer from the display
- * window
- *
- * Input parameters:
- * camHal - camera HAL handle
- * buffer_id - Buffer id pointer. The id of buffer obtained
- * by this function is returned in this arg
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int get_buf_from_display(camera_hardware_t *camHal, int *buffer_id)
-{
- int err = 0;
- preview_stream_ops *mPreviewWindow = NULL;
- int stride = 0, cnt = 0;
- buffer_handle_t *buffer_handle = NULL;
- struct private_handle_t *private_buffer_handle = NULL;
-
- ALOGD("%s: E", __func__);
-
- if (camHal == NULL) {
- ALOGE("%s: camHal = NULL", __func__);
- return -1;
- }
-
- mPreviewWindow = camHal->window;
- if( mPreviewWindow == NULL) {
- ALOGE("%s: mPreviewWindow = NULL", __func__);
- return -1;
- }
- err = mPreviewWindow->dequeue_buffer(mPreviewWindow,
- &buffer_handle,
- &stride);
- if(!err) {
- ALOGD("%s: dequeue buf buffer_handle: %p\n", __func__, buffer_handle);
-
- ALOGD("%s: mPreviewWindow->lock_buffer: %p",
- __func__, mPreviewWindow->lock_buffer);
- if(mPreviewWindow->lock_buffer) {
- err = mPreviewWindow->lock_buffer(mPreviewWindow, buffer_handle);
- ALOGD("%s: mPreviewWindow->lock_buffer success", __func__);
- }
- ALOGD("%s: camera call genlock_lock, hdl=%p",
- __func__, (*buffer_handle));
-
- if (GENLOCK_NO_ERROR !=
- genlock_lock_buffer((native_handle_t *)(*buffer_handle),
- GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT)) {
- ALOGE("%s: genlock_lock_buffer(WRITE) failed", __func__);
- } else {
- ALOGD("%s: genlock_lock_buffer hdl =%p", __func__, *buffer_handle);
- }
-
- private_buffer_handle = (struct private_handle_t *)(*buffer_handle);
-
- ALOGD("%s: fd = %d, size = %d, offset = %d, stride = %d",
- __func__, private_buffer_handle->fd,
- private_buffer_handle->size, private_buffer_handle->offset, stride);
-
- for(cnt = 0; cnt < camHal->previewMem.buffer_count + 2; cnt++) {
- if(private_buffer_handle->fd ==
- camHal->previewMem.private_buffer_handle[cnt]->fd) {
- *buffer_id = cnt;
- ALOGD("%s: deQueued fd = %d, index: %d",
- __func__, private_buffer_handle->fd, cnt);
- break;
- }
- }
- }
- else
- ALOGE("%s: dequeue buf failed \n", __func__);
-
- ALOGD("%s: X", __func__);
-
- return err;
-}
-
-/******************************************************************************
- * Function: put_buf_to_display
- * Description: This funtion puts/enqueues 1 buffer back to the display window
- *
- * Input parameters:
- * camHal - camera HAL handle
- * buffer_id - id of the buffer that needs to be enqueued
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int put_buf_to_display(camera_hardware_t *camHal, int buffer_id)
-{
- int err = 0;
- preview_stream_ops *mPreviewWindow;
-
- ALOGD("%s: E", __func__);
-
- if (camHal == NULL) {
- ALOGE("%s: camHal = NULL", __func__);
- return -1;
- }
-
- mPreviewWindow = camHal->window;
- if( mPreviewWindow == NULL) {
- ALOGE("%s: mPreviewWindow = NULL", __func__);
- return -1;
- }
-
- if (GENLOCK_FAILURE ==
- genlock_unlock_buffer(
- (native_handle_t *)
- (*(camHal->previewMem.buffer_handle[buffer_id])))) {
- ALOGE("%s: genlock_unlock_buffer failed: hdl =%p",
- __func__, (*(camHal->previewMem.buffer_handle[buffer_id])) );
- } else {
- ALOGD("%s: genlock_unlock_buffer success: hdl =%p",
- __func__, (*(camHal->previewMem.buffer_handle[buffer_id])) );
- }
-
- /* Cache clean the output buffer so that cache is written back */
- cache_ops(&camHal->previewMem.mem_info[buffer_id],
- (void *)camHal->previewMem.camera_memory[buffer_id]->data,
- ION_IOC_CLEAN_CACHES);
- /*
- cache_ops(&camHal->previewMem.mem_info[buffer_id],
- (void *)camHal->previewMem.camera_memory[buffer_id]->data,
- ION_IOC_CLEAN_INV_CACHES);
-*/
- err = mPreviewWindow->enqueue_buffer(mPreviewWindow,
- (buffer_handle_t *)camHal->previewMem.buffer_handle[buffer_id]);
- if(!err) {
- ALOGD("%s: enqueue buf successful: %p\n",
- __func__, camHal->previewMem.buffer_handle[buffer_id]);
- }else
- ALOGE("%s: enqueue buf failed: %p\n",
- __func__, camHal->previewMem.buffer_handle[buffer_id]);
-
- ALOGD("%s: X", __func__);
-
- return err;
-}
-
-/******************************************************************************
- * Function: put_buf_to_display
- * Description: This funtion transfers the content from capture buffer to
- * preiew display buffer after appropriate conversion
- *
- * Input parameters:
- * camHal - camera HAL handle
- * buffer_id - id of the buffer that needs to be enqueued
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int convert_data_frm_cam_to_disp(camera_hardware_t *camHal, int buffer_id)
-{
- int rc = -1;
-
- if(!camHal) {
- ALOGE("%s: camHal is NULL", __func__);
- return -1;
- }
- /* If input and output are raw formats, but different color format, */
- /* call color conversion routine */
- if( (V4L2_PIX_FMT_YUYV == camHal->captureFormat) &&
- (HAL_PIXEL_FORMAT_YCrCb_420_SP == camHal->dispFormat))
- {
- convert_YUYV_to_420_NV12(
- (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
- (char *)camHal->previewMem.camera_memory[buffer_id]->data,
- camHal->prevWidth,
- camHal->prevHeight);
- ALOGD("%s: Copied %d bytes from camera buffer %d to display buffer: %d",
- __func__, camHal->curCaptureBuf.bytesused,
- camHal->curCaptureBuf.index, buffer_id);
- rc = 0;
- }
-
- /* If camera buffer is MJPEG encoded, call mjpeg decode call */
- if(V4L2_PIX_FMT_MJPEG == camHal->captureFormat)
- {
- if(NULL == camHal->mjpegd)
- {
- rc = mjpegDecoderInit(&camHal->mjpegd);
- if(rc < 0)
- ALOGE("%s: mjpegDecoderInit Error: %d", __func__, rc);
- }
- if(camHal->mjpegd)
- {
- rc = mjpegDecode(
- (void*)camHal->mjpegd,
- (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
- camHal->curCaptureBuf.bytesused,
- (char *)camHal->previewMem.camera_memory[buffer_id]->data,
- (char *)camHal->previewMem.camera_memory[buffer_id]->data +
- camHal->prevWidth * camHal->prevHeight,
- getMjpegdOutputFormat(camHal->dispFormat));
- if(rc < 0)
- ALOGE("%s: mjpegDecode Error: %d", __func__, rc);
- }
- }
- return rc;
-}
-
-/******************************************************************************
- * Function: launch_preview_thread
- * Description: This is a wrapper function to start preview thread
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int launch_preview_thread(camera_hardware_t *camHal)
-{
- ALOGD("%s: E", __func__);
- int rc = 0;
-
- if(!camHal) {
- ALOGE("%s: camHal is NULL", __func__);
- return -1;
- }
-
- pthread_attr_t attr;
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
- pthread_create(&camHal->previewThread, &attr, previewloop, camHal);
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: launch_preview_thread
- * Description: This is thread funtion for preivew loop
- *
- * Input parameters:
- * hcamHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static void * previewloop(void *hcamHal)
-{
- int rc;
- int buffer_id = 0;
- pid_t tid = 0;
- camera_hardware_t *camHal = NULL;
- int msgType = 0;
- camera_memory_t *data = NULL;
- camera_frame_metadata_t *metadata= NULL;
- camera_memory_t *previewMem = NULL;
-
- camHal = (camera_hardware_t *)hcamHal;
- ALOGD("%s: E", __func__);
-
- if(!camHal) {
- ALOGE("%s: camHal is NULL", __func__);
- return NULL ;
- }
-
- tid = gettid();
- /* TBR: Set appropriate thread priority */
- androidSetThreadPriority(tid, ANDROID_PRIORITY_NORMAL);
- prctl(PR_SET_NAME, (unsigned long)"Camera HAL preview thread", 0, 0, 0);
-
- /************************************************************************/
- /* - Time wait (select) on camera fd for input read buffer */
- /* - Check if any preview thread commands are set. If set, process */
- /* - Dequeue display buffer from surface */
- /* - Dequeue capture buffer from USB camera */
- /* - Convert capture format to display format */
- /* - If preview frames callback is requested, callback with prvw buffers*/
- /* - Enqueue display buffer back to surface */
- /* - Enqueue capture buffer back to USB camera */
- /************************************************************************/
- while(1) {
- fd_set fds;
- struct timeval tv;
- int r = 0;
-
- FD_ZERO(&fds);
-#if CAPTURE
- FD_SET(camHal->fd, &fds);
-#endif /* CAPTURE */
-
- /************************************************************************/
- /* - Time wait (select) on camera fd for input read buffer */
- /************************************************************************/
- tv.tv_sec = 0;
- tv.tv_usec = 500000;
-
- ALOGD("%s: b4 select on camHal->fd + 1,fd: %d", __func__, camHal->fd);
-#if CAPTURE
- r = select(camHal->fd + 1, &fds, NULL, NULL, &tv);
-#else
- r = select(1, NULL, NULL, NULL, &tv);
-#endif /* CAPTURE */
- ALOGD("%s: after select : %d", __func__, camHal->fd);
-
- if (-1 == r) {
- if (EINTR == errno)
- continue;
- ALOGE("%s: FDSelect error: %d", __func__, errno);
- }
-
- if (0 == r) {
- ALOGD("%s: select timeout\n", __func__);
- }
-
- /* Protect the context for one iteration of preview loop */
- /* this gets unlocked at the end of the while */
- Mutex::Autolock autoLock(camHal->lock);
-
- /************************************************************************/
- /* - Check if any preview thread commands are set. If set, process */
- /************************************************************************/
- if(camHal->prvwCmdPending)
- {
- /* command is serviced. Hence command pending = 0 */
- camHal->prvwCmdPending--;
- //sempost(ack)
- if(USB_CAM_PREVIEW_EXIT == camHal->prvwCmd){
- /* unlock before exiting the thread */
- camHal->lock.unlock();
- ALOGI("%s: Exiting coz USB_CAM_PREVIEW_EXIT", __func__);
- return (void *)0;
- }else if(USB_CAM_PREVIEW_TAKEPIC == camHal->prvwCmd){
- rc = prvwThreadTakePictureInternal(camHal);
- if(rc)
- ALOGE("%s: prvwThreadTakePictureInternal returned error",
- __func__);
- }
- }
-
- /* Null check on preview window. If null, sleep */
- if(!camHal->window) {
- ALOGD("%s: sleeping coz camHal->window = NULL",__func__);
- camHal->lock.unlock();
- sleep(2);
- continue;
- }
-#if DISPLAY
- /************************************************************************/
- /* - Dequeue display buffer from surface */
- /************************************************************************/
- if(0 == get_buf_from_display(camHal, &buffer_id)) {
- ALOGD("%s: get_buf_from_display success: %d",
- __func__, buffer_id);
- }else{
- ALOGE("%s: get_buf_from_display failed. Skipping the loop",
- __func__);
- continue;
- }
-#endif
-
-#if CAPTURE
- /************************************************************************/
- /* - Dequeue capture buffer from USB camera */
- /************************************************************************/
- if (0 == get_buf_from_cam(camHal))
- ALOGD("%s: get_buf_from_cam success", __func__);
- else
- ALOGE("%s: get_buf_from_cam error", __func__);
-#endif
-
-#if FILE_DUMP_CAMERA
- /* Debug code to dump frames from camera */
- {
- static int frame_cnt = 0;
- /* currently hardcoded for Bytes-Per-Pixel = 1.5 */
- fileDump("/data/USBcam.yuv",
- (char*)camHal->buffers[camHal->curCaptureBuf.index].data,
- camHal->prevWidth * camHal->prevHeight * 1.5,
- &frame_cnt);
- }
-#endif
-
-#if MEMSET
- static int color = 30;
- color += 50;
- if(color > 200) {
- color = 30;
- }
- ALOGE("%s: Setting to the color: %d\n", __func__, color);
- /* currently hardcoded for format of type Bytes-Per-Pixel = 1.5 */
- memset(camHal->previewMem.camera_memory[buffer_id]->data,
- color, camHal->dispWidth * camHal->dispHeight * 1.5 + 2 * 1024);
-#else
- convert_data_frm_cam_to_disp(camHal, buffer_id);
- ALOGD("%s: Copied data to buffer_id: %d", __func__, buffer_id);
-#endif
-
-#if FILE_DUMP_B4_DISP
- /* Debug code to dump display buffers */
- {
- static int frame_cnt = 0;
- /* currently hardcoded for Bytes-Per-Pixel = 1.5 */
- fileDump("/data/display.yuv",
- (char*) camHal->previewMem.camera_memory[buffer_id]->data,
- camHal->dispWidth * camHal->dispHeight * 1.5,
- &frame_cnt);
- ALOGD("%s: Written buf_index: %d ", __func__, buffer_id);
- }
-#endif
-
-#if DISPLAY
- /************************************************************************/
- /* - Enqueue display buffer back to surface */
- /************************************************************************/
- if(0 == put_buf_to_display(camHal, buffer_id)) {
- ALOGD("%s: put_buf_to_display success: %d", __func__, buffer_id);
- }
- else
- ALOGE("%s: put_buf_to_display error", __func__);
-#endif
-
-#if CAPTURE
- /************************************************************************/
- /* - Enqueue capture buffer back to USB camera */
- /************************************************************************/
- if(0 == put_buf_to_cam(camHal)) {
- ALOGD("%s: put_buf_to_cam success", __func__);
- }
- else
- ALOGE("%s: put_buf_to_cam error", __func__);
-#endif
-
-#if CALL_BACK
- /************************************************************************/
- /* - If preview frames callback is requested, callback with prvw buffers*/
- /************************************************************************/
- /* TBD: change the 1.5 hardcoding to Bytes Per Pixel */
- int previewBufSize = camHal->prevWidth * camHal->prevHeight * 1.5;
-
- msgType |= CAMERA_MSG_PREVIEW_FRAME;
-
- if(previewBufSize !=
- camHal->previewMem.private_buffer_handle[buffer_id]->size) {
-
- previewMem = camHal->get_memory(
- camHal->previewMem.private_buffer_handle[buffer_id]->fd,
- previewBufSize,
- 1,
- camHal->cb_ctxt);
-
- if (!previewMem || !previewMem->data) {
- ALOGE("%s: get_memory failed.\n", __func__);
- }
- else {
- data = previewMem;
- ALOGD("%s: GetMemory successful. data = %p",
- __func__, data);
- ALOGD("%s: previewBufSize = %d, priv_buf_size: %d",
- __func__, previewBufSize,
- camHal->previewMem.private_buffer_handle[buffer_id]->size);
- }
- }
- else{
- data = camHal->previewMem.camera_memory[buffer_id];
- ALOGD("%s: No GetMemory, no invalid fmt. data = %p, idx=%d",
- __func__, data, buffer_id);
- }
- /* Unlock and lock around the callback. */
- /* Sometimes 'disable_msg' is issued in the callback context, */
- /* leading to deadlock */
- camHal->lock.unlock();
- if((camHal->msgEnabledFlag & CAMERA_MSG_PREVIEW_FRAME) &&
- camHal->data_cb){
- ALOGD("%s: before data callback", __func__);
- camHal->data_cb(msgType, data, 0,metadata, camHal->cb_ctxt);
- ALOGD("%s: after data callback: %p", __func__, camHal->data_cb);
- }
- camHal->lock.lock();
- if (previewMem)
- previewMem->release(previewMem);
-#endif
-
- }//while(1)
- ALOGD("%s: X", __func__);
- return (void *)0;
-}
-
-/******************************************************************************
- * Function: get_uvc_device
- * Description: This function loops through /dev/video entries and probes with
- * UVCIOC query. If the device responds to the query, then it is
- * detected as UVC webcam
- * Input parameters:
- * devname - String pointer. The function return dev entry
- * name in this string
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-static int get_uvc_device(char *devname)
-{
- char temp_devname[FILENAME_LENGTH];
- FILE *fp = NULL;
- int i = 0, ret = 0, fd;
-
- ALOGD("%s: E", __func__);
-#if 1
- strncpy(devname, "/dev/video1", FILENAME_LENGTH);
-
-/*
- struct stat st;
-
- strncpy(dev_name, "/dev/video1", FILENAME_LENGTH);
- if (-1 == stat(dev_name, &st)) {
- ALOGE("%s: Cannot identify '%s': %d, %s\n",
- __func__, dev_name, errno, strerror(errno));
- }
-
- if (!S_ISCHR(st.st_mode)) {
- ALOGE("%s: %s is no device\n", __func__, dev_name);
- rc = -1;
- }
-*/
-
-#else
-
- *devname = '\0';
- /************************************************************************/
- /* - List all /dev/video* entries to a file */
- /* - Open the video list file and loop through the list */
- /* - Send UVC specific control query and check the response */
- /* - If device responds to the query as success, device is UVC webcam */
- /************************************************************************/
-
- /************************************************************************/
- /* - List all /dev/video* entries to a file */
- /************************************************************************/
- /* Temporarily commented out. This logic doesnt seem to be working */
- //system("ls > /data/video_dev_list");
-
- /************************************************************************/
- /* - Open the video list file and loop through the list */
- /************************************************************************/
-
- /* Temporarily commented out. This logic doesnt seem to be working */
- /*
- fp = fopen("/data/video_dev_list", "rb");
- if(!fp) {
- ALOGE("%s: Error in opening /data/video_dev_list ", __func__);
- return -1;
- }
- */
-
- /* Temporarily commented out. Looping logic changed due to issue in */
- /* executing system("ls > /data/video_dev_list") */
- //while(EOF != fscanf(fp, "%s", devname)){
- while(1){
- uvc_xu_control_query xqry;
-
- sprintf(temp_devname, "/dev/video%d", i);
- ALOGD("%s: Probing %s \n", __func__, temp_devname);
-
- fd = open(temp_devname, O_RDWR /* required */ | O_NONBLOCK, 0);
- if(-1 != fd){
- memset(&xqry, 0, sizeof(uvc_xu_control_query));
- ret = ioctl(fd, UVCIOC_CTRL_QUERY, &xqry);
- ALOGD("%s: UVCIOC ret: %d, errno: %d", __func__, ret, errno);
- /****************************************************************/
- /* if UVCIOC is executed successfully, ret = 0 */
- /* if UVCIOC is executed but Control Unit = 0 does not exist, */
- /* ret = -1 and errno = ENOENT */
- /* if UVCIOC doesnot execute, ret = -1 and errno = EINVAL */
- /****************************************************************/
- if((0 == ret) || (ret && (ENOENT == errno))){
- ALOGD("%s: Found UVC node: %s\n", __func__, temp_devname);
- strncpy(devname, temp_devname, FILENAME_LENGTH);
- /* Exit the loop at the first UVC node detection */
- break;
- }
- close(fd);
- }
- /* Temporarily logic to probe video0 to video10 nodes */
- if(i++ > 10)
- {
- if(fp)
- fclose(fp);
- break;
- }
- }
-#endif /* #if 0 */
- ALOGD("%s: X", __func__);
- return 0;
-} /* get_uvc_device */
-
-/******************************************************************************
- * Function: fileDump
- * Description: This is a utility function to dump buffers into a file
- *
- * Input parameters:
- * fn - File name string
- * data - pointer to character buffer that needs to be dumped
- * length - Length of the buffer to be dumped
- * frm_cnt - Pointer to frame count. This count is incremented by this
- * function on successful file write
- * Return values:
- * 0 Success
- * -1 Error
- * Notes: none
- *****************************************************************************/
-static int fileDump(const char* fn, char* data, int length, int* frm_cnt)
-{
-
- FILE *fp = NULL;
- if (0 == *frm_cnt) {
- fp = fopen(fn, "wb");
- if (NULL == fp) {
- ALOGE("%s: Error in opening %s", __func__, fn);
- }
- fclose(fp);
- }
- fp = fopen(fn, "ab");
- if (NULL == fp) {
- ALOGE("%s: Error in opening %s", __func__, fn);
- }
- fwrite(data, 1, length, fp);
- fclose(fp);
- (*frm_cnt)++;
- ALOGD("%s: Written %d bytes for frame:%d, in %s",
- __func__, length, *frm_cnt, fn);
-
- return 0;
-}
-
-/******************************************************************************
- * Function: launchTakePictureThread
- * Description: This is a wrapper function to start take picture thread
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int launchTakePictureThread(camera_hardware_t *camHal)
-{
- ALOGD("%s: E", __func__);
- int rc = 0;
-
- if(!camHal) {
- ALOGE("%s: camHal is NULL", __func__);
- return -1;
- }
-
- pthread_attr_t attr;
- pthread_attr_init(&attr);
- /* create the thread in detatched state, when the thread exits all */
- /* memory resources are freed up */
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- pthread_create(&camHal->takePictureThread, &attr, takePictureThread, camHal);
-
- ALOGD("%s: X", __func__);
- return rc;
-}
-
-/******************************************************************************
- * Function: takePictureThread
- * Description: This function is associated with take picture thread
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static void * takePictureThread(void *hcamHal)
-{
- int rc = 0;
- int buffer_id = 0;
- pid_t tid = 0;
- camera_hardware_t *camHal = NULL;
- int msgType = 0;
- int jpegLength = 0;
- QCameraHalMemInfo_t *mem_info = NULL;
-
- camHal = (camera_hardware_t *)hcamHal;
- ALOGI("%s: E", __func__);
-
- if(!camHal) {
- ALOGE("%s: camHal is NULL", __func__);
- return NULL ;
- }
-
- tid = gettid();
- /* TBR: Set appropriate thread priority */
- androidSetThreadPriority(tid, ANDROID_PRIORITY_NORMAL);
- prctl(PR_SET_NAME, (unsigned long)"Camera HAL preview thread", 0, 0, 0);
-
- /************************************************************************/
- /* - If requested for shutter notfication, notify */
- /* - Initialize USB camera with snapshot parameters */
- /* - Time wait (select) on camera fd for camera frame availability */
- /* - Dequeue capture buffer from USB camera */
- /* - Send capture buffer to JPEG encoder for JPEG compression */
- /* - If jpeg frames callback is requested, callback with jpeg buffers */
- /* - Enqueue capture buffer back to USB camera */
- /* - Free USB camera resources and close camera */
- /* - If preview was stopped for taking picture, restart the preview */
- /************************************************************************/
-
- Mutex::Autolock autoLock(camHal->lock);
- /************************************************************************/
- /* - If requested for shutter notfication, notify */
- /************************************************************************/
-#if 0 /* TBD: Temporarily commented out due to an issue. Sometimes it takes */
- /* long time to get back the lock once unlocked and notify callback */
- if (camHal->msgEnabledFlag & CAMERA_MSG_SHUTTER){
- camHal->lock.unlock();
- camHal->notify_cb(CAMERA_MSG_SHUTTER, 0, 0, camHal->cb_ctxt);
- camHal->lock.lock();
- }
-#endif
- /************************************************************************/
- /* - Initialize USB camera with snapshot parameters */
- /************************************************************************/
- USB_CAM_OPEN(camHal);
-
-#if JPEG_ON_USB_CAMERA
- rc = initUsbCamera(camHal, camHal->pictWidth, camHal->pictHeight,
- V4L2_PIX_FMT_MJPEG);
-#else
- rc = initUsbCamera(camHal, camHal->pictWidth, camHal->pictHeight,
- V4L2_PIX_FMT_YUYV);
-#endif
- ERROR_CHECK_EXIT_THREAD(rc, "initUsbCamera");
-
- rc = startUsbCamCapture(camHal);
- ERROR_CHECK_EXIT_THREAD(rc, "startUsbCamCapture");
-
- /************************************************************************/
- /* - Time wait (select) on camera fd for camera frame availability */
- /************************************************************************/
- {
- fd_set fds;
- struct timeval tv;
- int r = 0;
-
- FD_ZERO(&fds);
- FD_SET(camHal->fd, &fds);
-
- tv.tv_sec = 1;
- tv.tv_usec = 0;
-
- do{
- ALOGD("%s: b4 select on camHal->fd : %d", __func__, camHal->fd);
- r = select(camHal->fd + 1, &fds, NULL, NULL, &tv);
- ALOGD("%s: after select", __func__);
- }while((0 == r) || ((-1 == r) && (EINTR == errno)));
-
- if ((-1 == r) && (EINTR != errno)){
- ALOGE("%s: FDSelect ret = %d error: %d", __func__, r, errno);
- return (void *)-1;
- }
-
- }
- /************************************************************************/
- /* - Dequeue capture buffer from USB camera */
- /************************************************************************/
- if (0 == get_buf_from_cam(camHal))
- ALOGD("%s: get_buf_from_cam success", __func__);
- else
- ALOGE("%s: get_buf_from_cam error", __func__);
-
- /************************************************************************/
- /* - Send capture buffer to JPEG encoder for JPEG compression */
- /************************************************************************/
- mem_info = &camHal->pictMem.mem_info[0];
- mem_info->size = MAX_JPEG_BUFFER_SIZE;
-
- rc = allocate_ion_memory(mem_info,
- ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
- (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
- if(rc)
- ALOGE("%s: ION memory allocation failed", __func__);
-
- camHal->pictMem.camera_memory[0] = camHal->get_memory(
- mem_info->fd, mem_info->size, 1, camHal->cb_ctxt);
- if(!camHal->pictMem.camera_memory[0])
- ALOGE("%s: get_mem failed", __func__);
-
-#if FREAD_JPEG_PICTURE
- jpegLength = readFromFile("/data/tempVGA.jpeg",
- (char*)camHal->pictMem.camera_memory[0]->data,
- camHal->pictMem.camera_memory[0]->size);
- camHal->pictMem.camera_memory[0]->size = jpegLength;
-
-#elif JPEG_ON_USB_CAMERA
- memcpy((char*)camHal->pictMem.camera_memory[0]->data,
- (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
- camHal->curCaptureBuf.bytesused);
- camHal->pictMem.camera_memory[0]->size = camHal->curCaptureBuf.bytesused;
- jpegLength = camHal->curCaptureBuf.bytesused;
-
-#else
- rc = encodeJpeg(camHal);
- ERROR_CHECK_EXIT_THREAD(rc, "jpeg_encode");
-#endif
- if(jpegLength <= 0)
- ALOGI("%s: jpegLength : %d", __func__, jpegLength);
-
- ALOGD("%s: jpegLength : %d", __func__, jpegLength);
- /************************************************************************/
- /* - If jpeg frames callback is requested, callback with jpeg buffers */
- /************************************************************************/
- /* TBD: CAMERA_MSG_RAW_IMAGE data call back */
-
- if ((camHal->msgEnabledFlag & CAMERA_MSG_COMPRESSED_IMAGE) &&
- (camHal->data_cb)){
- /* Unlock temporarily, callback might call HAL api in turn */
- camHal->lock.unlock();
-
- camHal->data_cb(CAMERA_MSG_COMPRESSED_IMAGE,
- camHal->pictMem.camera_memory[0],
- 0, NULL, camHal->cb_ctxt);
- camHal->lock.lock();
- }
-
- /* release heap memory after the call back */
- if(camHal->pictMem.camera_memory[0])
- camHal->pictMem.camera_memory[0]->release(
- camHal->pictMem.camera_memory[0]);
-
- rc = deallocate_ion_memory(mem_info);
- if(rc)
- ALOGE("%s: ION memory de-allocation failed", __func__);
-
- /************************************************************************/
- /* - Enqueue capture buffer back to USB camera */
- /************************************************************************/
- if(0 == put_buf_to_cam(camHal)) {
- ALOGD("%s: put_buf_to_cam success", __func__);
- }
- else
- ALOGE("%s: put_buf_to_cam error", __func__);
-
- /************************************************************************/
- /* - Free USB camera resources and close camera */
- /************************************************************************/
- rc = stopUsbCamCapture(camHal);
- ERROR_CHECK_EXIT_THREAD(rc, "stopUsbCamCapture");
-
- rc = unInitV4L2mmap(camHal);
- ERROR_CHECK_EXIT_THREAD(rc, "unInitV4L2mmap");
-
- USB_CAM_CLOSE(camHal);
- /************************************************************************/
- /* - If preview was stopped for taking picture, restart the preview */
- /************************************************************************/
- if(camHal->prvwStoppedForPicture)
- {
- struct camera_device device;
- device.priv = (void *)camHal;
-
- USB_CAM_OPEN(camHal);
- /* Unlock temporarily coz usbcam_start_preview has a lock */
- camHal->lock.unlock();
- rc = usbcam_start_preview(&device);
- if(rc)
- ALOGE("%s: start_preview error after take picture", __func__);
- camHal->lock.lock();
- camHal->prvwStoppedForPicture = 0;
- }
-
- /* take picture activity is done */
- camHal->takePictInProgress = 0;
-
- ALOGI("%s: X", __func__);
- return (void *)0;
-}
-
-/******************************************************************************
- * Function: allocate_ion_memory
- * Description: This function is allocates ION memory
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type)
-{
- int rc = 0;
- struct ion_handle_data handle_data;
- struct ion_allocation_data alloc;
- struct ion_fd_data ion_info_fd;
- int main_ion_fd = 0;
-
- main_ion_fd = open("/dev/ion", O_RDONLY);
- if (main_ion_fd <= 0) {
- ALOGE("Ion dev open failed %s\n", strerror(errno));
- goto ION_OPEN_FAILED;
- }
-
- memset(&alloc, 0, sizeof(alloc));
- alloc.len = mem_info->size;
- /* to make it page size aligned */
- alloc.len = (alloc.len + 4095) & (~4095);
- alloc.align = 4096;
- alloc.flags = ION_FLAG_CACHED;
- alloc.heap_mask = ion_type;
- rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &alloc);
- if (rc < 0) {
- ALOGE("ION allocation failed\n");
- goto ION_ALLOC_FAILED;
- }
-
- memset(&ion_info_fd, 0, sizeof(ion_info_fd));
- ion_info_fd.handle = alloc.handle;
- rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd);
- if (rc < 0) {
- ALOGE("ION map failed %s\n", strerror(errno));
- goto ION_MAP_FAILED;
- }
-
- mem_info->main_ion_fd = main_ion_fd;
- mem_info->fd = ion_info_fd.fd;
- mem_info->handle = ion_info_fd.handle;
- mem_info->size = alloc.len;
- return 0;
-
-ION_MAP_FAILED:
- memset(&handle_data, 0, sizeof(handle_data));
- handle_data.handle = ion_info_fd.handle;
- ioctl(main_ion_fd, ION_IOC_FREE, &handle_data);
-ION_ALLOC_FAILED:
- close(main_ion_fd);
-ION_OPEN_FAILED:
- return -1;
-}
-
-/******************************************************************************
- * Function: deallocate_ion_memory
- * Description: This function de allocates ION memory
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-static int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info)
-{
- struct ion_handle_data handle_data;
- int rc = 0;
-
- if (mem_info->fd > 0) {
- close(mem_info->fd);
- mem_info->fd = 0;
- }
-
- if (mem_info->main_ion_fd > 0) {
- memset(&handle_data, 0, sizeof(handle_data));
- handle_data.handle = mem_info->handle;
- ioctl(mem_info->main_ion_fd, ION_IOC_FREE, &handle_data);
- close(mem_info->main_ion_fd);
- mem_info->main_ion_fd = 0;
- }
- return rc;
-}
-
-/******************************************************************************
- * Function: readFromFile
- * Description: This function reads data from the given file into given buffer
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * int bytesRead
- *
- * Notes: none
- *****************************************************************************/
-static int readFromFile(char* fileName, char* buffer, int bufferSize)
-{
- int bytesRead = 0, fileSize = 0;
- FILE *fp;
-
- fp = fopen(fileName, "rb");
- if(!fp){
- ALOGE("%s: Error in opening %s ", __func__, fileName);
- return bytesRead;
- }
-
- /* If file is bigger for given buffer, exit */
- if (fileSize > bufferSize){
- ALOGE("%s: Error %d > %d", __func__, fileSize, bufferSize);
- return bytesRead;
- }
-
- bytesRead = fread(buffer, 1, bufferSize, fp);
- ALOGD(" %s: bytesRead: %d", __func__, bytesRead);
-
- return bytesRead;
-}
-
-/******************************************************************************
- * Function: encodeJpeg
- * Description: This function initializes Jpeg encoder and calls jpeg encoder
- * call and waits for the encode to complete
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No Error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-int encodeJpeg(camera_hardware_t *camHal)
-{
- int rc = 0;
- mm_jpeg_ops_t mmJpegOps;
- int jpegEncHdl = 0;
- mm_jpeg_job mmJpegJob;
- src_image_buffer_info *srcBuf = NULL;
- QCameraHalMemInfo_t jpegInMemInfo;
- camera_memory_t* jpegInMem;
- uint32_t jobId;
-
- ALOGI("%s: E", __func__);
-
- /************************************************************************/
- /* - Allocate Jpeg input buffer from ION memory */
- /************************************************************************/
- jpegInMemInfo.size = camHal->pictWidth * camHal->pictHeight * 2;
- rc = allocate_ion_memory(&jpegInMemInfo,
- ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
- (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
- ERROR_CHECK_EXIT(rc, "allocate_ion_memory");
-
- jpegInMem = camHal->get_memory(
- jpegInMemInfo.fd, jpegInMemInfo.size, 1, camHal->cb_ctxt);
- if(!jpegInMem){
- ALOGE("%s: get_mem failed", __func__);
- return -1;
- }
-
- rc = convert_YUYV_to_420_NV12(
- (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
- (char *)jpegInMem->data, camHal->pictWidth, camHal->pictHeight);
- ERROR_CHECK_EXIT(rc, "convert_YUYV_to_420_NV12");
- /************************************************************************/
- /* - Populate JPEG encoding parameters from the camHal context */
- /************************************************************************/
- memset(&mmJpegJob, 0, sizeof(mmJpegJob));
-
- mmJpegJob.job_type = JPEG_JOB_TYPE_ENCODE;
- mmJpegJob.encode_job.jpeg_cb = jpegEncodeCb;
- mmJpegJob.encode_job.userdata = (void *)camHal;
- /* TBD: Rotation to be set from settings sent from app */
- mmJpegJob.encode_job.encode_parm.rotation = 0;
- mmJpegJob.encode_job.encode_parm.exif_numEntries = 0;
- mmJpegJob.encode_job.encode_parm.exif_data = NULL;
-
- /* TBD: Add thumbnail support */
- mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.src_img_num = 1;
- mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.is_video_frame = 0;
-
- /* Fill main image information */
- srcBuf = &mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.src_img[0];
- srcBuf->type = JPEG_SRC_IMAGE_TYPE_MAIN;
- srcBuf->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
- /* TBD: convert from YUYV to CRCBH2V2 */
- srcBuf->color_format = MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
- srcBuf->num_bufs = 1;
- srcBuf->src_image[0].fd = jpegInMemInfo.fd;
- srcBuf->src_image[0].buf_vaddr = (uint8_t*)jpegInMem->data;
- //srcBuf->src_image[0].offset = 0;
- srcBuf->src_dim.width = camHal->pictWidth;
- srcBuf->src_dim.height = camHal->pictHeight;
- srcBuf->out_dim.width = camHal->pictWidth;
- srcBuf->out_dim.height = camHal->pictHeight;
- srcBuf->crop.offset_x = 0;
- srcBuf->crop.offset_y = 0;
- srcBuf->crop.width = srcBuf->src_dim.width;
- srcBuf->crop.height = srcBuf->src_dim.height;
- srcBuf->quality = camHal->pictJpegQlty;
-
- /* TBD:Fill thumbnail image information */
-
- /* Fill out buf information */
- mmJpegJob.encode_job.encode_parm.buf_info.sink_img.buf_vaddr =
- (uint8_t*)camHal->pictMem.camera_memory[0]->data;
- mmJpegJob.encode_job.encode_parm.buf_info.sink_img.fd = 0;
- /* TBD: hard coded for 1.5 bytes per pixel */
- mmJpegJob.encode_job.encode_parm.buf_info.sink_img.buf_len =
- camHal->pictWidth * camHal->pictHeight * 1.5;
-
- /************************************************************************/
- /* - Initialize jpeg encoder and call Jpeg encoder start */
- /************************************************************************/
- memset(&mmJpegOps, 0, sizeof(mm_jpeg_ops_t));
- jpegEncHdl = jpeg_open(&mmJpegOps);
- if(!jpegEncHdl){
- ALOGE("%s: Failed to open Jpeg Encoder instance", __func__);
- }else
- ALOGD("%s: jpegEncHdl = %d", __func__, jpegEncHdl);
-
- camHal->jpegEncInProgress = 1;
- rc = mmJpegOps.start_job(jpegEncHdl, &mmJpegJob, &jobId);
-
- /************************************************************************/
- /* - Wait for JPEG encoder to complete encoding */
- /************************************************************************/
- pthread_mutex_init(&camHal->jpegEncMutex, NULL);
- pthread_cond_init(&camHal->jpegEncCond, NULL);
-
- pthread_mutex_lock(&camHal->jpegEncMutex);
- while(camHal->jpegEncInProgress)
- pthread_cond_wait(&camHal->jpegEncCond, &camHal->jpegEncMutex);
- pthread_mutex_unlock(&camHal->jpegEncMutex);
-
- /************************************************************************/
- /* - De-allocate Jpeg input buffer from ION memory */
- /************************************************************************/
- if(jpegInMem)
- jpegInMem->release(jpegInMem);
-
- rc = deallocate_ion_memory(&jpegInMemInfo);
- if(rc)
- ALOGE("%s: ION memory de-allocation failed", __func__);
-
- ALOGI("%s: X rc = %d", __func__, rc);
- return rc;
-}
-
-/******************************************************************************
- * Function: jpegEncodeCb
- * Description: This is a call back function registered with JPEG encoder.
- * Jpeg encoder calls this function on completion of encoding
- *
- * Input parameters:
- * camHal - camera HAL handle
- *
- * Return values:
- * 0 No Error
- * -1 Error
- *
- * Notes: none
- *****************************************************************************/
-void jpegEncodeCb (jpeg_job_status_t status,
- uint8_t thumbnailDroppedFlag,
- uint32_t client_hdl,
- uint32_t jobId,
- uint8_t* out_data,
- uint32_t data_size,
- void *userData)
-{
- int rc = 0;
- camera_hardware_t *camHal = NULL;
-
- ALOGI("%s: E status = %d", __func__, status);
-
- camHal = (camera_hardware_t*) userData;
-
- if(JPEG_JOB_STATUS_DONE == status){
- ALOGD("%s: JPEG encode successful. out_data:%p, size: %d", __func__,
- out_data, data_size);
- camHal->jpegEncInProgress = 0;
- }
-
- pthread_mutex_lock(&camHal->jpegEncMutex);
- pthread_cond_signal(&camHal->jpegEncCond);
- pthread_mutex_unlock(&camHal->jpegEncMutex);
-
- ALOGI("%s: X", __func__);
- return;
-}
-
-/******************************************************************************/
-}; // namespace android
diff --git a/camera/QCamera/HAL/wrapper/QualcommCamera.cpp b/camera/QCamera/HAL/wrapper/QualcommCamera.cpp
deleted file mode 100755
index 7a809ea..0000000
--- a/camera/QCamera/HAL/wrapper/QualcommCamera.cpp
+++ /dev/null
@@ -1,529 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- *
- */
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QualcommCamera"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraHAL.h"
-/* include QCamera Hardware Interface Header*/
-#include "QualcommCamera.h"
-#include "QualcommUsbCamera.h"
-//#include "QualcommCameraHardware.h"
-//#include <camera/CameraHardwareInterface.h>
-
-extern "C" {
-#include <sys/time.h>
-}
-
-/* HAL function implementation goes here*/
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-
-static hw_module_methods_t camera_module_methods = {
- open: camera_device_open,
-};
-
-static hw_module_t camera_common = {
- tag: HARDWARE_MODULE_TAG,
- version_major: 0,
- version_minor: 01,
- id: CAMERA_HARDWARE_MODULE_ID,
- name: "Qcamera",
- author:"Qcom",
- methods: &camera_module_methods,
- dso: NULL,
- reserved: {0},
-};
-camera_module_t HAL_MODULE_INFO_SYM = {
- common: camera_common,
- get_number_of_cameras: get_number_of_cameras,
- get_camera_info: get_camera_info,
-};
-
-camera_device_ops_t camera_ops = {
- set_preview_window: android::set_preview_window,
- set_callbacks: android::set_CallBacks,
- enable_msg_type: android::enable_msg_type,
- disable_msg_type: android::disable_msg_type,
- msg_type_enabled: android::msg_type_enabled,
-
- start_preview: android::start_preview,
- stop_preview: android::stop_preview,
- preview_enabled: android::preview_enabled,
- store_meta_data_in_buffers: android::store_meta_data_in_buffers,
-
- start_recording: android::start_recording,
- stop_recording: android::stop_recording,
- recording_enabled: android::recording_enabled,
- release_recording_frame: android::release_recording_frame,
-
- auto_focus: android::auto_focus,
- cancel_auto_focus: android::cancel_auto_focus,
-
- take_picture: android::take_picture,
- cancel_picture: android::cancel_picture,
-
- set_parameters: android::set_parameters,
- get_parameters: android::get_parameters,
- put_parameters: android::put_parameters,
- send_command: android::send_command,
-
- release: android::release,
- dump: android::dump,
-};
-
-namespace android {
-
-typedef struct {
- camera_device hw_dev;
- //sp<CameraHardwareInterface> hardware;
- QCameraHardwareInterface *hardware;
- int camera_released;
- int cameraId;
- //QCameraParameters parameters;
-} camera_hardware_t;
-
-typedef struct {
- camera_memory_t mem;
- int32_t msgType;
- sp<IMemory> dataPtr;
- void* user;
- unsigned int index;
-} q_cam_memory_t;
-
-QCameraHardwareInterface *util_get_Hal_obj( struct camera_device * device)
-{
- QCameraHardwareInterface *hardware = NULL;
- if(device && device->priv){
- camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
- hardware = camHal->hardware;
- }
- return hardware;
-}
-
-#if 0 //mzhu
-QCameraParameters* util_get_HAL_parameter( struct camera_device * device)
-{
- QCameraParameters *param = NULL;
- if(device && device->priv){
- camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
- param = &(camHal->parameters);
- }
- return param;
-}
-#endif //mzhu
-
-extern "C" int get_number_of_cameras()
-{
- /* try to query every time we get the call!*/
-
- ALOGE("Q%s: E", __func__);
- int is_mpq = 0;
- IS_TARGET_MPQ(is_mpq);
-
- if(is_mpq)
- return usbcam_get_number_of_cameras();
-
- /* if(!is_mpq) */
- return android::HAL_getNumberOfCameras( );
-}
-
-extern "C" int get_camera_info(int camera_id, struct camera_info *info)
-{
- int rc = -1;
- ALOGE("Q%s: E", __func__);
-
- int is_mpq = 0;
- IS_TARGET_MPQ(is_mpq);
-
- if(is_mpq)
- return usbcam_get_camera_info(camera_id, info);
-
- /* if(!is_mpq) */
- if(info) {
- struct CameraInfo camInfo;
- memset(&camInfo, -1, sizeof (struct CameraInfo));
- android::HAL_getCameraInfo(camera_id, &camInfo);
- if (camInfo.facing >= 0) {
- rc = 0;
- info->facing = camInfo.facing;
- info->orientation = camInfo.orientation;
- }
- }
- ALOGV("Q%s: X", __func__);
- return rc;
-}
-
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" int camera_device_open(
- const struct hw_module_t* module, const char* id,
- struct hw_device_t** hw_device)
-{
- int rc = -1;
- int mode = 0; // TODO: need to add 3d/2d mode, etc
- camera_device *device = NULL;
- int is_mpq = 0;
- IS_TARGET_MPQ(is_mpq);
-
- if(is_mpq && module && id && hw_device)
- return usbcam_camera_device_open(module, id, hw_device);
-
- /* if(!is_mpq) */
- if(module && id && hw_device) {
- int cameraId = atoi(id);
-
- if (!strcmp(module->name, camera_common.name)) {
- camera_hardware_t *camHal =
- (camera_hardware_t *) malloc(sizeof (camera_hardware_t));
- if(!camHal) {
- *hw_device = NULL;
- ALOGE("%s: end in no mem", __func__);
- return rc;
- }
- /* we have the camera_hardware obj malloced */
- memset(camHal, 0, sizeof (camera_hardware_t));
- camHal->hardware = new QCameraHardwareInterface(cameraId, mode); //HAL_openCameraHardware(cameraId);
- if (camHal->hardware && camHal->hardware->isCameraReady()) {
- camHal->cameraId = cameraId;
- device = &camHal->hw_dev;
- device->common.close = close_camera_device;
- device->ops = &camera_ops;
- device->priv = (void *)camHal;
- rc = 0;
- } else {
- if (camHal->hardware) {
- delete camHal->hardware;
- camHal->hardware = NULL;
- }
- free(camHal);
- device = NULL;
- }
- }
- }
- /* pass actual hw_device ptr to framework. This amkes that we actally be use memberof() macro */
- *hw_device = (hw_device_t*)&device->common;
- ALOGE("%s: end rc %d", __func__, rc);
- return rc;
-}
-
-extern "C" int close_camera_device( hw_device_t *hw_dev)
-{
- ALOGE("Q%s: device =%p E", __func__, hw_dev);
- int rc = -1;
- camera_device_t *device = (camera_device_t *)hw_dev;
-
- if(device) {
- camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
- if(camHal ) {
- QCameraHardwareInterface *hardware = util_get_Hal_obj( device);
- if(!camHal->camera_released) {
- if(hardware != NULL) {
- hardware->release( );
- }
- }
- if(hardware != NULL)
- delete hardware;
- free(camHal);
- }
- rc = 0;
- }
- return rc;
-}
-
-
-int set_preview_window(struct camera_device * device,
- struct preview_stream_ops *window)
-{
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->setPreviewWindow(window);
- }
- return rc;
-}
-
-void set_CallBacks(struct camera_device * device,
- camera_notify_callback notify_cb,
- camera_data_callback data_cb,
- camera_data_timestamp_callback data_cb_timestamp,
- camera_request_memory get_memory,
- void *user)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->setCallbacks(notify_cb,data_cb, data_cb_timestamp, get_memory, user);
- }
-}
-
-void enable_msg_type(struct camera_device * device, int32_t msg_type)
-{
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->enableMsgType(msg_type);
- }
-}
-
-void disable_msg_type(struct camera_device * device, int32_t msg_type)
-{
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- ALOGE("Q%s: E", __func__);
- if(hardware != NULL){
- hardware->disableMsgType(msg_type);
- }
-}
-
-int msg_type_enabled(struct camera_device * device, int32_t msg_type)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->msgTypeEnabled(msg_type);
- }
- return rc;
-}
-
-int start_preview(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->startPreview( );
- }
- ALOGE("Q%s: X", __func__);
- return rc;
-}
-
-void stop_preview(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->stopPreview( );
- }
-}
-
-int preview_enabled(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->previewEnabled( );
- }
- return rc;
-}
-
-int store_meta_data_in_buffers(struct camera_device * device, int enable)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->storeMetaDataInBuffers(enable);
- }
- return rc;
-}
-
-int start_recording(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->startRecording( );
- }
- return rc;
-}
-
-void stop_recording(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->stopRecording( );
- }
-}
-
-int recording_enabled(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->recordingEnabled( );
- }
- return rc;
-}
-
-void release_recording_frame(struct camera_device * device,
- const void *opaque)
-{
- ALOGV("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->releaseRecordingFrame(opaque);
- }
-}
-
-int auto_focus(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->autoFocus( );
- }
- return rc;
-}
-
-int cancel_auto_focus(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->cancelAutoFocus( );
- }
- return rc;
-}
-
-int take_picture(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->takePicture( );
- }
- return rc;
-}
-
-int cancel_picture(struct camera_device * device)
-
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->cancelPicture( );
- }
- return rc;
-}
-
-int set_parameters(struct camera_device * device, const char *parms)
-
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL && parms){
- //QCameraParameters param;// = util_get_HAL_parameter(device);
- //String8 str = String8(parms);
-
- //param.unflatten(str);
- rc = hardware->setParameters(parms);
- //rc = 0;
- }
- return rc;
-}
-
-char* get_parameters(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- char *parms = NULL;
- hardware->getParameters(&parms);
- return parms;
- }
- return NULL;
-}
-
-void put_parameters(struct camera_device * device, char *parm)
-
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->putParameters(parm);
- }
-}
-
-int send_command(struct camera_device * device,
- int32_t cmd, int32_t arg1, int32_t arg2)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->sendCommand( cmd, arg1, arg2);
- }
- return rc;
-}
-
-void release(struct camera_device * device)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
- hardware->release( );
- camHal->camera_released = true;
- }
-}
-
-int dump(struct camera_device * device, int fd)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->dump( fd );
- //rc = 0;
- }
- return rc;
-}
-
-}; // namespace android
diff --git a/camera/QCamera/HAL/wrapper/QualcommCamera.h b/camera/QCamera/HAL/wrapper/QualcommCamera.h
deleted file mode 100755
index 8142689..0000000
--- a/camera/QCamera/HAL/wrapper/QualcommCamera.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- *
- */
-
-#ifndef ANDROID_HARDWARE_QUALCOMM_CAMERA_H
-#define ANDROID_HARDWARE_QUALCOMM_CAMERA_H
-
-
-#include "QCameraHWI.h"
-
-extern "C" {
-/*#include <hardware/camera.h>*/
-
- int get_number_of_cameras();
- int get_camera_info(int camera_id, struct camera_info *info);
-
- int camera_device_open(const struct hw_module_t* module, const char* id,
- struct hw_device_t** device);
-
- hw_device_t * open_camera_device(int cameraId);
-
- int close_camera_device( hw_device_t *);
-
-namespace android {
- int set_preview_window(struct camera_device *,
- struct preview_stream_ops *window);
- void set_CallBacks(struct camera_device *,
- camera_notify_callback notify_cb,
- camera_data_callback data_cb,
- camera_data_timestamp_callback data_cb_timestamp,
- camera_request_memory get_memory,
- void *user);
-
- void enable_msg_type(struct camera_device *, int32_t msg_type);
-
- void disable_msg_type(struct camera_device *, int32_t msg_type);
- int msg_type_enabled(struct camera_device *, int32_t msg_type);
-
- int start_preview(struct camera_device *);
-
- void stop_preview(struct camera_device *);
-
- int preview_enabled(struct camera_device *);
- int store_meta_data_in_buffers(struct camera_device *, int enable);
-
- int start_recording(struct camera_device *);
-
- void stop_recording(struct camera_device *);
-
- int recording_enabled(struct camera_device *);
-
- void release_recording_frame(struct camera_device *,
- const void *opaque);
-
- int auto_focus(struct camera_device *);
-
- int cancel_auto_focus(struct camera_device *);
-
- int take_picture(struct camera_device *);
-
- int cancel_picture(struct camera_device *);
-
- int set_parameters(struct camera_device *, const char *parms);
-
- char* get_parameters(struct camera_device *);
-
- void put_parameters(struct camera_device *, char *);
-
- int send_command(struct camera_device *,
- int32_t cmd, int32_t arg1, int32_t arg2);
-
- void release(struct camera_device *);
-
- int dump(struct camera_device *, int fd);
-
-
-
-}; // namespace android
-
-} //extern "C"
-
-#endif
-
diff --git a/camera/QCamera/HAL2/Android.mk b/camera/QCamera/HAL2/Android.mk
deleted file mode 100644
index 5097dae..0000000
--- a/camera/QCamera/HAL2/Android.mk
+++ /dev/null
@@ -1,3 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(LOCAL_PATH)/core/Android.mk
-#include $(LOCAL_PATH)/test/Android.mk
diff --git a/camera/QCamera/HAL2/core/Android.mk b/camera/QCamera/HAL2/core/Android.mk
deleted file mode 100644
index 6491691..0000000
--- a/camera/QCamera/HAL2/core/Android.mk
+++ /dev/null
@@ -1,81 +0,0 @@
-
-#ifeq ($(call is-board-platform,msm8960),true)
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-DLOPEN_LIBMMCAMERA:=0
-
-LOCAL_CFLAGS:= -DDLOPEN_LIBMMCAMERA=$(DLOPEN_LIBMMCAMERA)
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
- LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_CFLAGS += -DCAMERA_ION_HEAP_ID=ION_CP_MM_HEAP_ID # 8660=SMI, Rest=EBI
-LOCAL_CFLAGS += -DCAMERA_ZSL_ION_HEAP_ID=ION_CP_MM_HEAP_ID
-
-LOCAL_CFLAGS+= -DHW_ENCODE
-LOCAL_CFLAGS+= -DUSE_NEON_CONVERSION
-
-ifeq ($(TARGET_BOARD_PLATFORM),msm8960)
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_MM_HEAP
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_IOMMU_HEAP
- LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_IOMMU_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
-else ifeq ($(TARGET_BOARD_PLATFORM),msm8660)
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_CAMERA_HEAP # Don't Care
- LOCAL_CFLAGS += -DCAMERA_ION_FALLBACK_HEAP_ID=ION_CAMERA_HEAP_ID # EBI
- LOCAL_CFLAGS += -DCAMERA_ZSL_ION_FALLBACK_HEAP_ID=ION_CAMERA_HEAP_ID
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=0
-else
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_HEAP_ID=GRALLOC_USAGE_PRIVATE_ADSP_HEAP
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_FALLBACK_HEAP_ID=GRALLOC_USAGE_PRIVATE_ADSP_HEAP # Don't Care
- LOCAL_CFLAGS += -DCAMERA_GRALLOC_CACHING_ID=GRALLOC_USAGE_PRIVATE_UNCACHED #uncached
-endif
-
-LOCAL_HAL_FILES := \
- src/QCameraHAL.cpp \
- src/QCameraHWI.cpp \
- src/QCameraStream.cpp \
- src/QCameraHWI_Metatags.cpp \
- src/QCameraStream_Preview.cpp
-
-LOCAL_HAL_WRAPPER_FILES := ../wrapper/QualcommCamera.cpp
-
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/../wrapper \
- $(LOCAL_PATH)/inc \
- $(LOCAL_PATH)/../../stack/mm-camera-interface/inc\
- $(LOCAL_PATH)/../../stack/mm-jpeg-interface/inc\
- $(TARGET_OUT_INTERMEDIATES)/include/mm-camera-interface_badger \
-
-LOCAL_C_INCLUDES += hardware/qcom/display/libgralloc \
- hardware/qcom/display/libgenlock \
- hardware/qcom/media/libstagefrighthw \
- system/media/camera/include
-
-# if debug service layer and up , use stub camera!
-LOCAL_C_INCLUDES += \
- frameworks/base/services/camera/libcameraservice
-
-LOCAL_SRC_FILES := \
- $(LOCAL_HAL_WRAPPER_FILES) \
- $(LOCAL_HAL_FILES)
-
-LOCAL_SHARED_LIBRARIES := libutils libui libcamera_client liblog libcutils
-LOCAL_SHARED_LIBRARIES += libmmcamera_interface
-LOCAL_SHARED_LIBRARIES+= libgenlock libbinder libcamera_metadata
-
-LOCAL_CFLAGS += -include bionic/libc/include/sys/socket.h
-
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-LOCAL_MODULE:= camera.$(TARGET_BOARD_PLATFORM)
-LOCAL_MODULE_TAGS := optional
-include $(BUILD_SHARED_LIBRARY)
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
-
diff --git a/camera/QCamera/HAL2/core/inc/QCameraHAL.h b/camera/QCamera/HAL2/core/inc/QCameraHAL.h
deleted file mode 100644
index 7f7533d..0000000
--- a/camera/QCamera/HAL2/core/inc/QCameraHAL.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-** Copyright (c) 2011 The Linux Foundation. All rights reserved.
-**
-** 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_QCAMERA_HAL_H
-#define ANDROID_HARDWARE_QCAMERA_HAL_H
-
-
-#include "QCameraHWI.h"
-
-extern "C" {
-#include <mm_camera_interface.h>
-}
-namespace android {
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" void *
- QCameraHAL_openCameraHardware(int cameraId, int mode);
-extern "C" int HAL_getNumberOfCameras();
-extern "C" int HAL_getCameraInfo(int cameraId, struct camera_info* cameraInfo);
-extern "C" status_t getStaticInfo(camera_metadata_t **info,
- mm_camera_vtbl_t *camera_vtbl, bool sizeRequest);
-extern "C" status_t constructDefaultRequest(int request_template,
- camera_metadata_t **info, bool sizeRequest);
-
-}; // namespace android
-
-#endif
-
diff --git a/camera/QCamera/HAL2/core/inc/QCameraHWI.h b/camera/QCamera/HAL2/core/inc/QCameraHWI.h
deleted file mode 100644
index 220e8e5..0000000
--- a/camera/QCamera/HAL2/core/inc/QCameraHWI.h
+++ /dev/null
@@ -1,883 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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_QCAMERA_HARDWARE_INTERFACE_H
-#define ANDROID_HARDWARE_QCAMERA_HARDWARE_INTERFACE_H
-
-
-#include <utils/threads.h>
-#include <hardware/camera2.h>
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <camera/Camera.h>
-//#include <QCameraParameters.h>
-#include <system/window.h>
-#include <system/camera.h>
-#include <gralloc_priv.h>
-//#include <QComOMXMetadata.h>
-
-extern "C" {
-#include <linux/android_pmem.h>
-#include <linux/msm_ion.h>
-#include <mm_camera_interface.h>
-#include "mm_jpeg_interface.h"
-} //extern C
-
-#include "QCameraStream.h"
-#include "QCamera_Intf.h"
-
-//Error codes
-#define NOT_FOUND -1
-#define MAX_ZOOM_RATIOS 62
-
-#ifdef Q12
-#undef Q12
-#endif
-
-#define Q12 4096
-#define QCAMERA_PARM_ENABLE 1
-#define QCAMERA_PARM_DISABLE 0
-#define PREVIEW_TBL_MAX_SIZE 14
-#define VIDEO_TBL_MAX_SIZE 14
-#define THUMB_TBL_MAX_SIZE 16
-#define HFR_TBL_MAX_SIZE 2
-//Default Video Width
-#define DEFAULT_VIDEO_WIDTH 1920
-#define DEFAULT_VIDEO_HEIGHT 1088
-
-#define DEFAULT_STREAM_WIDTH 640
-#define DEFAULT_STREAM_HEIGHT 480
-#define DEFAULT_LIVESHOT_WIDTH 2592
-#define DEFAULT_LIVESHOT_HEIGHT 1944
-
-struct str_map {
- const char *const desc;
- int val;
-};
-
-struct preview_format_info_t {
- int Hal_format;
- cam_format_t mm_cam_format;
- cam_pad_format_t padding;
- int num_planar;
-};
-
-
-typedef enum {
- CAMERA_STATE_UNINITED,
- CAMERA_STATE_READY,
- CAMERA_STATE_PREVIEW_START_CMD_SENT,
- CAMERA_STATE_PREVIEW_STOP_CMD_SENT,
- CAMERA_STATE_PREVIEW,
- CAMERA_STATE_RECORD_START_CMD_SENT, /*5*/
- CAMERA_STATE_RECORD_STOP_CMD_SENT,
- CAMERA_STATE_RECORD,
- CAMERA_STATE_SNAP_START_CMD_SENT,
- CAMERA_STATE_SNAP_STOP_CMD_SENT,
- CAMERA_STATE_SNAP_CMD_ACKED, /*10 - snapshot comd acked, snapshot not done yet*/
- CAMERA_STATE_ZSL_START_CMD_SENT,
- CAMERA_STATE_ZSL,
- CAMERA_STATE_AF_START_CMD_SENT,
- CAMERA_STATE_AF_STOP_CMD_SENT,
- CAMERA_STATE_ERROR, /*15*/
-
- /*Add any new state above*/
- CAMERA_STATE_MAX
-} HAL_camera_state_type_t;
-
-enum {
- BUFFER_NOT_REGGED,
- BUFFER_NOT_OWNED,
- BUFFER_OWNED,
- BUFFER_UNLOCKED,
- BUFFER_LOCKED,
-};
-
-typedef enum {
- HAL_DUMP_FRM_PREVIEW = 1,
- HAL_DUMP_FRM_VIDEO = 1<<1,
- HAL_DUMP_FRM_MAIN = 1<<2,
- HAL_DUMP_FRM_THUMBNAIL = 1<<3,
-
- /*8 bits mask*/
- HAL_DUMP_FRM_MAX = 1 << 8
-} HAL_cam_dump_frm_type_t;
-
-
-typedef enum {
- HAL_CAM_MODE_ZSL = 1,
-
- /*add new entry before and update the max entry*/
- HAL_CAM_MODE_MAX = HAL_CAM_MODE_ZSL << 1,
-} qQamera_mode_t;
-
-
-typedef enum {
- MM_CAMERA_OK,
- MM_CAMERA_E_GENERAL,
- MM_CAMERA_E_NO_MEMORY,
- MM_CAMERA_E_NOT_SUPPORTED,
- MM_CAMERA_E_INVALID_INPUT,
- MM_CAMERA_E_INVALID_OPERATION, /* 5 */
- MM_CAMERA_E_ENCODE,
- MM_CAMERA_E_BUFFER_REG,
- MM_CAMERA_E_PMEM_ALLOC,
- MM_CAMERA_E_CAPTURE_FAILED,
- MM_CAMERA_E_CAPTURE_TIMEOUT, /* 10 */
-}mm_camera_status_type_t;
-
-
-
-#define HAL_DUMP_FRM_MASK_ALL ( HAL_DUMP_FRM_PREVIEW + HAL_DUMP_FRM_VIDEO + \
- HAL_DUMP_FRM_MAIN + HAL_DUMP_FRM_THUMBNAIL)
-#define QCAMERA_HAL_PREVIEW_STOPPED 0
-#define QCAMERA_HAL_PREVIEW_START 1
-#define QCAMERA_HAL_PREVIEW_STARTED 2
-#define QCAMERA_HAL_RECORDING_STARTED 3
-#define QCAMERA_HAL_TAKE_PICTURE 4
-
-//EXIF globals
-static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 }; // "ASCII\0\0\0"
-static const char ExifUndefinedPrefix[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // "\0\0\0\0\0\0\0\0"
-
-//EXIF detfines
-#define MAX_EXIF_TABLE_ENTRIES 14
-#define GPS_PROCESSING_METHOD_SIZE 101
-#define FOCAL_LENGTH_DECIMAL_PRECISION 100
-#define EXIF_ASCII_PREFIX_SIZE 8 //(sizeof(ExifAsciiPrefix))
-
-typedef struct{
- //GPS tags
- rat_t latitude[3];
- rat_t longitude[3];
- char lonRef[2];
- char latRef[2];
- rat_t altitude;
- rat_t gpsTimeStamp[3];
- char gpsDateStamp[20];
- char gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE+GPS_PROCESSING_METHOD_SIZE];
- //Other tags
- char dateTime[20];
- rat_t focalLength;
- uint16_t flashMode;
- uint16_t isoSpeed;
-
- bool mAltitude;
- bool mLongitude;
- bool mLatitude;
- bool mTimeStamp;
- bool mGpsProcess;
-
- int mAltitude_ref;
- long mGPSTimestamp;
-
-} exif_values_t;
-
-namespace android {
-
-class QCameraStream;
-
-class QCameraHardwareInterface : public virtual RefBase {
-public:
-
- QCameraHardwareInterface(int cameraId, int mode);
-
- int set_request_queue_src_ops(
- const camera2_request_queue_src_ops_t *request_src_ops);
- int notify_request_queue_not_empty();
- int set_frame_queue_dst_ops(const camera2_frame_queue_dst_ops_t *frame_dst_ops);
- int get_in_progress_count();
- int construct_default_request(int request_template, camera_metadata_t **request);
- int allocate_stream(uint32_t width,
- uint32_t height, int format,
- const camera2_stream_ops_t *stream_ops,
- uint32_t *stream_id,
- uint32_t *format_actual,
- uint32_t *usage,
- uint32_t *max_buffers);
- int register_stream_buffers(uint32_t stream_id, int num_buffers,
- buffer_handle_t *buffers);
- int release_stream(uint32_t stream_id);
- int allocate_reprocess_stream(
- uint32_t width,
- uint32_t height,
- uint32_t format,
- const camera2_stream_in_ops_t *reprocess_stream_ops,
- uint32_t *stream_id,
- uint32_t *consumer_usage,
- uint32_t *max_buffers);
- int release_reprocess_stream(
- uint32_t stream_id);
- int get_metadata_vendor_tag_ops(vendor_tag_query_ops_t **ops);
- int set_notify_callback(camera2_notify_callback notify_cb,
- void *user);
-
-
- void runCommandThread(void *);
-
- int getBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int putBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
-
-#if 0
- static QCameraHardwareInterface *createInstance(int, int);
- /** Set the ANativeWindow to which preview frames are sent */
- int setPreviewWindow(preview_stream_ops_t* window);
-
- /** Set the notification and data callbacks */
- void setCallbacks(camera_notify_callback notify_cb,
- camera_data_callback data_cb,
- camera_data_timestamp_callback data_cb_timestamp,
- camera_request_memory get_memory,
- void *user);
-
- /**
- * The following three functions all take a msg_type, which is a bitmask of
- * the messages defined in include/ui/Camera.h
- */
-
- /**
- * Enable a message, or set of messages.
- */
- void enableMsgType(int32_t msg_type);
-
- /**
- * Disable a message, or a set of messages.
- *
- * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
- * HAL should not rely on its client to call releaseRecordingFrame() to
- * release video recording frames sent out by the cameral HAL before and
- * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
- * clients must not modify/access any video recording frame after calling
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
- */
- void disableMsgType(int32_t msg_type);
-
- /**
- * Query whether a message, or a set of messages, is enabled. Note that
- * this is operates as an AND, if any of the messages queried are off, this
- * will return false.
- */
- int msgTypeEnabled(int32_t msg_type);
-
- /**
- * Start preview mode.
- */
- int startPreview();
- int startPreview2();
-
- /**
- * Stop a previously started preview.
- */
- void stopPreview();
-
- /**
- * Returns true if preview is enabled.
- */
- int previewEnabled();
-
-
- /**
- * Request the camera HAL to store meta data or real YUV data in the video
- * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
- * it is not called, the default camera HAL behavior is to store real YUV
- * data in the video buffers.
- *
- * This method should be called before startRecording() in order to be
- * effective.
- *
- * If meta data is stored in the video buffers, it is up to the receiver of
- * the video buffers to interpret the contents and to find the actual frame
- * data with the help of the meta data in the buffer. How this is done is
- * outside of the scope of this method.
- *
- * Some camera HALs may not support storing meta data in the video buffers,
- * but all camera HALs should support storing real YUV data in the video
- * buffers. If the camera HAL does not support storing the meta data in the
- * video buffers when it is requested to do do, INVALID_OPERATION must be
- * returned. It is very useful for the camera HAL to pass meta data rather
- * than the actual frame data directly to the video encoder, since the
- * amount of the uncompressed frame data can be very large if video size is
- * large.
- *
- * @param enable if true to instruct the camera HAL to store
- * meta data in the video buffers; false to instruct
- * the camera HAL to store real YUV data in the video
- * buffers.
- *
- * @return OK on success.
- */
- int storeMetaDataInBuffers(int enable);
-
- /**
- * Start record mode. When a record image is available, a
- * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding
- * frame. Every record frame must be released by a camera HAL client via
- * releaseRecordingFrame() before the client calls
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
- * responsibility to manage the life-cycle of the video recording frames,
- * and the client must not modify/access any video recording frames.
- */
- int startRecording();
-
- /**
- * Stop a previously started recording.
- */
- void stopRecording();
-
- /**
- * Returns true if recording is enabled.
- */
- int recordingEnabled();
-
- /**
- * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
- *
- * It is camera HAL client's responsibility to release video recording
- * frames sent out by the camera HAL before the camera HAL receives a call
- * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
- * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
- * responsibility to manage the life-cycle of the video recording frames.
- */
- void releaseRecordingFrame(const void *opaque);
-
- /**
- * Start auto focus, the notification callback routine is called with
- * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be
- * called again if another auto focus is needed.
- */
- int autoFocus();
-
- /**
- * Cancels auto-focus function. If the auto-focus is still in progress,
- * this function will cancel it. Whether the auto-focus is in progress or
- * not, this function will return the focus position to the default. If
- * the camera does not support auto-focus, this is a no-op.
- */
- int cancelAutoFocus();
-
- /**
- * Take a picture.
- */
- int takePicture();
-
- /**
- * Cancel a picture that was started with takePicture. Calling this method
- * when no picture is being taken is a no-op.
- */
- int cancelPicture();
-
- /**
- * Set the camera parameters. This returns BAD_VALUE if any parameter is
- * invalid or not supported.
- */
- int setParameters(const char *parms);
-
- //status_t setParameters(const QCameraParameters& params);
- /** Retrieve the camera parameters. The buffer returned by the camera HAL
- must be returned back to it with put_parameters, if put_parameters
- is not NULL.
- */
- int getParameters(char **parms);
-
- /** The camera HAL uses its own memory to pass us the parameters when we
- call get_parameters. Use this function to return the memory back to
- the camera HAL, if put_parameters is not NULL. If put_parameters
- is NULL, then you have to use free() to release the memory.
- */
- void putParameters(char *);
-
- /**
- * Send command to camera driver.
- */
- int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
-
-
- /**
- * Dump state of the camera hardware
- */
- int dump(int fd);
-
- //virtual sp<IMemoryHeap> getPreviewHeap() const;
- //virtual sp<IMemoryHeap> getRawHeap() const;
-
-
- status_t takeLiveSnapshot();
- status_t takeFullSizeLiveshot();
- bool canTakeFullSizeLiveshot();
-
- //virtual status_t getBufferInfo( sp<IMemory>& Frame,
- //size_t *alignedSize);
- void getPictureSize(int *picture_width, int *picture_height) const;
- void getPreviewSize(int *preview_width, int *preview_height) const;
- cam_format_t getPreviewFormat() const;
-
- cam_pad_format_t getPreviewPadding() const;
-
- //bool useOverlay(void);
- //virtual status_t setOverlay(const sp<Overlay> &overlay);
- void processEvent(mm_camera_event_t *);
- int getJpegQuality() const;
- int getNumOfSnapshots(void) const;
- int getNumOfSnapshots(const QCameraParameters& params);
- int getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
- int *picture_width,
- int *picture_height);
- bool isRawSnapshot();
- bool mShutterSoundPlayed;
- void dumpFrameToFile(mm_camera_buf_def_t*, HAL_cam_dump_frm_type_t);
-
- status_t setZSLBurstLookBack(const QCameraParameters& params);
- status_t setZSLBurstInterval(const QCameraParameters& params);
- int getZSLBurstInterval(void);
- int getZSLQueueDepth(void) const;
- int getZSLBackLookCount(void) const;
-#endif
- /**
- * Release the hardware resources owned by this object. Note that this is
- * *not* done in the destructor.
- */
- void release();
-
- bool isCameraReady();
- ~QCameraHardwareInterface();
-
- mm_camear_mem_vtbl_t mMemHooks;
- mm_camera_vtbl_t *mCameraHandle;
- uint32_t mChannelId;
-
-#if 0
- int initHeapMem( QCameraHalHeap_t *heap,
- int num_of_buf,
- int buf_len,
- int y_off,
- int cbcr_off,
- int pmem_type,
- mm_camera_buf_def_t *buf_def,
- uint8_t num_planes,
- uint32_t *planes);
- int releaseHeapMem( QCameraHalHeap_t *heap);
- status_t sendMappingBuf(int ext_mode, int idx, int fd, uint32_t size,
- int cameraid, mm_camera_socket_msg_type msg_type);
- status_t sendUnMappingBuf(int ext_mode, int idx, int cameraid,
- mm_camera_socket_msg_type msg_type);
-
- int allocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt,
- int ion_type);
- int deallocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt);
-
- int allocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt,
- int ion_type);
- int deallocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt);
-
- int cache_ops(int ion_fd, struct ion_flush_data *cache_inv_data, int type);
-
- void dumpFrameToFile(const void * data, uint32_t size, char* name,
- char* ext, int index);
- preview_format_info_t getPreviewFormatInfo( );
- bool isNoDisplayMode();
-
- int getBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int putBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
-
-
-private:
- int16_t zoomRatios[MAX_ZOOM_RATIOS];
- struct camera_size_type default_preview_sizes[PREVIEW_TBL_MAX_SIZE];
- struct camera_size_type default_video_sizes[VIDEO_TBL_MAX_SIZE];
- struct camera_size_type default_hfr_sizes[HFR_TBL_MAX_SIZE];
- struct camera_size_type default_thumbnail_sizes[THUMB_TBL_MAX_SIZE];
- unsigned int preview_sizes_count;
- unsigned int video_sizes_count;
- unsigned int thumbnail_sizes_count;
- unsigned int hfr_sizes_count;
-
-
- bool mUseOverlay;
-
- void loadTables();
- void initDefaultParameters();
- bool getMaxPictureDimension(mm_camera_dimension_t *dim);
-
- status_t updateFocusDistances();
-
- bool native_set_parms(mm_camera_parm_type_t type, uint16_t length, void *value);
- bool native_set_parms( mm_camera_parm_type_t type, uint16_t length, void *value, int *result);
-
- void hasAutoFocusSupport();
- void debugShowPreviewFPS() const;
- //void prepareSnapshotAndWait();
-
- bool isPreviewRunning();
- bool isRecordingRunning();
- bool isSnapshotRunning();
-
- void processChannelEvent(mm_camera_ch_event_t *, app_notify_cb_t *);
- void processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
- void processRecordChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
- void processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
- void processCtrlEvent(mm_camera_ctrl_event_t *, app_notify_cb_t *);
- void processStatsEvent(mm_camera_stats_event_t *, app_notify_cb_t *);
- void processInfoEvent(mm_camera_info_event_t *event, app_notify_cb_t *);
- void processprepareSnapshotEvent(cam_ctrl_status_t *);
- void roiEvent(fd_roi_t roi, app_notify_cb_t *);
- void zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *);
- void autofocusevent(cam_ctrl_status_t *status, app_notify_cb_t *);
- void handleZoomEventForPreview(app_notify_cb_t *);
- void handleZoomEventForSnapshot(void);
- status_t autoFocusEvent(cam_ctrl_status_t *, app_notify_cb_t *);
-
- void filterPictureSizes();
- bool supportsSceneDetection();
- bool supportsSelectableZoneAf();
- bool supportsFaceDetection();
- bool supportsRedEyeReduction();
- bool preview_parm_config (cam_ctrl_dimension_t* dim,QCameraParameters& parm);
-
- void stopPreviewInternal();
- void stopRecordingInternal();
- //void stopPreviewZSL();
- status_t cancelPictureInternal();
- //status_t startPreviewZSL();
- void pausePreviewForSnapshot();
- void pausePreviewForZSL();
- status_t resumePreviewAfterSnapshot();
-
- status_t runFaceDetection();
-
- status_t setParameters(const QCameraParameters& params);
- QCameraParameters& getParameters() ;
-
- status_t setCameraMode(const QCameraParameters& params);
- status_t setPictureSizeTable(void);
- status_t setPreviewSizeTable(void);
- status_t setVideoSizeTable(void);
- status_t setPreviewSize(const QCameraParameters& params);
- status_t setJpegThumbnailSize(const QCameraParameters& params);
- status_t setPreviewFpsRange(const QCameraParameters& params);
- status_t setPreviewFrameRate(const QCameraParameters& params);
- status_t setPreviewFrameRateMode(const QCameraParameters& params);
- status_t setVideoSize(const QCameraParameters& params);
- status_t setPictureSize(const QCameraParameters& params);
- status_t setJpegQuality(const QCameraParameters& params);
- status_t setNumOfSnapshot(const QCameraParameters& params);
- status_t setJpegRotation(int isZSL);
- int getJpegRotation(void);
- int getISOSpeedValue();
- status_t setAntibanding(const QCameraParameters& params);
- status_t setEffect(const QCameraParameters& params);
- status_t setExposureCompensation(const QCameraParameters ¶ms);
- status_t setAutoExposure(const QCameraParameters& params);
- status_t setWhiteBalance(const QCameraParameters& params);
- status_t setFlash(const QCameraParameters& params);
- status_t setGpsLocation(const QCameraParameters& params);
- status_t setRotation(const QCameraParameters& params);
- status_t setZoom(const QCameraParameters& params);
- status_t setFocusMode(const QCameraParameters& params);
- status_t setBrightness(const QCameraParameters& params);
- status_t setSkinToneEnhancement(const QCameraParameters& params);
- status_t setOrientation(const QCameraParameters& params);
- status_t setLensshadeValue(const QCameraParameters& params);
- status_t setMCEValue(const QCameraParameters& params);
- status_t setISOValue(const QCameraParameters& params);
- status_t setPictureFormat(const QCameraParameters& params);
- status_t setSharpness(const QCameraParameters& params);
- status_t setContrast(const QCameraParameters& params);
- status_t setSaturation(const QCameraParameters& params);
- status_t setWaveletDenoise(const QCameraParameters& params);
- status_t setSceneMode(const QCameraParameters& params);
- status_t setContinuousAf(const QCameraParameters& params);
- status_t setFaceDetection(const char *str);
- status_t setSceneDetect(const QCameraParameters& params);
- status_t setStrTextures(const QCameraParameters& params);
- status_t setPreviewFormat(const QCameraParameters& params);
- status_t setSelectableZoneAf(const QCameraParameters& params);
- status_t setOverlayFormats(const QCameraParameters& params);
- status_t setHighFrameRate(const QCameraParameters& params);
- status_t setRedeyeReduction(const QCameraParameters& params);
- status_t setAEBracket(const QCameraParameters& params);
- status_t setFaceDetect(const QCameraParameters& params);
- status_t setDenoise(const QCameraParameters& params);
- status_t setAecAwbLock(const QCameraParameters & params);
- status_t setHistogram(int histogram_en);
- status_t setRecordingHint(const QCameraParameters& params);
- status_t setRecordingHintValue(const int32_t value);
- status_t setFocusAreas(const QCameraParameters& params);
- status_t setMeteringAreas(const QCameraParameters& params);
- status_t setFullLiveshot(void);
- status_t setDISMode(void);
- status_t setCaptureBurstExp(void);
- status_t setPowerMode(const QCameraParameters& params);
- void takePicturePrepareHardware( );
- status_t setNoDisplayMode(const QCameraParameters& params);
-
- isp3a_af_mode_t getAutoFocusMode(const QCameraParameters& params);
- bool isValidDimension(int w, int h);
-
- String8 create_values_str(const str_map *values, int len);
-
- void setMyMode(int mode);
- bool isZSLMode();
- bool isWDenoiseEnabled();
- void wdenoiseEvent(cam_ctrl_status_t status, void *cookie);
- bool isLowPowerCamcorder();
- void freePictureTable(void);
- void freeVideoSizeTable(void);
-
- int32_t createPreview();
- int32_t createRecord();
- int32_t createSnapshot();
-
- int getHDRMode();
- //EXIF
- void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
- uint32_t count, uint8_t copy, void *data);
- void setExifTags();
- void initExifData();
- void deinitExifData();
- void setExifTagsGPS();
- exif_tags_info_t* getExifData(){ return mExifData; }
- int getExifTableNumEntries() { return mExifTableNumEntries; }
- void parseGPSCoordinate(const char *latlonString, rat_t* coord);
- //added to support hdr
- bool getHdrInfoAndSetExp(int max_num_frm, int *num_frame, int *exp);
- void hdrEvent(cam_ctrl_status_t status, void *cookie);
-
- camera_mode_t myMode;
-
-
-
-
- QCameraParameters mParameters;
- //sp<Overlay> mOverlay;
- int32_t mMsgEnabled;
-
- camera_notify_callback mNotifyCb;
- camera_data_callback mDataCb;
- camera_data_timestamp_callback mDataCbTimestamp;
- camera_request_memory mGetMemory;
- void *mCallbackCookie;
-
- //sp<MemoryHeapBase> mPreviewHeap; //@Guru : Need to remove
- sp<AshmemPool> mMetaDataHeap;
-
- mutable Mutex mLock;
- //mutable Mutex eventLock;
- Mutex mCallbackLock;
- Mutex mRecordingMemoryLock;
- Mutex mAutofocusLock;
- Mutex mMetaDataWaitLock;
- Mutex mRecordFrameLock;
- Mutex mRecordLock;
- Condition mRecordWait;
- pthread_mutex_t mAsyncCmdMutex;
- pthread_cond_t mAsyncCmdWait;
-
- cam_ctrl_dimension_t mDimension;
- int mPreviewWidth, mPreviewHeight;
- int videoWidth, videoHeight;
- int thumbnailWidth, thumbnailHeight;
- int maxSnapshotWidth, maxSnapshotHeight;
- int mPreviewFormat;
- int mFps;
- int mDebugFps;
- int mBrightness;
- int mContrast;
- int mBestShotMode;
- int mEffects;
- int mSkinToneEnhancement;
- int mDenoiseValue;
- int mHJR;
- int mRotation;
- int mJpegQuality;
- int mThumbnailQuality;
- int mTargetSmoothZoom;
- int mSmoothZoomStep;
- int mMaxZoom;
- int mCurrentZoom;
- int mSupportedPictureSizesCount;
- int mFaceDetectOn;
- int mDumpFrmCnt;
- int mDumpSkipCnt;
- int mFocusMode;
-
- unsigned int mPictureSizeCount;
- unsigned int mPreviewSizeCount;
- int mPowerMode;
- unsigned int mVideoSizeCount;
-
- bool mAutoFocusRunning;
- bool mMultiTouch;
- bool mHasAutoFocusSupport;
- bool mInitialized;
- bool mDisEnabled;
- bool strTexturesOn;
- bool mIs3DModeOn;
- bool mSmoothZoomRunning;
- bool mPreparingSnapshot;
- bool mParamStringInitialized;
- bool mZoomSupported;
- bool mSendMetaData;
- bool mFullLiveshotEnabled;
- bool mRecordingHint;
- bool mStartRecording;
- bool mReleasedRecordingFrame;
- int mHdrMode;
- int mSnapshotFormat;
- int mZslInterval;
- bool mRestartPreview;
-
-/*for histogram*/
- int mStatsOn;
- int mCurrentHisto;
- bool mSendData;
- sp<AshmemPool> mStatHeap;
- camera_memory_t *mStatsMapped[3];
- QCameraStatHeap_t mHistServer;
- int32_t mStatSize;
-
- bool mZslLookBackMode;
- int mZslLookBackValue;
- int mHFRLevel;
- bool mZslEmptyQueueFlag;
- String8 mEffectValues;
- String8 mIsoValues;
- String8 mSceneModeValues;
- String8 mSceneDetectValues;
- String8 mFocusModeValues;
- String8 mSelectableZoneAfValues;
- String8 mAutoExposureValues;
- String8 mWhitebalanceValues;
- String8 mAntibandingValues;
- String8 mFrameRateModeValues;
- String8 mTouchAfAecValues;
- String8 mPreviewSizeValues;
- String8 mPictureSizeValues;
- String8 mVideoSizeValues;
- String8 mFlashValues;
- String8 mLensShadeValues;
- String8 mMceValues;
- String8 mHistogramValues;
- String8 mSkinToneEnhancementValues;
- String8 mPictureFormatValues;
- String8 mDenoiseValues;
- String8 mZoomRatioValues;
- String8 mPreviewFrameRateValues;
- String8 mPreviewFormatValues;
- String8 mFaceDetectionValues;
- String8 mHfrValues;
- String8 mHfrSizeValues;
- String8 mRedeyeReductionValues;
- String8 denoise_value;
- String8 mFpsRangesSupportedValues;
- String8 mZslValues;
- String8 mFocusDistance;
-
-
- android :: FPSRange* mSupportedFpsRanges;
- int mSupportedFpsRangesCount;
-
- camera_size_type* mPictureSizes;
- camera_size_type* mPreviewSizes;
- camera_size_type* mVideoSizes;
- const camera_size_type * mPictureSizesPtr;
- HAL_camera_state_type_t mCameraState;
-
- /* Temporary - can be removed after Honeycomb*/
-#ifdef USE_ION
- sp<IonPool> mPostPreviewHeap;
-#else
- sp<PmemPool> mPostPreviewHeap;
-#endif
- // mm_cameara_stream_buf_t mPrevForPostviewBuf;
- int mStoreMetaDataInFrame;
- preview_stream_ops_t *mPreviewWindow;
- Mutex mStateLock;
- int mPreviewState;
- /*preview memory without display case: memory is allocated
- directly by camera */
- QCameraHalHeap_t mNoDispPreviewMemory;
-
- QCameraHalHeap_t mSnapshotMemory;
- QCameraHalHeap_t mThumbnailMemory;
- QCameraHalHeap_t mRecordingMemory;
- QCameraHalHeap_t mJpegMemory;
- QCameraHalHeap_t mRawMemory;
- camera_frame_metadata_t mMetadata;
- camera_face_t mFace[MAX_ROI];
- preview_format_info_t mPreviewFormatInfo;
- // friend void liveshot_callback(mm_camera_ch_data_buf_t *frame,void *user_data);
- //EXIF
- exif_tags_info_t mExifData[MAX_EXIF_TABLE_ENTRIES]; //Exif tags for JPEG encoder
- exif_values_t mExifValues; //Exif values in usable format
- int mExifTableNumEntries; //NUmber of entries in mExifData
- int mNoDisplayMode;
-#endif
-private:
- int mCameraId;
- camera_metadata_t *mStaticInfo;
-
- friend class QCameraStream;
- friend class QCameraStream_record;
- friend class QCameraStream_preview;
- friend class QCameraStream_SnapshotMain;
- friend class QCameraStream_SnapshotThumbnail;
- friend class QCameraStream_Rdi;
-
- friend void stream_cb_routine(mm_camera_super_buf_t *bufs, void *userdata);
- friend void superbuf_cb_routine(mm_camera_super_buf_t *bufs, void *userdata);
- friend void *command_thread(void *);
-
- int tryRestartStreams(camera_metadata_entry_t& streams);
-
- QCameraStream *mStreamDisplay;
- QCameraStream *mStreamRecord;
- QCameraStream *mStreamSnapMain;
- QCameraStream *mStreamSnapThumb;
- QCameraStream *mStreamLiveSnap;
- QCameraStream *mStreamRdi;
-
- const camera2_request_queue_src_ops *mRequestQueueSrc;
- uint8_t mPendingRequests;
- const camera2_frame_queue_dst_ops *mFrameQueueDst;
- camera2_notify_callback mNotifyCb;
- void *mNotifyUserPtr;
- pthread_t mCommandThread;
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL2/core/inc/QCameraParameters.h b/camera/QCamera/HAL2/core/inc/QCameraParameters.h
deleted file mode 100644
index 6920413..0000000
--- a/camera/QCamera/HAL2/core/inc/QCameraParameters.h
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
-**
-** 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_QCAMERA_PARAMETERS_H
-#define ANDROID_HARDWARE_QCAMERA_PARAMETERS_H
-
-//#include <utils/KeyedVector.h>
-//#include <utils/String8.h>
-#include <camera/CameraParameters.h>
-
-namespace android {
-
-struct FPSRange{
- int minFPS;
- int maxFPS;
- FPSRange(){
- minFPS=0;
- maxFPS=0;
- };
- FPSRange(int min,int max){
- minFPS=min;
- maxFPS=max;
- };
-};
-class QCameraParameters: public CameraParameters
-{
-public:
-#if 1
- QCameraParameters() : CameraParameters() {};
- QCameraParameters(const String8 ¶ms): CameraParameters(params) {};
- #else
- QCameraParameters() : CameraParameters() {};
- QCameraParameters(const String8 ¶ms) { unflatten(params); }
-#endif
- ~QCameraParameters();
-
- // Supported PREVIEW/RECORDING SIZES IN HIGH FRAME RATE recording, sizes in pixels.
- // Example value: "800x480,432x320". Read only.
- static const char KEY_SUPPORTED_HFR_SIZES[];
- // The mode of preview frame rate.
- // Example value: "frame-rate-auto, frame-rate-fixed".
- static const char KEY_PREVIEW_FRAME_RATE_MODE[];
- static const char KEY_SUPPORTED_PREVIEW_FRAME_RATE_MODES[];
- static const char KEY_PREVIEW_FRAME_RATE_AUTO_MODE[];
- static const char KEY_PREVIEW_FRAME_RATE_FIXED_MODE[];
-
- static const char KEY_SKIN_TONE_ENHANCEMENT[] ;
- static const char KEY_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] ;
-
- //Touch Af/AEC settings.
- static const char KEY_TOUCH_AF_AEC[];
- static const char KEY_SUPPORTED_TOUCH_AF_AEC[];
- //Touch Index for AEC.
- static const char KEY_TOUCH_INDEX_AEC[];
- //Touch Index for AF.
- static const char KEY_TOUCH_INDEX_AF[];
- // Current auto scene detection mode.
- // Example value: "off" or SCENE_DETECT_XXX constants. Read/write.
- static const char KEY_SCENE_DETECT[];
- // Supported auto scene detection settings.
- // Example value: "off,backlight,snow/cloudy". Read only.
- static const char KEY_SUPPORTED_SCENE_DETECT[];
- // Returns true if video snapshot is supported. That is, applications
- static const char KEY_FULL_VIDEO_SNAP_SUPPORTED[];
- static const char KEY_POWER_MODE_SUPPORTED[];
-
- static const char KEY_ISO_MODE[];
- static const char KEY_SUPPORTED_ISO_MODES[];
- static const char KEY_LENSSHADE[] ;
- static const char KEY_SUPPORTED_LENSSHADE_MODES[] ;
-
- static const char KEY_AUTO_EXPOSURE[];
- static const char KEY_SUPPORTED_AUTO_EXPOSURE[];
-
- static const char KEY_GPS_LATITUDE_REF[];
- static const char KEY_GPS_LONGITUDE_REF[];
- static const char KEY_GPS_ALTITUDE_REF[];
- static const char KEY_GPS_STATUS[];
- static const char KEY_EXIF_DATETIME[];
- static const char KEY_MEMORY_COLOR_ENHANCEMENT[];
- static const char KEY_SUPPORTED_MEM_COLOR_ENHANCE_MODES[];
-
-
- static const char KEY_POWER_MODE[];
-
- static const char KEY_ZSL[];
- static const char KEY_SUPPORTED_ZSL_MODES[];
-
- static const char KEY_CAMERA_MODE[];
-
- static const char KEY_VIDEO_HIGH_FRAME_RATE[];
- static const char KEY_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[];
- static const char KEY_HIGH_DYNAMIC_RANGE_IMAGING[];
- static const char KEY_SUPPORTED_HDR_IMAGING_MODES[];
- static const char KEY_AE_BRACKET_HDR[];
-
-
- // DENOISE
- static const char KEY_DENOISE[];
- static const char KEY_SUPPORTED_DENOISE[];
-
- //Selectable zone AF.
- static const char KEY_SELECTABLE_ZONE_AF[];
- static const char KEY_SUPPORTED_SELECTABLE_ZONE_AF[];
-
- //Face Detection
- static const char KEY_FACE_DETECTION[];
- static const char KEY_SUPPORTED_FACE_DETECTION[];
-
- //Redeye Reduction
- static const char KEY_REDEYE_REDUCTION[];
- static const char KEY_SUPPORTED_REDEYE_REDUCTION[];
- static const char EFFECT_EMBOSS[];
- static const char EFFECT_SKETCH[];
- static const char EFFECT_NEON[];
-
- // Values for Touch AF/AEC
- static const char TOUCH_AF_AEC_OFF[] ;
- static const char TOUCH_AF_AEC_ON[] ;
- static const char SCENE_MODE_ASD[];
- static const char SCENE_MODE_BACKLIGHT[];
- static const char SCENE_MODE_FLOWERS[];
- static const char SCENE_MODE_AR[];
- static const char SCENE_DETECT_OFF[];
- static const char SCENE_DETECT_ON[];
- static const char PIXEL_FORMAT_YUV420SP_ADRENO[]; // ADRENO
- static const char PIXEL_FORMAT_RAW[];
- static const char PIXEL_FORMAT_YV12[]; // NV12
- static const char PIXEL_FORMAT_NV12[]; //NV12
- // Normal focus mode. Applications should call
- // CameraHardwareInterface.autoFocus to start the focus in this mode.
- static const char FOCUS_MODE_NORMAL[];
- static const char ISO_AUTO[];
- static const char ISO_HJR[] ;
- static const char ISO_100[];
- static const char ISO_200[] ;
- static const char ISO_400[];
- static const char ISO_800[];
- static const char ISO_1600[];
- // Values for Lens Shading
- static const char LENSSHADE_ENABLE[] ;
- static const char LENSSHADE_DISABLE[] ;
-
- // Values for auto exposure settings.
- static const char AUTO_EXPOSURE_FRAME_AVG[];
- static const char AUTO_EXPOSURE_CENTER_WEIGHTED[];
- static const char AUTO_EXPOSURE_SPOT_METERING[];
-
- static const char KEY_SHARPNESS[];
- static const char KEY_MAX_SHARPNESS[];
- static const char KEY_CONTRAST[];
- static const char KEY_MAX_CONTRAST[];
- static const char KEY_SATURATION[];
- static const char KEY_MAX_SATURATION[];
-
- static const char KEY_HISTOGRAM[] ;
- static const char KEY_SUPPORTED_HISTOGRAM_MODES[] ;
- // Values for HISTOGRAM
- static const char HISTOGRAM_ENABLE[] ;
- static const char HISTOGRAM_DISABLE[] ;
-
- // Values for SKIN TONE ENHANCEMENT
- static const char SKIN_TONE_ENHANCEMENT_ENABLE[] ;
- static const char SKIN_TONE_ENHANCEMENT_DISABLE[] ;
-
- // Values for Denoise
- static const char DENOISE_OFF[] ;
- static const char DENOISE_ON[] ;
-
- // Values for auto exposure settings.
- static const char SELECTABLE_ZONE_AF_AUTO[];
- static const char SELECTABLE_ZONE_AF_SPOT_METERING[];
- static const char SELECTABLE_ZONE_AF_CENTER_WEIGHTED[];
- static const char SELECTABLE_ZONE_AF_FRAME_AVERAGE[];
-
- // Values for Face Detection settings.
- static const char FACE_DETECTION_OFF[];
- static const char FACE_DETECTION_ON[];
-
- // Values for MCE settings.
- static const char MCE_ENABLE[];
- static const char MCE_DISABLE[];
-
- // Values for ZSL settings.
- static const char ZSL_OFF[];
- static const char ZSL_ON[];
-
- // Values for HDR Bracketing settings.
- static const char AE_BRACKET_HDR_OFF[];
- static const char AE_BRACKET_HDR[];
- static const char AE_BRACKET[];
-
- // Values for Power mode settings.
- static const char LOW_POWER[];
- static const char NORMAL_POWER[];
-
- // Values for HFR settings.
- static const char VIDEO_HFR_OFF[];
- static const char VIDEO_HFR_2X[];
- static const char VIDEO_HFR_3X[];
- static const char VIDEO_HFR_4X[];
-
- // Values for Redeye Reduction settings.
- static const char REDEYE_REDUCTION_ENABLE[];
- static const char REDEYE_REDUCTION_DISABLE[];
- // Values for HDR settings.
- static const char HDR_ENABLE[];
- static const char HDR_DISABLE[];
-
- // Values for Redeye Reduction settings.
- // static const char REDEYE_REDUCTION_ENABLE[];
- // static const char REDEYE_REDUCTION_DISABLE[];
- // Values for HDR settings.
- // static const char HDR_ENABLE[];
- // static const char HDR_DISABLE[];
-
-
- static const char KEY_SINGLE_ISP_OUTPUT_ENABLED[];
-
- enum {
- CAMERA_ORIENTATION_UNKNOWN = 0,
- CAMERA_ORIENTATION_PORTRAIT = 1,
- CAMERA_ORIENTATION_LANDSCAPE = 2,
- };
- int getOrientation() const;
- void setOrientation(int orientation);
- void getSupportedHfrSizes(Vector<Size> &sizes) const;
- void setPreviewFpsRange(int minFPS,int maxFPS);
- void setPreviewFrameRateMode(const char *mode);
- const char *getPreviewFrameRateMode() const;
- void setTouchIndexAec(int x, int y);
- void getTouchIndexAec(int *x, int *y) const;
- void setTouchIndexAf(int x, int y);
- void getTouchIndexAf(int *x, int *y) const;
- void getMeteringAreaCenter(int * x, int *y) const;
-
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL2/core/inc/QCameraStream.h b/camera/QCamera/HAL2/core/inc/QCameraStream.h
deleted file mode 100644
index a2fb8d7..0000000
--- a/camera/QCamera/HAL2/core/inc/QCameraStream.h
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
-** Copyright 2008, Google Inc.
-** Copyright (c) 2009-2012, The Linux Foundation. All rights reserved.
-**
-** 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_QCAMERA_STREAM_H
-#define ANDROID_HARDWARE_QCAMERA_STREAM_H
-
-
-#include <utils/threads.h>
-
-#include <binder/MemoryBase.h>
-#include <binder/MemoryHeapBase.h>
-#include <utils/threads.h>
-
-
-#include "QCameraHWI.h"
-extern "C" {
-#include <mm_camera_interface.h>
-#include <mm_jpeg_interface.h>
-
-#define OPAQUE_BUFFER_COUNT 5
-#define STREAM_TABLE_SIZE 8
-
-#define MM_CAMERA_CH_PREVIEW_MASK (0x01 << MM_CAMERA_CH_PREVIEW)
-#define MM_CAMERA_CH_VIDEO_MASK (0x01 << MM_CAMERA_CH_VIDEO)
-#define MM_CAMERA_CH_SNAPSHOT_MASK (0x01 << MM_CAMERA_CH_SNAPSHOT)
-
-} /* extern C*/
-
-namespace android {
-
-class QCameraHardwareInterface;
-
-class StreamQueue {
-private:
- Mutex mQueueLock;
- Condition mQueueWait;
- bool mInitialized;
-
- //Vector<struct msm_frame *> mContainer;
- Vector<void *> mContainer;
-public:
- StreamQueue();
- virtual ~StreamQueue();
- bool enqueue(void *element);
- void flush();
- void* dequeue();
- void init();
- void deinit();
- bool isInitialized();
-bool isEmpty();
-};
-
-typedef struct {
- int buffer_count;
- buffer_handle_t buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
- struct private_handle_t *private_buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
- int stride[MM_CAMERA_MAX_NUM_FRAMES];
- uint32_t addr_offset[MM_CAMERA_MAX_NUM_FRAMES];
- uint8_t local_flag[MM_CAMERA_MAX_NUM_FRAMES];
- int main_ion_fd[MM_CAMERA_MAX_NUM_FRAMES];
- struct ion_fd_data ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES];
-} QCameraStreamMemory_t;
-
-class QCameraStream {
-
-public:
- bool mInit;
- bool mActive;
-
- uint32_t mCameraHandle;
- uint32_t mChannelId;
- uint32_t mMmStreamId;
- uint32_t mWidth;
- uint32_t mHeight;
- cam_format_t mFormat;
- uint8_t mNumBuffers;
- mm_camera_frame_len_offset mFrameOffsetInfo;
- mm_camera_vtbl_t *p_mm_ops;
- mm_camera_img_mode mExtImgMode;
-
- uint8_t mPendingCount;
-
- pthread_mutex_t mFrameDeliveredMutex;
- pthread_cond_t mFrameDeliveredCond;
-
- virtual status_t init();
- virtual status_t start();
- virtual void stop();
- virtual void release();
-
- status_t setFormat();
- status_t setMode(int enable);
-
- int getStreamId() {return mStreamId;}
- int getMaxBuffers() {return mMaxBuffers;}
-
- static QCameraStream *getStreamAtId(int id);
- static QCameraStream *getStreamAtMmId(uint32_t mm_id);
- static void streamOffAll();
-
- virtual void setHALCameraControl(QCameraHardwareInterface* ctrl);
-
- virtual int prepareStream() {return NO_ERROR;}
- void onNewRequest();
- void dataCallback(mm_camera_super_buf_t *bufs);
- int32_t streamOn();
- int32_t streamOff(bool aSync);
- virtual status_t initStream(mm_camera_img_mode imgmode, cam_format_t format);
- virtual status_t deinitStream();
- virtual status_t initBuffers(){return NO_ERROR;}
- virtual sp<IMemoryHeap> getRawHeap() const {return NULL;}
- virtual void *getLastQueuedFrame(void){return NULL;}
- virtual status_t processPreviewFrame(mm_camera_super_buf_t *frame){return NO_ERROR;}
-
- /* Set the ANativeWindow */
- virtual int setPreviewWindow(const camera2_stream_ops_t* window) {return NO_ERROR;}
- virtual void notifyWDenoiseEvent(cam_ctrl_status_t status, void * cookie) {;}
- virtual void resetSnapshotCounters(void ){};
- virtual void initHdrInfoForSnapshot(bool HDR_on, int number_frames, int *exp){};
- virtual void notifyHdrEvent(cam_ctrl_status_t status, void * cookie){};
- virtual status_t receiveRawPicture(mm_camera_super_buf_t* recvd_frame){return NO_ERROR;};
-
- QCameraStream(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- mm_camera_vtbl_t *mm_ops,
- camera_mode_t mode);
- virtual ~QCameraStream();
-public:
- QCameraHardwareInterface* mHalCamCtrl;
- mm_camera_rect_t mCrop;
-
- camera_mode_t myMode;
-
- mutable Mutex mLock;
-protected:
-
- uint32_t mStreamId;
- int mMaxBuffers;
- int allocateStreamId();
- int deallocateStreamId(int id);
-
-private:
- static QCameraStream *mStreamTable[STREAM_TABLE_SIZE];
-
- StreamQueue mBusyQueue;
- StreamQueue mFreeQueue;
-
- QCameraStream();
-public:
-// friend void liveshot_callback(mm_camera_ch_data_buf_t *frame,void *user_data);
-};
-
-class QCameraStream_preview : public QCameraStream {
-public:
- status_t init();
- status_t start() ;
- void stop() ;
- void release() ;
-
- static QCameraStream* createInstance(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- int requestedFormat,
- mm_camera_vtbl_t *mm_ops,
- camera_mode_t mode);
- static void deleteInstance(QCameraStream *p);
-
- virtual ~QCameraStream_preview();
- void *getLastQueuedFrame(void);
- status_t initBuffers();
- void deinitBuffers();
-
- virtual int prepareStream();
- virtual status_t processPreviewFrame(mm_camera_super_buf_t *frame);
-
- int setPreviewWindow(const camera2_stream_ops_t* window);
- int registerStreamBuffers(int num_buffers, buffer_handle_t *buffers);
- friend class QCameraHardwareInterface;
-
-private:
- QCameraStream_preview();
- QCameraStream_preview(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- int requestedFormat,
- mm_camera_vtbl_t *mm_ops,
- camera_mode_t mode);
-
- void dumpFrameToFile(mm_camera_buf_def_t* newFrame);
-
-private:
- bool mFirstFrameRcvd;
- QCameraStreamMemory_t mPreviewMemory;
- Mutex mPreviewMemoryLock;
-
- int8_t my_id;
- mm_camera_op_mode_type_t op_mode;
- mm_camera_buf_def_t *mLastQueuedFrame;
- mm_camera_buf_def_t *mDisplayBuf;
- Mutex mDisplayLock;
- const camera2_stream_ops_t *mPreviewWindow;
- mm_camera_super_buf_t mNotifyBuffer[16];
- int8_t mNumFDRcvd;
- int mVFEOutputs;
- int mHFRFrameCnt;
- int mHFRFrameSkip;
-};
-
-class QCameraStream_SnapshotMain : public QCameraStream {
-public:
- status_t init();
- status_t start();
- void stop();
- void release();
- status_t initMainBuffers();
- void releaseMainBuffers();
- void initHdrInfoForSnapshot(bool HDR_on, int number_frames, int *exp);
- void notifyHdrEvent(cam_ctrl_status_t status, void * cookie);
- static void deleteInstance(QCameraStream *p);
- status_t receiveRawPicture(mm_camera_super_buf_t* recvd_frame);
- mm_camera_buf_def_t mSnapshotStreamBuf[MM_CAMERA_MAX_NUM_FRAMES];
- static QCameraStream* createInstance(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode);
- QCameraStream_SnapshotMain(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode);
- ~QCameraStream_SnapshotMain();
-
-private:
- status_t doHdrProcessing();
- status_t encodeData(mm_camera_super_buf_t* recvd_frame);
- /*Member variables*/
- mm_jpeg_ops_t mJpegHandle;
- uint32_t mJpegClientHandle;
- int mSnapshotState;
- StreamQueue mSnapshotQueue;
-};
-
-class QCameraStream_SnapshotThumbnail : public QCameraStream {
-public:
- status_t init();
- status_t start();
- void stop();
- void release();
- status_t initThumbnailBuffers();
- static QCameraStream* createInstance(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode);
- QCameraStream_SnapshotThumbnail(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- uint32_t Format,
- uint8_t NumBuffers,
- mm_camera_vtbl_t *mm_ops,
- mm_camera_img_mode imgmode,
- camera_mode_t mode);
- ~QCameraStream_SnapshotThumbnail();
- static void deleteInstance(QCameraStream *p);
- mm_camera_buf_def_t mPostviewStreamBuf[MM_CAMERA_MAX_NUM_FRAMES];
-};
-
-}; // namespace android
-
-#endif
diff --git a/camera/QCamera/HAL2/core/inc/QCamera_Intf.h b/camera/QCamera/HAL2/core/inc/QCamera_Intf.h
deleted file mode 100644
index bf6435e..0000000
--- a/camera/QCamera/HAL2/core/inc/QCamera_Intf.h
+++ /dev/null
@@ -1,2698 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- *
- */
-
-#ifndef __QCAMERA_INTF_H__
-#define __QCAMERA_INTF_H__
-
-#include <stdint.h>
-#include <pthread.h>
-#include <inttypes.h>
-#include <media/msm_camera.h>
-
-#define PAD_TO_WORD(a) (((a)+3)&~3)
-#define PAD_TO_2K(a) (((a)+2047)&~2047)
-#define PAD_TO_4K(a) (((a)+4095)&~4095)
-#define PAD_TO_8K(a) (((a)+8191)&~8191)
-
-#define CEILING32(X) (((X) + 0x0001F) & 0xFFFFFFE0)
-#define CEILING16(X) (((X) + 0x000F) & 0xFFF0)
-#define CEILING4(X) (((X) + 0x0003) & 0xFFFC)
-#define CEILING2(X) (((X) + 0x0001) & 0xFFFE)
-
-#define MAX_ROI 2
-#define MAX_NUM_PARM 5
-#define MAX_NUM_OPS 2
-#define VIDEO_MAX_PLANES 8
-#define MAX_SNAPSHOT_BUFFERS 5
-#define MAX_EXP_BRACKETING_LENGTH 32
-#define ANDROID_FB0 "/dev/graphics/fb0"
-#define LE_FB0 "/dev/fb0"
-
-// Events common to encoder and decoder
-#define JPEG_EVENT_DONE 0
-#define JPEG_EVENT_WARNING 1
-#define JPEG_EVENT_ERROR 2
-#define JPEG_EVENT_ABORTED 3
-// Events specific to encoder
-#define JPEG_EVENT_THUMBNAIL_DROPPED 4
-
-/* Exif Tag ID */
-typedef uint32_t exif_tag_id_t;
-
-/* Exif Info (opaque definition) */
-struct exif_info_t;
-typedef struct exif_info_t * exif_info_obj_t;
-
-typedef enum {
- BACK_CAMERA,
- FRONT_CAMERA,
-}cam_position_t;
-
-typedef enum {
- CAM_CTRL_FAILED, /* Failure in doing operation */
- CAM_CTRL_SUCCESS, /* Operation Succeded */
- CAM_CTRL_INVALID_PARM, /* Inavlid parameter provided */
- CAM_CTRL_NOT_SUPPORTED, /* Parameter/operation not supported */
- CAM_CTRL_ACCEPTED, /* Parameter accepted */
- CAM_CTRL_MAX,
-} cam_ctrl_status_t;
-
-typedef enum {
- CAMERA_YUV_420_NV12,
- CAMERA_YUV_420_NV21,
- CAMERA_YUV_420_NV21_ADRENO,
- CAMERA_BAYER_SBGGR10,
- CAMERA_RDI,
- CAMERA_YUV_420_YV12,
- CAMERA_YUV_422_NV16,
- CAMERA_YUV_422_NV61,
- CAMERA_YUV_422_YUYV,
-} cam_format_t;
-
-typedef enum {
- CAMERA_PAD_NONE,
- CAMERA_PAD_TO_WORD, /*2 bytes*/
- CAMERA_PAD_TO_LONG_WORD, /*4 bytes*/
- CAMERA_PAD_TO_8, /*8 bytes*/
- CAMERA_PAD_TO_16, /*16 bytes*/
-
- CAMERA_PAD_TO_1K, /*1k bytes*/
- CAMERA_PAD_TO_2K, /*2k bytes*/
- CAMERA_PAD_TO_4K,
- CAMERA_PAD_TO_8K
-} cam_pad_format_t;
-
-typedef struct {
- int ext_mode; /* preview, main, thumbnail, video, raw, etc */
- int frame_idx; /* frame index */
- int fd; /* origin fd */
- uint32_t size;
-} mm_camera_frame_map_type;
-
-typedef struct {
- int ext_mode; /* preview, main, thumbnail, video, raw, etc */
- int frame_idx; /* frame index */
-} mm_camera_frame_unmap_type;
-
-typedef enum {
- CAM_SOCK_MSG_TYPE_FD_MAPPING,
- CAM_SOCK_MSG_TYPE_FD_UNMAPPING,
- CAM_SOCK_MSG_TYPE_WDN_START,
- CAM_SOCK_MSG_TYPE_HIST_MAPPING,
- CAM_SOCK_MSG_TYPE_HIST_UNMAPPING,
- CAM_SOCK_MSG_TYPE_MAX
-}mm_camera_socket_msg_type;
-
-#define MM_MAX_WDN_NUM 2
-typedef struct {
- unsigned long cookie;
- int num_frames;
- int ext_mode[MM_MAX_WDN_NUM];
- int frame_idx[MM_MAX_WDN_NUM];
-} mm_camera_wdn_start_type;
-
-typedef struct {
- mm_camera_socket_msg_type msg_type;
- union {
- mm_camera_frame_map_type frame_fd_map;
- mm_camera_frame_unmap_type frame_fd_unmap;
- mm_camera_wdn_start_type wdn_start;
- } payload;
-} cam_sock_packet_t;
-
-
-typedef enum {
- CAM_VIDEO_FRAME,
- CAM_SNAPSHOT_FRAME,
- CAM_PREVIEW_FRAME,
-}cam_frame_type_t;
-
-
-typedef enum {
- CAMERA_MODE_2D = (1<<0),
- CAMERA_MODE_3D = (1<<1),
- CAMERA_NONZSL_MODE = (1<<2),
- CAMERA_ZSL_MODE = (1<<3),
- CAMERA_MODE_MAX = CAMERA_ZSL_MODE,
-} camera_mode_t;
-
-
-typedef struct {
- int modes_supported;
- int8_t camera_id;
- cam_position_t position;
- uint32_t sensor_mount_angle;
-}camera_info_t;
-
-typedef struct {
- camera_mode_t mode;
- int8_t camera_id;
- camera_mode_t cammode;
-}config_params_t;
-
-typedef struct {
- uint32_t len;
- uint32_t y_offset;
- uint32_t cbcr_offset;
-} cam_sp_len_offset_t;
-
-typedef struct{
- uint32_t len;
- uint32_t offset;
-} cam_mp_len_offset_t;
-
-typedef struct {
- int num_planes;
- union {
- cam_sp_len_offset_t sp;
- cam_mp_len_offset_t mp[8];
- };
- uint32_t frame_len;
-} cam_frame_len_offset_t;
-
-typedef struct {
- uint32_t parm[MAX_NUM_PARM];
- uint32_t ops[MAX_NUM_OPS];
- uint8_t yuv_output;
- uint8_t jpeg_capture;
- uint32_t max_pict_width;
- uint32_t max_pict_height;
- uint32_t max_preview_width;
- uint32_t max_preview_height;
- uint32_t max_video_width;
- uint32_t max_video_height;
- uint32_t effect;
- camera_mode_t modes;
- uint8_t preview_format;
- uint32_t preview_sizes_cnt;
- uint32_t thumb_sizes_cnt;
- uint32_t video_sizes_cnt;
- uint32_t hfr_sizes_cnt;
- uint8_t vfe_output_enable;
- uint8_t hfr_frame_skip;
- uint32_t default_preview_width;
- uint32_t default_preview_height;
- uint32_t bestshot_reconfigure;
- uint32_t pxlcode;
-}cam_prop_t;
-
-typedef struct {
- uint16_t video_width; /* Video width seen by VFE could be different than orig. Ex. DIS */
- uint16_t video_height; /* Video height seen by VFE */
- uint16_t picture_width; /* Picture width seen by VFE */
- uint16_t picture_height; /* Picture height seen by VFE */
- uint16_t display_width; /* width of display */
- uint16_t display_height; /* height of display */
- uint16_t orig_video_width; /* original video width received */
- uint16_t orig_video_height; /* original video height received */
- uint16_t orig_picture_dx; /* original picture width received */
- uint16_t orig_picture_dy; /* original picture height received */
- uint16_t ui_thumbnail_height; /* Just like orig_picture_dx */
- uint16_t ui_thumbnail_width; /* Just like orig_picture_dy */
- uint16_t thumbnail_height;
- uint16_t thumbnail_width;
- uint16_t orig_picture_width;
- uint16_t orig_picture_height;
- uint16_t orig_thumb_width;
- uint16_t orig_thumb_height;
- uint16_t raw_picture_height;
- uint16_t raw_picture_width;
- uint16_t rdi0_height;
- uint16_t rdi0_width;
- uint16_t rdi1_height;
- uint16_t rdi1_width;
- uint32_t hjr_xtra_buff_for_bayer_filtering;
- cam_format_t prev_format;
- cam_format_t enc_format;
- cam_format_t thumb_format;
- cam_format_t main_img_format;
- cam_format_t rdi0_format;
- cam_format_t rdi1_format;
- cam_format_t raw_img_format;
- cam_pad_format_t prev_padding_format;
- cam_pad_format_t enc_padding_format;
- cam_pad_format_t thumb_padding_format;
- cam_pad_format_t main_padding_format;
- uint16_t display_luma_width;
- uint16_t display_luma_height;
- uint16_t display_chroma_width;
- uint16_t display_chroma_height;
- uint16_t video_luma_width;
- uint16_t video_luma_height;
- uint16_t video_chroma_width;
- uint16_t video_chroma_height;
- uint16_t thumbnail_luma_width;
- uint16_t thumbnail_luma_height;
- uint16_t thumbnail_chroma_width;
- uint16_t thumbnail_chroma_height;
- uint16_t main_img_luma_width;
- uint16_t main_img_luma_height;
- uint16_t main_img_chroma_width;
- uint16_t main_img_chroma_height;
- int rotation;
- cam_frame_len_offset_t display_frame_offset;
- cam_frame_len_offset_t video_frame_offset;
- cam_frame_len_offset_t picture_frame_offset;
- cam_frame_len_offset_t thumb_frame_offset;
- uint32_t channel_interface_mask;
-} cam_ctrl_dimension_t;
-
-typedef struct {
- uint8_t cid;
- uint8_t dt;
- uint32_t inst_handle;
-} cam_cid_entry_t;
-
-#define CAM_MAX_CID_NUM 8
-typedef struct {
- /*should we hard code max CIDs? if not we need to have two CMD*/
- uint8_t num_cids;
- cam_cid_entry_t cid_entries[CAM_MAX_CID_NUM];
-} cam_cid_info_t;
-
-typedef struct {
- /* we still use prev, video, main,
- * thumb to interprete image types */
- uint32_t image_mode; /* input */
- cam_format_t format; /* input */
- cam_pad_format_t padding_format; /* input */
- int rotation; /* input */
- uint16_t width; /* input/output */
- uint16_t height; /* input/output */
- cam_frame_len_offset_t frame_offset; /* output */
-} cam_frame_resolution_t;
-
-/* Add enumenrations at the bottom but before MM_CAMERA_PARM_MAX */
-typedef enum {
- MM_CAMERA_PARM_PICT_SIZE,
- MM_CAMERA_PARM_ZOOM_RATIO,
- MM_CAMERA_PARM_HISTOGRAM,
- MM_CAMERA_PARM_DIMENSION,
- MM_CAMERA_PARM_FPS,
- MM_CAMERA_PARM_FPS_MODE, /*5*/
- MM_CAMERA_PARM_EFFECT,
- MM_CAMERA_PARM_EXPOSURE_COMPENSATION,
- MM_CAMERA_PARM_EXPOSURE,
- MM_CAMERA_PARM_SHARPNESS,
- MM_CAMERA_PARM_CONTRAST, /*10*/
- MM_CAMERA_PARM_SATURATION,
- MM_CAMERA_PARM_BRIGHTNESS,
- MM_CAMERA_PARM_WHITE_BALANCE,
- MM_CAMERA_PARM_LED_MODE,
- MM_CAMERA_PARM_ANTIBANDING, /*15*/
- MM_CAMERA_PARM_ROLLOFF,
- MM_CAMERA_PARM_CONTINUOUS_AF,
- MM_CAMERA_PARM_FOCUS_RECT,
- MM_CAMERA_PARM_AEC_ROI,
- MM_CAMERA_PARM_AF_ROI, /*20*/
- MM_CAMERA_PARM_HJR,
- MM_CAMERA_PARM_ISO,
- MM_CAMERA_PARM_BL_DETECTION,
- MM_CAMERA_PARM_SNOW_DETECTION,
- MM_CAMERA_PARM_BESTSHOT_MODE, /*25*/
- MM_CAMERA_PARM_ZOOM,
- MM_CAMERA_PARM_VIDEO_DIS,
- MM_CAMERA_PARM_VIDEO_ROT,
- MM_CAMERA_PARM_SCE_FACTOR,
- MM_CAMERA_PARM_FD, /*30*/
- MM_CAMERA_PARM_MODE,
- /* 2nd 32 bits */
- MM_CAMERA_PARM_3D_FRAME_FORMAT,
- MM_CAMERA_PARM_CAMERA_ID,
- MM_CAMERA_PARM_CAMERA_INFO,
- MM_CAMERA_PARM_PREVIEW_SIZE, /*35*/
- MM_CAMERA_PARM_QUERY_FALSH4SNAP,
- MM_CAMERA_PARM_FOCUS_DISTANCES,
- MM_CAMERA_PARM_BUFFER_INFO,
- MM_CAMERA_PARM_JPEG_ROTATION,
- MM_CAMERA_PARM_JPEG_MAINIMG_QUALITY, /* 40 */
- MM_CAMERA_PARM_JPEG_THUMB_QUALITY,
- MM_CAMERA_PARM_ZSL_ENABLE,
- MM_CAMERA_PARM_FOCAL_LENGTH,
- MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE,
- MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE, /* 45 */
- MM_CAMERA_PARM_MCE,
- MM_CAMERA_PARM_RESET_LENS_TO_INFINITY,
- MM_CAMERA_PARM_SNAPSHOTDATA,
- MM_CAMERA_PARM_HFR,
- MM_CAMERA_PARM_REDEYE_REDUCTION, /* 50 */
- MM_CAMERA_PARM_WAVELET_DENOISE,
- MM_CAMERA_PARM_3D_DISPLAY_DISTANCE,
- MM_CAMERA_PARM_3D_VIEW_ANGLE,
- MM_CAMERA_PARM_PREVIEW_FORMAT,
- MM_CAMERA_PARM_RDI_FORMAT,
- MM_CAMERA_PARM_HFR_SIZE, /* 55 */
- MM_CAMERA_PARM_3D_EFFECT,
- MM_CAMERA_PARM_3D_MANUAL_CONV_RANGE,
- MM_CAMERA_PARM_3D_MANUAL_CONV_VALUE,
- MM_CAMERA_PARM_ENABLE_3D_MANUAL_CONVERGENCE,
- /* These are new parameters defined here */
- MM_CAMERA_PARM_CH_IMAGE_FMT, /* 60 */ // mm_camera_ch_image_fmt_parm_t
- MM_CAMERA_PARM_OP_MODE, // camera state, sub state also
- MM_CAMERA_PARM_SHARPNESS_CAP, //
- MM_CAMERA_PARM_SNAPSHOT_BURST_NUM, // num shots per snapshot action
- MM_CAMERA_PARM_LIVESHOT_MAIN, // enable/disable full size live shot
- MM_CAMERA_PARM_MAXZOOM, /* 65 */
- MM_CAMERA_PARM_LUMA_ADAPTATION, // enable/disable
- MM_CAMERA_PARM_HDR,
- MM_CAMERA_PARM_CROP,
- MM_CAMERA_PARM_MAX_PICTURE_SIZE,
- MM_CAMERA_PARM_MAX_PREVIEW_SIZE, /* 70 */
- MM_CAMERA_PARM_ASD_ENABLE,
- MM_CAMERA_PARM_RECORDING_HINT,
- MM_CAMERA_PARM_CAF_ENABLE,
- MM_CAMERA_PARM_FULL_LIVESHOT,
- MM_CAMERA_PARM_DIS_ENABLE, /* 75 */
- MM_CAMERA_PARM_AEC_LOCK,
- MM_CAMERA_PARM_AWB_LOCK,
- MM_CAMERA_PARM_AF_MTR_AREA,
- MM_CAMERA_PARM_AEC_MTR_AREA,
- MM_CAMERA_PARM_LOW_POWER_MODE,
- MM_CAMERA_PARM_MAX_HFR_MODE, /* 80 */
- MM_CAMERA_PARM_MAX_VIDEO_SIZE,
- MM_CAMERA_PARM_DEF_PREVIEW_SIZES,
- MM_CAMERA_PARM_DEF_VIDEO_SIZES,
- MM_CAMERA_PARM_DEF_THUMB_SIZES,
- MM_CAMERA_PARM_DEF_HFR_SIZES,
- MM_CAMERA_PARM_PREVIEW_SIZES_CNT,
- MM_CAMERA_PARM_VIDEO_SIZES_CNT,
- MM_CAMERA_PARM_THUMB_SIZES_CNT,
- MM_CAMERA_PARM_HFR_SIZES_CNT,
- MM_CAMERA_PARM_GRALLOC_USAGE,
- MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, //to check whether both oputputs are
- MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH,
- MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT,
- MM_CAMERA_PARM_FOCUS_MODE,
- MM_CAMERA_PARM_HFR_FRAME_SKIP,
- MM_CAMERA_PARM_CH_INTERFACE,
- //or single output enabled to differentiate 7x27a with others
- MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
- MM_CAMERA_PARM_MAX_NUM_FACES_DECT,
- MM_CAMERA_PARM_FPS_RANGE,
- MM_CAMERA_PARM_CID,
- MM_CAMERA_PARM_FRAME_RESOLUTION,
- MM_CAMERA_PARM_RAW_SNAPSHOT_FMT,
- MM_CAMERA_PARM_FACIAL_FEATURE_INFO,
- MM_CAMERA_PARM_CAF_LOCK_CANCEL,
- MM_CAMERA_PARM_APERTURE,
- MM_CAMERA_PARM_MAX
-} mm_camera_parm_type_t;
-
-typedef enum {
- STREAM_IMAGE,
- STREAM_RAW,
- STREAM_IMAGE_AND_RAW,
- STREAM_RAW_AND_RAW,
- STREAM_MAX,
-} mm_camera_channel_stream_info_t;
-
-typedef enum {
- CAMERA_SET_PARM_DISPLAY_INFO,
- CAMERA_SET_PARM_DIMENSION,
-
- CAMERA_SET_PARM_ZOOM,
- CAMERA_SET_PARM_SENSOR_POSITION,
- CAMERA_SET_PARM_FOCUS_RECT,
- CAMERA_SET_PARM_LUMA_ADAPTATION,
- CAMERA_SET_PARM_CONTRAST,
- CAMERA_SET_PARM_BRIGHTNESS,
- CAMERA_SET_PARM_EXPOSURE_COMPENSATION,
- CAMERA_SET_PARM_SHARPNESS,
- CAMERA_SET_PARM_HUE, /* 10 */
- CAMERA_SET_PARM_SATURATION,
- CAMERA_SET_PARM_EXPOSURE,
- CAMERA_SET_PARM_AUTO_FOCUS,
- CAMERA_SET_PARM_WB,
- CAMERA_SET_PARM_EFFECT,
- CAMERA_SET_PARM_FPS,
- CAMERA_SET_PARM_FLASH,
- CAMERA_SET_PARM_NIGHTSHOT_MODE,
- CAMERA_SET_PARM_REFLECT,
- CAMERA_SET_PARM_PREVIEW_MODE, /* 20 */
- CAMERA_SET_PARM_ANTIBANDING,
- CAMERA_SET_PARM_RED_EYE_REDUCTION,
- CAMERA_SET_PARM_FOCUS_STEP,
- CAMERA_SET_PARM_EXPOSURE_METERING,
- CAMERA_SET_PARM_AUTO_EXPOSURE_MODE,
- CAMERA_SET_PARM_ISO,
- CAMERA_SET_PARM_BESTSHOT_MODE,
- CAMERA_SET_PARM_ENCODE_ROTATION,
-
- CAMERA_SET_PARM_PREVIEW_FPS,
- CAMERA_SET_PARM_AF_MODE, /* 30 */
- CAMERA_SET_PARM_HISTOGRAM,
- CAMERA_SET_PARM_FLASH_STATE,
- CAMERA_SET_PARM_FRAME_TIMESTAMP,
- CAMERA_SET_PARM_STROBE_FLASH,
- CAMERA_SET_PARM_FPS_LIST,
- CAMERA_SET_PARM_HJR,
- CAMERA_SET_PARM_ROLLOFF,
-
- CAMERA_STOP_PREVIEW,
- CAMERA_START_PREVIEW,
- CAMERA_START_SNAPSHOT, /* 40 */
- CAMERA_START_RAW_SNAPSHOT,
- CAMERA_STOP_SNAPSHOT,
- CAMERA_EXIT,
- CAMERA_ENABLE_BSM,
- CAMERA_DISABLE_BSM,
- CAMERA_GET_PARM_ZOOM,
- CAMERA_GET_PARM_MAXZOOM,
- CAMERA_GET_PARM_ZOOMRATIOS,
- CAMERA_GET_PARM_AF_SHARPNESS,
- CAMERA_SET_PARM_LED_MODE, /* 50 */
- CAMERA_SET_MOTION_ISO,
- CAMERA_AUTO_FOCUS_CANCEL,
- CAMERA_GET_PARM_FOCUS_STEP,
- CAMERA_ENABLE_AFD,
- CAMERA_PREPARE_SNAPSHOT,
- CAMERA_SET_FPS_MODE,
- CAMERA_START_VIDEO,
- CAMERA_STOP_VIDEO,
- CAMERA_START_RECORDING,
- CAMERA_STOP_RECORDING, /* 60 */
- CAMERA_SET_VIDEO_DIS_PARAMS,
- CAMERA_SET_VIDEO_ROT_PARAMS,
- CAMERA_SET_PARM_AEC_ROI,
- CAMERA_SET_CAF,
- CAMERA_SET_PARM_BL_DETECTION_ENABLE,
- CAMERA_SET_PARM_SNOW_DETECTION_ENABLE,
- CAMERA_SET_PARM_STROBE_FLASH_MODE,
- CAMERA_SET_PARM_AF_ROI,
- CAMERA_START_LIVESHOT,
- CAMERA_SET_SCE_FACTOR, /* 70 */
- CAMERA_GET_CAPABILITIES,
- CAMERA_GET_PARM_DIMENSION,
- CAMERA_GET_PARM_LED_MODE,
- CAMERA_SET_PARM_FD,
- CAMERA_GET_PARM_3D_FRAME_FORMAT,
- CAMERA_QUERY_FLASH_FOR_SNAPSHOT,
- CAMERA_GET_PARM_FOCUS_DISTANCES,
- CAMERA_START_ZSL,
- CAMERA_STOP_ZSL,
- CAMERA_ENABLE_ZSL, /* 80 */
- CAMERA_GET_PARM_FOCAL_LENGTH,
- CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
- CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
- CAMERA_SET_PARM_WAVELET_DENOISE,
- CAMERA_SET_PARM_MCE,
- CAMERA_ENABLE_STEREO_CAM,
- CAMERA_SET_PARM_RESET_LENS_TO_INFINITY,
- CAMERA_GET_PARM_SNAPSHOTDATA,
- CAMERA_SET_PARM_HFR,
- CAMERA_SET_REDEYE_REDUCTION, /* 90 */
- CAMERA_SET_PARM_3D_DISPLAY_DISTANCE,
- CAMERA_SET_PARM_3D_VIEW_ANGLE,
- CAMERA_SET_PARM_3D_EFFECT,
- CAMERA_SET_PARM_PREVIEW_FORMAT,
- CAMERA_GET_PARM_3D_DISPLAY_DISTANCE, /* 95 */
- CAMERA_GET_PARM_3D_VIEW_ANGLE,
- CAMERA_GET_PARM_3D_EFFECT,
- CAMERA_GET_PARM_3D_MANUAL_CONV_RANGE,
- CAMERA_SET_PARM_3D_MANUAL_CONV_VALUE,
- CAMERA_ENABLE_3D_MANUAL_CONVERGENCE, /* 100 */
- CAMERA_SET_PARM_HDR,
- CAMERA_SET_ASD_ENABLE,
- CAMERA_POSTPROC_ABORT,
- CAMERA_SET_AEC_MTR_AREA,
- CAMERA_SET_AEC_LOCK, /*105*/
- CAMERA_SET_AWB_LOCK,
- CAMERA_SET_RECORDING_HINT,
- CAMERA_SET_PARM_CAF,
- CAMERA_SET_FULL_LIVESHOT,
- CAMERA_SET_DIS_ENABLE, /*110*/
- CAMERA_GET_PARM_MAX_HFR_MODE,
- CAMERA_SET_LOW_POWER_MODE,
- CAMERA_GET_PARM_DEF_PREVIEW_SIZES,
- CAMERA_GET_PARM_DEF_VIDEO_SIZES,
- CAMERA_GET_PARM_DEF_THUMB_SIZES, /*115*/
- CAMERA_GET_PARM_DEF_HFR_SIZES,
- CAMERA_GET_PARM_MAX_LIVESHOT_SIZE,
- CAMERA_GET_PARM_FPS_RANGE,
- CAMERA_SET_3A_CONVERGENCE,
- CAMERA_SET_PREVIEW_HFR, /*120*/
- CAMERA_GET_MAX_DIMENSION,
- CAMERA_GET_MAX_NUM_FACES_DECT,
- CAMERA_SET_CHANNEL_STREAM,
- CAMERA_GET_CHANNEL_STREAM,
- CAMERA_SET_PARM_CID, /*125*/
- CAMERA_GET_PARM_FRAME_RESOLUTION,
- CAMERA_GET_FACIAL_FEATURE_INFO,
- CAMERA_SET_CAF_LOCK_CANCEL,
- CAMERA_CTRL_PARM_MAX
-} cam_ctrl_type;
-
-typedef enum {
- CAMERA_ERROR_NO_MEMORY,
- CAMERA_ERROR_EFS_FAIL, /* Low-level operation failed */
- CAMERA_ERROR_EFS_FILE_OPEN, /* File already opened */
- CAMERA_ERROR_EFS_FILE_NOT_OPEN, /* File not opened */
- CAMERA_ERROR_EFS_FILE_ALREADY_EXISTS, /* File already exists */
- CAMERA_ERROR_EFS_NONEXISTENT_DIR, /* User directory doesn't exist */
- CAMERA_ERROR_EFS_NONEXISTENT_FILE, /* User directory doesn't exist */
- CAMERA_ERROR_EFS_BAD_FILE_NAME, /* Client specified invalid file/directory name*/
- CAMERA_ERROR_EFS_BAD_FILE_HANDLE, /* Client specified invalid file/directory name*/
- CAMERA_ERROR_EFS_SPACE_EXHAUSTED, /* Out of file system space */
- CAMERA_ERROR_EFS_OPEN_TABLE_FULL, /* Out of open-file table slots */
- CAMERA_ERROR_EFS_OTHER_ERROR, /* Other error */
- CAMERA_ERROR_CONFIG,
- CAMERA_ERROR_EXIF_ENCODE,
- CAMERA_ERROR_VIDEO_ENGINE,
- CAMERA_ERROR_IPL,
- CAMERA_ERROR_INVALID_FORMAT,
- CAMERA_ERROR_TIMEOUT,
- CAMERA_ERROR_ESD,
- CAMERA_ERROR_MAX
-} camera_error_type;
-
-#if defined CAMERA_ANTIBANDING_OFF
-#undef CAMERA_ANTIBANDING_OFF
-#endif
-
-#if defined CAMERA_ANTIBANDING_60HZ
-#undef CAMERA_ANTIBANDING_60HZ
-#endif
-
-#if defined CAMERA_ANTIBANDING_50HZ
-#undef CAMERA_ANTIBANDING_50HZ
-#endif
-
-#if defined CAMERA_ANTIBANDING_AUTO
-#undef CAMERA_ANTIBANDING_AUTO
-#endif
-
-typedef enum {
- CAMERA_ANTIBANDING_OFF,
- CAMERA_ANTIBANDING_60HZ,
- CAMERA_ANTIBANDING_50HZ,
- CAMERA_ANTIBANDING_AUTO,
- CAMERA_ANTIBANDING_AUTO_50HZ,
- CAMERA_ANTIBANDING_AUTO_60HZ,
- CAMERA_MAX_ANTIBANDING,
-} camera_antibanding_type;
-
-/* Enum Type for different ISO Mode supported */
-typedef enum {
- CAMERA_ISO_AUTO = 0,
- CAMERA_ISO_DEBLUR,
- CAMERA_ISO_100,
- CAMERA_ISO_200,
- CAMERA_ISO_400,
- CAMERA_ISO_800,
- CAMERA_ISO_1600,
- CAMERA_ISO_MAX
-} camera_iso_mode_type;
-
-typedef enum {
- MM_CAMERA_FACIAL_FEATURE_FD, // facial detection
- MM_CAMERA_FACIAL_FEATURE_MAX
-} camera_facial_features;
-
-typedef enum {
- AEC_ROI_OFF,
- AEC_ROI_ON
-} aec_roi_ctrl_t;
-
-typedef enum {
- AEC_ROI_BY_INDEX,
- AEC_ROI_BY_COORDINATE,
-} aec_roi_type_t;
-
-typedef struct {
- uint32_t x;
- uint32_t y;
-} cam_coordinate_type_t;
-
-/*
- * Define DRAW_RECTANGLES to draw rectangles on screen. Just for test purpose.
- */
-//#define DRAW_RECTANGLES
-
-typedef struct {
- uint16_t x;
- uint16_t y;
- uint16_t dx;
- uint16_t dy;
-} roi_t;
-
-typedef struct {
- aec_roi_ctrl_t aec_roi_enable;
- aec_roi_type_t aec_roi_type;
- union {
- cam_coordinate_type_t coordinate;
- uint32_t aec_roi_idx;
- } aec_roi_position;
-} cam_set_aec_roi_t;
-
-typedef struct {
- uint32_t frm_id;
- uint8_t num_roi;
- roi_t roi[MAX_ROI];
- uint8_t is_multiwindow;
-} roi_info_t;
-
-/* Exif Tag Data Type */
-typedef enum
-{
- EXIF_BYTE = 1,
- EXIF_ASCII = 2,
- EXIF_SHORT = 3,
- EXIF_LONG = 4,
- EXIF_RATIONAL = 5,
- EXIF_UNDEFINED = 7,
- EXIF_SLONG = 9,
- EXIF_SRATIONAL = 10
-} exif_tag_type_t;
-
-
-/* Exif Rational Data Type */
-typedef struct
-{
- uint32_t num; // Numerator
- uint32_t denom; // Denominator
-
-} rat_t;
-
-/* Exif Signed Rational Data Type */
-typedef struct
-{
- int32_t num; // Numerator
- int32_t denom; // Denominator
-
-} srat_t;
-
-typedef struct
-{
- exif_tag_type_t type;
- uint8_t copy;
- uint32_t count;
- union
- {
- char *_ascii;
- uint8_t *_bytes;
- uint8_t _byte;
- uint16_t *_shorts;
- uint16_t _short;
- uint32_t *_longs;
- uint32_t _long;
- rat_t *_rats;
- rat_t _rat;
- uint8_t *_undefined;
- int32_t *_slongs;
- int32_t _slong;
- srat_t *_srats;
- srat_t _srat;
- } data;
-} exif_tag_entry_t;
-
-typedef struct {
- uint32_t tag_id;
- exif_tag_entry_t tag_entry;
-} exif_tags_info_t;
-
-
-typedef enum {
- HDR_BRACKETING_OFF,
- HDR_MODE,
- EXP_BRACKETING_MODE
- } hdr_mode;
-
-typedef struct {
- hdr_mode mode;
- uint32_t hdr_enable;
- uint32_t total_frames;
- uint32_t total_hal_frames;
- char values[MAX_EXP_BRACKETING_LENGTH]; /* user defined values */
-} exp_bracketing_t;
-typedef struct {
- roi_t mtr_area[MAX_ROI];
- uint32_t num_area;
- int weight[MAX_ROI];
-} aec_mtr_area_t;
-
-typedef struct {
- int denoise_enable;
- int process_plates;
-} denoise_param_t;
-
-#ifndef HAVE_CAMERA_SIZE_TYPE
- #define HAVE_CAMERA_SIZE_TYPE
-struct camera_size_type {
- int width;
- int height;
-};
-#endif
-
-typedef struct {
- uint32_t yoffset;
- uint32_t cbcr_offset;
- uint32_t size;
- struct camera_size_type resolution;
-}cam_buf_info_t;
-
-typedef struct {
- int x;
- int y;
-}cam_point_t;
-
-typedef struct {
- /* AF parameters */
- uint8_t focus_position;
- /* AEC parameters */
- uint32_t line_count;
- uint8_t luma_target;
- /* AWB parameters */
- int32_t r_gain;
- int32_t b_gain;
- int32_t g_gain;
- uint8_t exposure_mode;
- uint8_t exposure_program;
- float exposure_time;
- uint32_t iso_speed;
-} snapshotData_info_t;
-
-
-typedef enum {
- CAMERA_HFR_MODE_OFF = 1,
- CAMERA_HFR_MODE_60FPS,
- CAMERA_HFR_MODE_90FPS,
- CAMERA_HFR_MODE_120FPS,
- CAMERA_HFR_MODE_150FPS,
-} camera_hfr_mode_t;
-
-/* frame Q*/
-struct fifo_node
-{
- struct fifo_node *next;
- void *f;
-};
-
-struct fifo_queue
-{
- int num_of_frames;
- struct fifo_node *front;
- struct fifo_node *back;
- pthread_mutex_t mut;
- pthread_cond_t wait;
- char* name;
-};
-
-typedef struct {
- uint32_t buf_len;
- uint8_t num;
- uint8_t pmem_type;
- uint32_t vaddr[8];
-} mm_camera_histo_mem_info_t;
-
-typedef enum {
- MM_CAMERA_CTRL_EVT_ZOOM_DONE,
- MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE,
- MM_CAMERA_CTRL_EVT_PREP_SNAPSHOT,
- MM_CAMERA_CTRL_EVT_SNAPSHOT_CONFIG_DONE,
- MM_CAMERA_CTRL_EVT_WDN_DONE, // wavelet denoise done
- MM_CAMERA_CTRL_EVT_ERROR,
- MM_CAMERA_CTRL_EVT_MAX
-}mm_camera_ctrl_event_type_t;
-
-typedef struct {
- mm_camera_ctrl_event_type_t evt;
- cam_ctrl_status_t status;
- unsigned long cookie;
-} mm_camera_ctrl_event_t;
-
-typedef enum {
- MM_CAMERA_CH_EVT_STREAMING_ON,
- MM_CAMERA_CH_EVT_STREAMING_OFF,
- MM_CAMERA_CH_EVT_STREAMING_ERR,
- MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE,
- MM_CAMERA_CH_EVT_DATA_REQUEST_MORE,
- MM_CAMERA_CH_EVT_MAX
-}mm_camera_ch_event_type_t;
-
-typedef struct {
- uint32_t ch;
- mm_camera_ch_event_type_t evt;
-} mm_camera_ch_event_t;
-
-typedef struct {
- uint32_t index;
- /* TBD: need more fields for histo stats? */
-} mm_camera_stats_histo_t;
-
-typedef struct {
- uint32_t event_id;
- union {
- mm_camera_stats_histo_t stats_histo;
- } e;
-} mm_camera_stats_event_t;
-
-typedef enum {
- FD_ROI_TYPE_HEADER,
- FD_ROI_TYPE_DATA
-} fd_roi_type_t;
-
-typedef struct {
- int fd_mode;
- int num_fd;
-} fd_set_parm_t;
-
-typedef struct {
- uint32_t frame_id;
- int16_t num_face_detected;
-} fd_roi_header_type;
-
-struct fd_rect_t {
- uint16_t x;
- uint16_t y;
- uint16_t dx;
- uint16_t dy;
-};
-
-typedef struct {
- struct fd_rect_t face_boundary;
- uint16_t left_eye_center[2];
- uint16_t right_eye_center[2];
- uint16_t mouth_center[2];
- uint8_t smile_degree; //0 -100
- uint8_t smile_confidence; //
- uint8_t blink_detected; // 0 or 1
- uint8_t is_face_recognised; // 0 or 1
- int8_t gaze_angle; // -90 -45 0 45 90 for head left to rigth tilt
- int8_t updown_dir; // -90 to 90
- int8_t leftright_dir; //-90 to 90
- int8_t roll_dir; // -90 to 90
- int8_t left_right_gaze; // -50 to 50
- int8_t top_bottom_gaze; // -50 to 50
- uint8_t left_blink; // 0 - 100
- uint8_t right_blink; // 0 - 100
- int8_t id; // unique id for face tracking within view unless view changes
- int8_t score; // score of confidence( 0 -100)
-} fd_face_type;
-
-typedef struct {
- uint32_t frame_id;
- uint8_t idx;
- fd_face_type face;
-} fd_roi_data_type;
-
-struct fd_roi_t {
- fd_roi_type_t type;
- union {
- fd_roi_header_type hdr;
- fd_roi_data_type data;
- } d;
-};
-
-typedef struct {
- uint32_t event_id;
- union {
- mm_camera_histo_mem_info_t histo_mem_info;
- struct fd_roi_t roi;
- } e;
-} mm_camera_info_event_t;
-
-
-typedef enum {
- MM_CAMERA_EVT_TYPE_CH,
- MM_CAMERA_EVT_TYPE_CTRL,
- MM_CAMERA_EVT_TYPE_STATS,
- MM_CAMERA_EVT_TYPE_INFO,
- MM_CAMERA_EVT_TYPE_MAX
-} mm_camera_event_type_t;
-
-/*
- * the APP event related defines
-*/
-typedef enum {
- MM_CAMERA_STATS_EVT_HISTO,
- MM_CAMERA_STATS_EVT_MAX
-} mm_camera_stats_event_type_t;
-
-typedef enum {
- MM_CAMERA_INFO_EVT_ROI,
- MM_CAMERA_INFO_FLASH_FRAME_IDX,
- MM_CAMERA_INFO_EVT_MAX
-} mm_camera_info_event_type_t;
-
-/* !!WARNING: PLAESE BE VERY CAREFUL!!
- * v4l2_event payload has a limitation of 64 bytes.
- * This makes that the whole mm_camera_event_t size
- * cannot go beyond 64 bytes.
- */
-typedef struct {
- mm_camera_event_type_t event_type;
- /* the union size cannot go beyond 64 bytes. need RFC */
- union {
- mm_camera_ch_event_t ch;
- mm_camera_ctrl_event_t ctrl;
- mm_camera_stats_event_t stats;
- mm_camera_info_event_t info;
- } e;
-} mm_camera_event_t;
-
-/******************************************************************************
- * Function: exif_set_tag
- * Description: Inserts or modifies an Exif tag to the Exif Info object. Typical
- * use is to call this function multiple times - to insert all the
- * desired Exif Tags individually to the Exif Info object and
- * then pass the info object to the Jpeg Encoder object so
- * the inserted tags would be emitted as tags in the Exif header.
- * Input parameters:
- * obj - The Exif Info object where the tag would be inserted to or
- * modified from.
- * tag_id - The Exif Tag ID of the tag to be inserted/modified.
- * p_entry - The pointer to the tag entry structure which contains the
- * details of tag. The pointer can be set to NULL to un-do
- * previous insertion for a certain tag.
- * Return values:
- * JPEGERR_SUCCESS
- * JPEGERR_ENULLPTR
- * JPEGERR_EFAILED
- * (See jpegerr.h for description of error values.)
- * Notes: none
- *****************************************************************************/
-int exif_set_tag(exif_info_obj_t obj,
- exif_tag_id_t tag_id,
- exif_tag_entry_t *p_entry);
-
-typedef uint32_t jpeg_event_t;
-
-/* Auto focus mode, used for CAMERA_PARM_AF_MODE */
-typedef enum {
- AF_MODE_UNCHANGED = -1,
- AF_MODE_NORMAL = 0,
- AF_MODE_MACRO,
- AF_MODE_AUTO,
- AF_MODE_CAF,
- AF_MODE_INFINITY,
- AF_MODE_MAX
-} isp3a_af_mode_t;
-
-typedef struct {
- uint32_t in1_w;
- uint32_t out1_w;
- uint32_t in1_h;
- uint32_t out1_h;
- uint32_t in2_w;
- uint32_t out2_w;
- uint32_t in2_h;
- uint32_t out2_h;
- uint8_t update_flag;
-} common_crop_t;
-
-typedef enum {
- LED_MODE_OFF,
- LED_MODE_AUTO,
- LED_MODE_ON,
- LED_MODE_TORCH,
-
- /*new mode above should be added above this line*/
- LED_MODE_MAX
-} led_mode_t;
-
-typedef struct video_dis_param_ctrl_t {
- uint32_t dis_enable; /* DIS feature: 1 = enable, 0 = disable.
- when enable, caller makes sure w/h are 10% more. */
- uint32_t video_rec_width; /* video frame width for recording */
- uint32_t video_rec_height; /* video frame height for recording */
- uint32_t output_cbcr_offset;
-} video_dis_param_ctrl_t;
-
-typedef enum camera_rotation_type {
- ROT_NONE = 0,
- ROT_CLOCKWISE_90 = 1,
- ROT_CLOCKWISE_180 = 6,
- ROT_CLOCKWISE_270 = 7,
-} camera_rotation_type;
-
-typedef struct video_rotation_param_ctrl_t {
- camera_rotation_type rotation; /* 0 degree = rot disable. */
-} video_rotation_param_ctrl_t;
-
-enum focus_distance_index{
- FOCUS_DISTANCE_NEAR_INDEX, /* 0 */
- FOCUS_DISTANCE_OPTIMAL_INDEX,
- FOCUS_DISTANCE_FAR_INDEX,
- FOCUS_DISTANCE_MAX_INDEX
-};
-
-typedef struct {
- float focus_distance[FOCUS_DISTANCE_MAX_INDEX];
- float real_gain;
-} focus_distances_info_t;
-
-typedef enum msm_st_frame_packing cam_3d_frame_format_t;
-
-typedef struct {
- cam_frame_type_t frame_type;
- cam_3d_frame_format_t format;
-}camera_3d_frame_t;
-
-// Possibly supported color formats
-// Ordering handcrafted for efficient coding, alter with care!
-typedef enum
-{
- YCRCBLP_H2V2 = 0,
- YCBCRLP_H2V2 = 1,
-
- YCRCBLP_H2V1 = 2,
- YCBCRLP_H2V1 = 3,
-
- YCRCBLP_H1V2 = 4,
- YCBCRLP_H1V2 = 5,
-
- YCRCBLP_H1V1 = 6,
- YCBCRLP_H1V1 = 7,
-
- RGB565 = 8,
- RGB888 = 9,
- RGBa = 10,
-
- JPEG_BITSTREAM_H2V2 = 12,
- JPEG_BITSTREAM_H2V1 = 14,
- JPEG_BITSTREAM_H1V2 = 16,
- JPEG_BITSTREAM_H1V1 = 18,
-
- JPEG_COLOR_FORMAT_MAX,
-
-} jpeg_color_format_t;
-
-typedef enum {
- CAMERA_BESTSHOT_OFF = 0,
- CAMERA_BESTSHOT_AUTO = 1,
- CAMERA_BESTSHOT_LANDSCAPE = 2,
- CAMERA_BESTSHOT_SNOW,
- CAMERA_BESTSHOT_BEACH,
- CAMERA_BESTSHOT_SUNSET,
- CAMERA_BESTSHOT_NIGHT,
- CAMERA_BESTSHOT_PORTRAIT,
- CAMERA_BESTSHOT_BACKLIGHT,
- CAMERA_BESTSHOT_SPORTS,
- CAMERA_BESTSHOT_ANTISHAKE,
- CAMERA_BESTSHOT_FLOWERS,
- CAMERA_BESTSHOT_CANDLELIGHT,
- CAMERA_BESTSHOT_FIREWORKS,
- CAMERA_BESTSHOT_PARTY,
- CAMERA_BESTSHOT_NIGHT_PORTRAIT,
- CAMERA_BESTSHOT_THEATRE,
- CAMERA_BESTSHOT_ACTION,
- CAMERA_BESTSHOT_AR,
- CAMERA_BESTSHOT_MAX
-} camera_bestshot_mode_type;
-
-typedef enum {
- AUTO = 1,
- SPOT,
- CENTER_WEIGHTED,
- AVERAGE
-} cam_af_focusrect_t;
-
-typedef enum {
- CAMERA_AEC_FRAME_AVERAGE,
- CAMERA_AEC_CENTER_WEIGHTED,
- CAMERA_AEC_SPOT_METERING,
- CAMERA_AEC_SMART_METERING,
- CAMERA_AEC_USER_METERING,
- CAMERA_AEC_MAX_MODES
-} camera_auto_exposure_mode_type;
-
-typedef enum {
- FPS_MODE_AUTO,
- FPS_MODE_FIXED,
-} fps_mode_t;
-
-typedef struct {
- int32_t buffer[256]; /* buffer to hold data */
- int32_t max_value;
-} camera_preview_histogram_info;
-
-/* Clockwise */
-typedef enum {
- CAMERA_ENCODING_ROTATE_0,
- CAMERA_ENCODING_ROTATE_90,
- CAMERA_ENCODING_ROTATE_180,
- CAMERA_ENCODING_ROTATE_270
-} camera_encoding_rotate_t;
-
-typedef enum {
- MOTION_ISO_OFF,
- MOTION_ISO_ON
-} motion_iso_t;
-
-typedef struct {
- struct msm_ctrl_cmd ctrlCmd;
- int fd;
- void (*af_cb)(int8_t );
- int8_t is_camafctrl_thread_join;
- isp3a_af_mode_t af_mode;
-} cam_af_ctrl_t;
-
-/* Display */
-typedef struct {
- uint16_t user_input_display_width;
- uint16_t user_input_display_height;
-} USER_INPUT_DISPLAY_T;
-
-#if defined CAMERA_WB_AUTO
-#undef CAMERA_WB_AUTO
-#endif
-
-#if defined CAMERA_WB_CUSTOM
-#undef CAMERA_WB_CUSTOM
-#endif
-
-#if defined CAMERA_WB_INCANDESCENT
-#undef CAMERA_WB_INCANDESCENT
-#endif
-
-#if defined CAMERA_WB_FLUORESCENT
-#undef CAMERA_WB_FLUORESCENT
-#endif
-
-#if defined CAMERA_WB_DAYLIGHT
-#undef CAMERA_WB_DAYLIGHT
-#endif
-
-#if defined CAMERA_WB_CLOUDY_DAYLIGHT
-#undef CAMERA_WB_CLOUDY_DAYLIGHT
-#endif
-
-#if defined CAMERA_WB_TWILIGHT
-#undef CAMERA_WB_TWILIGHT
-#endif
-
-#if defined CAMERA_WB_SHADE
-#undef CAMERA_WB_SHADE
-#endif
-
-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_OFF,
- CAMERA_WB_MAX_PLUS_1
-} config3a_wb_t;
-
-/* EXIF header */
-
-/* =======================================================================
-** Macro Definitions
-** ======================================================================= */
-/* Enum defined to let compiler generate unique offset numbers for different
- * tags - ordering matters! NOT INTENDED to be used by any application. */
-typedef enum
-{
- // GPS IFD
- GPS_VERSION_ID = 0,
- GPS_LATITUDE_REF,
- GPS_LATITUDE,
- GPS_LONGITUDE_REF,
- GPS_LONGITUDE,
- GPS_ALTITUDE_REF,
- GPS_ALTITUDE,
- GPS_TIMESTAMP,
- GPS_SATELLITES,
- GPS_STATUS,
- GPS_MEASUREMODE,
- GPS_DOP,
- GPS_SPEED_REF,
- GPS_SPEED,
- GPS_TRACK_REF,
- GPS_TRACK,
- GPS_IMGDIRECTION_REF,
- GPS_IMGDIRECTION,
- GPS_MAPDATUM,
- GPS_DESTLATITUDE_REF,
- GPS_DESTLATITUDE,
- GPS_DESTLONGITUDE_REF,
- GPS_DESTLONGITUDE,
- GPS_DESTBEARING_REF,
- GPS_DESTBEARING,
- GPS_DESTDISTANCE_REF,
- GPS_DESTDISTANCE,
- GPS_PROCESSINGMETHOD,
- GPS_AREAINFORMATION,
- GPS_DATESTAMP,
- GPS_DIFFERENTIAL,
-
- // TIFF IFD
- NEW_SUBFILE_TYPE,
- SUBFILE_TYPE,
- IMAGE_WIDTH,
- IMAGE_LENGTH,
- BITS_PER_SAMPLE,
- COMPRESSION,
- PHOTOMETRIC_INTERPRETATION,
- THRESH_HOLDING,
- CELL_WIDTH,
- CELL_HEIGHT,
- FILL_ORDER,
- DOCUMENT_NAME,
- IMAGE_DESCRIPTION,
- MAKE,
- MODEL,
- STRIP_OFFSETS,
- ORIENTATION,
- SAMPLES_PER_PIXEL,
- ROWS_PER_STRIP,
- STRIP_BYTE_COUNTS,
- MIN_SAMPLE_VALUE,
- MAX_SAMPLE_VALUE,
- X_RESOLUTION,
- Y_RESOLUTION,
- PLANAR_CONFIGURATION,
- PAGE_NAME,
- X_POSITION,
- Y_POSITION,
- FREE_OFFSET,
- FREE_BYTE_COUNTS,
- GRAY_RESPONSE_UNIT,
- GRAY_RESPONSE_CURVE,
- T4_OPTION,
- T6_OPTION,
- RESOLUTION_UNIT,
- PAGE_NUMBER,
- TRANSFER_FUNCTION,
- SOFTWARE,
- DATE_TIME,
- ARTIST,
- HOST_COMPUTER,
- PREDICTOR,
- WHITE_POINT,
- PRIMARY_CHROMATICITIES,
- COLOR_MAP,
- HALFTONE_HINTS,
- TILE_WIDTH,
- TILE_LENGTH,
- TILE_OFFSET,
- TILE_BYTE_COUNTS,
- INK_SET,
- INK_NAMES,
- NUMBER_OF_INKS,
- DOT_RANGE,
- TARGET_PRINTER,
- EXTRA_SAMPLES,
- SAMPLE_FORMAT,
- TRANSFER_RANGE,
- JPEG_PROC,
- JPEG_INTERCHANGE_FORMAT,
- JPEG_INTERCHANGE_FORMAT_LENGTH,
- JPEG_RESTART_INTERVAL,
- JPEG_LOSSLESS_PREDICTORS,
- JPEG_POINT_TRANSFORMS,
- JPEG_Q_TABLES,
- JPEG_DC_TABLES,
- JPEG_AC_TABLES,
- YCBCR_COEFFICIENTS,
- YCBCR_SUB_SAMPLING,
- YCBCR_POSITIONING,
- REFERENCE_BLACK_WHITE,
- GAMMA,
- ICC_PROFILE_DESCRIPTOR,
- SRGB_RENDERING_INTENT,
- IMAGE_TITLE,
- COPYRIGHT,
- EXIF_IFD,
- ICC_PROFILE,
- GPS_IFD,
-
-
- // TIFF IFD (Thumbnail)
- TN_IMAGE_WIDTH,
- TN_IMAGE_LENGTH,
- TN_BITS_PER_SAMPLE,
- TN_COMPRESSION,
- TN_PHOTOMETRIC_INTERPRETATION,
- TN_IMAGE_DESCRIPTION,
- TN_MAKE,
- TN_MODEL,
- TN_STRIP_OFFSETS,
- TN_ORIENTATION,
- TN_SAMPLES_PER_PIXEL,
- TN_ROWS_PER_STRIP,
- TN_STRIP_BYTE_COUNTS,
- TN_X_RESOLUTION,
- TN_Y_RESOLUTION,
- TN_PLANAR_CONFIGURATION,
- TN_RESOLUTION_UNIT,
- TN_TRANSFER_FUNCTION,
- TN_SOFTWARE,
- TN_DATE_TIME,
- TN_ARTIST,
- TN_WHITE_POINT,
- TN_PRIMARY_CHROMATICITIES,
- TN_JPEGINTERCHANGE_FORMAT,
- TN_JPEGINTERCHANGE_FORMAT_L,
- TN_YCBCR_COEFFICIENTS,
- TN_YCBCR_SUB_SAMPLING,
- TN_YCBCR_POSITIONING,
- TN_REFERENCE_BLACK_WHITE,
- TN_COPYRIGHT,
-
- // EXIF IFD
- EXPOSURE_TIME,
- F_NUMBER,
- EXPOSURE_PROGRAM,
- SPECTRAL_SENSITIVITY,
- ISO_SPEED_RATING,
- OECF,
- EXIF_VERSION,
- EXIF_DATE_TIME_ORIGINAL,
- EXIF_DATE_TIME_DIGITIZED,
- EXIF_COMPONENTS_CONFIG,
- EXIF_COMPRESSED_BITS_PER_PIXEL,
- SHUTTER_SPEED,
- APERTURE,
- BRIGHTNESS,
- EXPOSURE_BIAS_VALUE,
- MAX_APERTURE,
- SUBJECT_DISTANCE,
- METERING_MODE,
- LIGHT_SOURCE,
- FLASH,
- FOCAL_LENGTH,
- SUBJECT_AREA,
- EXIF_MAKER_NOTE,
- EXIF_USER_COMMENT,
- SUBSEC_TIME,
- SUBSEC_TIME_ORIGINAL,
- SUBSEC_TIME_DIGITIZED,
- EXIF_FLASHPIX_VERSION,
- EXIF_COLOR_SPACE,
- EXIF_PIXEL_X_DIMENSION,
- EXIF_PIXEL_Y_DIMENSION,
- RELATED_SOUND_FILE,
- INTEROP,
- FLASH_ENERGY,
- SPATIAL_FREQ_RESPONSE,
- FOCAL_PLANE_X_RESOLUTION,
- FOCAL_PLANE_Y_RESOLUTION,
- FOCAL_PLANE_RESOLUTION_UNIT,
- SUBJECT_LOCATION,
- EXPOSURE_INDEX,
- SENSING_METHOD,
- FILE_SOURCE,
- SCENE_TYPE,
- CFA_PATTERN,
- CUSTOM_RENDERED,
- EXPOSURE_MODE,
- WHITE_BALANCE,
- DIGITAL_ZOOM_RATIO,
- FOCAL_LENGTH_35MM,
- SCENE_CAPTURE_TYPE,
- GAIN_CONTROL,
- CONTRAST,
- SATURATION,
- SHARPNESS,
- DEVICE_SETTINGS_DESCRIPTION,
- SUBJECT_DISTANCE_RANGE,
- IMAGE_UID,
- PIM,
-
- EXIF_TAG_MAX_OFFSET
-
-} exif_tag_offset_t;
-
-/* Below are the supported Tags (ID and structure for their data) */
-#define CONSTRUCT_TAGID(offset,ID) (offset << 16 | ID)
-
-// GPS tag version
-// Use EXIFTAGTYPE_GPS_VERSION_ID as the exif_tag_type (EXIF_BYTE)
-// Count should be 4
-#define _ID_GPS_VERSION_ID 0x0000
-#define EXIFTAGID_GPS_VERSION_ID CONSTRUCT_TAGID(GPS_VERSION_ID, _ID_GPS_VERSION_ID)
-#define EXIFTAGTYPE_GPS_VERSION_ID EXIF_BYTE
-// North or South Latitude
-// Use EXIFTAGTYPE_GPS_LATITUDE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-#define _ID_GPS_LATITUDE_REF 0x0001
-#define EXIFTAGID_GPS_LATITUDE_REF CONSTRUCT_TAGID(GPS_LATITUDE_REF, _ID_GPS_LATITUDE_REF)
-#define EXIFTAGTYPE_GPS_LATITUDE_REF EXIF_ASCII
-// Latitude
-// Use EXIFTAGTYPE_GPS_LATITUDE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_LATITUDE 0x0002
-#define EXIFTAGID_GPS_LATITUDE CONSTRUCT_TAGID(GPS_LATITUDE, _ID_GPS_LATITUDE)
-#define EXIFTAGTYPE_GPS_LATITUDE EXIF_RATIONAL
-// East or West Longitude
-// Use EXIFTAGTYPE_GPS_LONGITUDE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-#define _ID_GPS_LONGITUDE_REF 0x0003
-#define EXIFTAGID_GPS_LONGITUDE_REF CONSTRUCT_TAGID(GPS_LONGITUDE_REF, _ID_GPS_LONGITUDE_REF)
-#define EXIFTAGTYPE_GPS_LONGITUDE_REF EXIF_ASCII
-// Longitude
-// Use EXIFTAGTYPE_GPS_LONGITUDE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_LONGITUDE 0x0004
-#define EXIFTAGID_GPS_LONGITUDE CONSTRUCT_TAGID(GPS_LONGITUDE, _ID_GPS_LONGITUDE)
-#define EXIFTAGTYPE_GPS_LONGITUDE EXIF_RATIONAL
-// Altitude reference
-// Use EXIFTAGTYPE_GPS_ALTITUDE_REF as the exif_tag_type (EXIF_BYTE)
-#define _ID_GPS_ALTITUDE_REF 0x0005
-#define EXIFTAGID_GPS_ALTITUDE_REF CONSTRUCT_TAGID(GPS_ALTITUDE_REF, _ID_GPS_ALTITUDE_REF)
-#define EXIFTAGTYPE_GPS_ALTITUDE_REF EXIF_BYTE
-// Altitude
-// Use EXIFTAGTYPE_GPS_ALTITUDE as the exif_tag_type (EXIF_RATIONAL)
-#define _ID_GPS_ALTITUDE 0x0006
-#define EXIFTAGID_GPS_ALTITUDE CONSTRUCT_TAGID(GPS_ALTITUDE, _ID_GPS_ALTITUDE)
-#define EXIFTAGTYPE_GPS_ALTITUE EXIF_RATIONAL
-// GPS time (atomic clock)
-// Use EXIFTAGTYPE_GPS_TIMESTAMP as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_TIMESTAMP 0x0007
-#define EXIFTAGID_GPS_TIMESTAMP CONSTRUCT_TAGID(GPS_TIMESTAMP, _ID_GPS_TIMESTAMP)
-#define EXIFTAGTYPE_GPS_TIMESTAMP EXIF_RATIONAL
-// GPS Satellites
-// Use EXIFTAGTYPE_GPS_SATELLITES as the exif_tag_type (EXIF_ASCII)
-// Count can be anything.
-#define _ID_GPS_SATELLITES 0x0008
-#define EXIFTAGID_GPS_SATELLITES CONSTRUCT_TAGID(GPS_SATELLITES, _ID_GPS_SATELLITES)
-#define EXIFTAGTYPE_GPS_SATELLITES EXIF_ASCII
-// GPS Status
-// Use EXIFTAGTYPE_GPS_STATUS as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "A" - Measurement in progress
-// "V" - Measurement Interoperability
-// Other - Reserved
-#define _ID_GPS_STATUS 0x0009
-#define EXIFTAGID_GPS_STATUS CONSTRUCT_TAGID(GPS_STATUS, _ID_GPS_STATUS)
-#define EXIFTATTYPE_GPS_STATUS EXIF_ASCII
-// GPS Measure Mode
-// Use EXIFTAGTYPE_GPS_MEASUREMODE as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "2" - 2-dimensional measurement
-// "3" - 3-dimensional measurement
-// Other - Reserved
-#define _ID_GPS_MEASUREMODE 0x000a
-#define EXIFTAGID_GPS_MEASUREMODE CONSTRUCT_TAGID(GPS_MEASUREMODE, _ID_GPS_MEASUREMODE)
-#define EXIFTAGTYPE_GPS_MEASUREMODE EXIF_ASCII
-// GPS Measurement precision (DOP)
-// Use EXIFTAGTYPE_GPS_DOP as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_DOP 0x000b
-#define EXIFTAGID_GPS_DOP CONSTRUCT_TAGID(GPS_DOP, _ID_GPS_DOP)
-#define EXIFTAGTYPE_GPS_DOP EXIF_RATIONAL
-// Speed Unit
-// Use EXIFTAGTYPE_GPS_SPEED_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "K" - Kilometers per hour
-// "M" - Miles per hour
-// "N" - Knots
-// Other - Reserved
-#define _ID_GPS_SPEED_REF 0x000c
-#define EXIFTAGID_GPS_SPEED_REF CONSTRUCT_TAGID(GPS_SPEED_REF, _ID_GPS_SPEED_REF)
-#define EXIFTAGTYPE_GPS_SPEED_REF EXIF_ASCII
-// Speed of GPS receiver
-// Use EXIFTAGTYPE_GPS_SPEED as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_SPEED 0x000d
-#define EXIFTAGID_GPS_SPEED CONSTRUCT_TAGID(GPS_SPEED, _ID_GPS_SPEED)
-#define EXIFTAGTYPE_GPS_SPEED EXIF_RATIONAL
-// Reference of direction of movement
-// Use EXIFTAGTYPE_GPS_TRACK_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "T" - True direction
-// "M" - Magnetic direction
-// Other - Reserved
-#define _ID_GPS_TRACK_REF 0x000e
-#define EXIFTAGID_GPS_TRACK_REF CONSTRUCT_TAGID(GPS_TRACK_REF, _ID_GPS_TRACK_REF)
-#define EXIFTAGTYPE_GPS_TRACK_REF EXIF_ASCII
-// Direction of movement
-// Use EXIFTAGTYPE_GPS_TRACK as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_TRACK 0x000f
-#define EXIFTAGID_GPS_TRACK CONSTRUCT_TAGID(GPS_TRACK, _ID_GPS_TRACK)
-#define EXIFTAGTYPE_GPS_TRACK EXIF_RATIONAL
-// Reference of direction of image
-// Use EXIFTAGTYPE_GPS_IMGDIRECTION_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "T" - True direction
-// "M" - Magnetic direction
-// Other - Reserved
-#define _ID_GPS_IMGDIRECTION_REF 0x0010
-#define EXIFTAGID_GPS_IMGDIRECTION_REF CONSTRUCT_TAGID(GPS_IMGDIRECTION_REF, _ID_GPS_IMGDIRECTION_REF)
-#define EXIFTAGTYPE_GPS_IMGDIRECTION_REF EXIF_ASCII
-// Direction of image
-// Use EXIFTAGTYPE_GPS_IMGDIRECTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_IMGDIRECTION 0x0011
-#define EXIFTAGID_GPS_IMGDIRECTION CONSTRUCT_TAGID(GPS_IMGDIRECTION, _ID_GPS_IMGDIRECTION)
-#define EXIFTAGTYPE_GPS_IMGDIRECTION EXIF_RATIONAL
-// Geodetic survey data used
-// Use EXIFTAGTYPE_GPS_MAPDATUM as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_GPS_MAPDATUM 0x0012
-#define EXIFTAGID_GPS_MAPDATUM CONSTRUCT_TAGID(GPS_MAPDATUM, _ID_GPS_MAPDATUM)
-#define EXIFTAGTYPE_GPS_MAPDATUM EXIF_ASCII
-// Reference for latitude of destination
-// Use EXIFTAGTYPE_GPS_DESTLATITUDE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "N" - North latitude
-// "S" - South latitude
-// Other - Reserved
-#define _ID_GPS_DESTLATITUDE_REF 0x0013
-#define EXIFTAGID_GPS_DESTLATITUDE_REF CONSTRUCT_TAGID(GPS_DESTLATITUDE_REF, _ID_GPS_DESTLATITUDE_REF)
-#define EXIFTAGTYPE_GPS_DESTLATITUDE_REF EXIF_ASCII
-// Latitude of destination
-// Use EXIFTAGTYPE_GPS_DESTLATITUDE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_DESTLATITUDE 0x0014
-#define EXIFTAGID_GPS_DESTLATITUDE CONSTRUCT_TAGID(GPS_DESTLATITUDE, _ID_GPS_DESTLATITUDE)
-#define EXIFTAGTYPE_GPS_DESTLATITUDE EXIF_RATIONAL
-// Reference for longitude of destination
-// Use EXIFTAGTYPE_GPS_DESTLONGITUDE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "E" - East longitude
-// "W" - West longitude
-// Other - Reserved
-#define _ID_GPS_DESTLONGITUDE_REF 0x0015
-#define EXIFTAGID_GPS_DESTLONGITUDE_REF CONSTRUCT_TAGID(GPS_DESTLONGITUDE_REF, _ID_GPS_DESTLONGITUDE_REF)
-#define EXIFTAGTYPE_GPS_DESTLONGITUDE_REF EXIF_ASCII
-// Longitude of destination
-// Use EXIFTAGTYPE_GPS_DESTLONGITUDE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_GPS_DESTLONGITUDE 0x0016
-#define EXIFTAGID_GPS_DESTLONGITUDE CONSTRUCT_TAGID(GPS_DESTLONGITUDE, _ID_GPS_DESTLONGITUDE)
-#define EXIFTAGTYPE_GPS_DESTLONGITUDE EXIF_RATIONAL
-// Reference for bearing of destination
-// Use EXIFTAGTYPE_GPS_DESTBEARING_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "T" - True direction
-// "M" - Magnetic direction
-// Other - Reserved
-#define _ID_GPS_DESTBEARING_REF 0x0017
-#define EXIFTAGID_GPS_DESTBEARING_REF CONSTRUCT_TAGID(GPS_DESTBEARING_REF, _ID_GPS_DESTBEARING_REF)
-#define EXIFTAGTYPE_GPS_DESTBEARING_REF EXIF_ASCII
-// Bearing of destination
-// Use EXIFTAGTYPE_GPS_DESTBEARING as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_DESTBEARING 0x0018
-#define EXIFTAGID_GPS_DESTBEARING CONSTRUCT_TAGID(GPS_DESTBEARING, _ID_GPS_DESTBEARING)
-#define EXIFTAGTYPE_GPS_DESTBEARING EXIF_RATIONAL
-// Reference for distance to destination
-// Use EXIFTAGTYPE_GPS_DESTDISTANCE_REF as the exif_tag_type (EXIF_ASCII)
-// It should be 2 characters long including the null-terminating character.
-// "K" - Kilometers per hour
-// "M" - Miles per hour
-// "N" - Knots
-// Other - Reserved
-#define _ID_GPS_DESTDISTANCE_REF 0x0019
-#define EXIFTAGID_GPS_DESTDISTANCE_REF CONSTRUCT_TAGID(GPS_DESTDISTANCE_REF, _ID_GPS_DESTDISTANCE_REF)
-#define EXIFTAGTYPE_GPS_DESTDISTANCE_REF EXIF_ASCII
-// Distance to destination
-// Use EXIFTAGTYPE_GPS_DESTDISTANCE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_GPS_DESTDISTANCE 0x001a
-#define EXIFTAGID_GPS_DESTDISTANCE CONSTRUCT_TAGID(GPS_DESTDISTANCE, _ID_GPS_DESTDISTANCE)
-#define EXIFTAGTYPE_GPS_DESTDISTANCE EXIF_RATIONAL
-// Name of GPS processing method
-// Use EXIFTAGTYPE_GPS_PROCESSINGMETHOD as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_GPS_PROCESSINGMETHOD 0x001b
-#define EXIFTAGID_GPS_PROCESSINGMETHOD CONSTRUCT_TAGID(GPS_PROCESSINGMETHOD, _ID_GPS_PROCESSINGMETHOD)
-#define EXIFTAGTYPE_GPS_PROCESSINGMETHOD EXIF_UNDEFINED
-// Name of GPS area
-// Use EXIFTAGTYPE_GPS_AREAINFORMATION as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_GPS_AREAINFORMATION 0x001c
-#define EXIFTAGID_GPS_AREAINFORMATION CONSTRUCT_TAGID(GPS_AREAINFORMATION, _ID_GPS_AREAINFORMATION)
-#define EXIFTAGTYPE_GPS_AREAINFORMATION EXIF_UNDEFINED
-// GPS date
-// Use EXIFTAGTYPE_GPS_DATESTAMP as the exif_tag_type (EXIF_ASCII)
-// It should be 11 characters long including the null-terminating character.
-#define _ID_GPS_DATESTAMP 0x001d
-#define EXIFTAGID_GPS_DATESTAMP CONSTRUCT_TAGID(GPS_DATESTAMP, _ID_GPS_DATESTAMP)
-#define EXIFTAGTYPE_GPS_DATESTAMP EXIF_ASCII
-// GPS differential correction
-// Use EXIFTAGTYPE_GPS_DIFFERENTIAL as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-// 0 - Measurement without differential correction
-// 1 - Differential correction applied
-// Other - Reserved
-#define _ID_GPS_DIFFERENTIAL 0x001e
-#define EXIFTAGID_GPS_DIFFERENTIAL CONSTRUCT_TAGID(GPS_DIFFERENTIAL, _ID_GPS_DIFFERENTIAL)
-#define EXIFTAGTYPE_GPS_DIFFERENTIAL EXIF_SHORT
-// Image width
-// Use EXIFTAGTYPE_IMAGE_WIDTH as the exif_tag_type (EXIF_LONG)
-// Count should be 1
-#define _ID_IMAGE_WIDTH 0x0100
-#define EXIFTAGID_IMAGE_WIDTH CONSTRUCT_TAGID(IMAGE_WIDTH, _ID_IMAGE_WIDTH)
-#define EXIFTAGTYPE_IMAGE_WIDTH EXIF_LONG
-// Image height
-// Use EXIFTAGTYPE_IMAGE_LENGTH as the exif_tag_type (EXIF_SHORT_OR_LONG)
-// Count should be 1
-#define _ID_IMAGE_LENGTH 0x0101
-#define EXIFTAGID_IMAGE_LENGTH CONSTRUCT_TAGID(IMAGE_LENGTH, _ID_IMAGE_LENGTH)
-#define EXIFTAGTYPE_IMAGE_LENGTH EXIF_LONG
-// Number of bits per component
-// Use EXIFTAGTYPE_BITS_PER_SAMPLE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_BITS_PER_SAMPLE 0x0102
-#define EXIFTAGID_BITS_PER_SAMPLE CONSTRUCT_TAGID(BITS_PER_SAMPLE, _ID_BITS_PER_SAMPLE)
-#define EXIFTAGTYPE_BITS_PER_SAMPLE EXIF_SHORT
-// Compression scheme
-// Use EXIFTAGTYPE_COMPRESSION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_COMPRESSION 0x0103
-#define EXIFTAGID_COMPRESSION CONSTRUCT_TAGID(COMPRESSION, _ID_COMPRESSION)
-#define EXIFTAGTYPE_COMPRESSION EXIF_SHORT
-// Pixel composition
-// Use EXIFTAGTYPE_PHOTOMETRIC_INTERPRETATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_PHOTOMETRIC_INTERPRETATION 0x0106
-#define EXIFTAGID_PHOTOMETRIC_INTERPRETATION CONSTRUCT_TAGID(PHOTOMETRIC_INTERPRETATION, _ID_PHOTOMETRIC_INTERPRETATION)
-#define EXIFTAGTYPE_PHOTOMETRIC_INTERPRETATION EXIF_SHORT
-
-// Thresholding
-// Use EXIFTAGTYPE_THRESH_HOLDING as the exif_tag_type (EXIF_SHORT)
-//
-//1 = No dithering or halftoning
-//2 = Ordered dither or halftone
-//3 = Randomized dither
-#define _ID_THRESH_HOLDING 0x0107
-#define EXIFTAGID_THRESH_HOLDING CONSTRUCT_TAGID(THRESH_HOLDING, _ID_THRESH_HOLDING)
-#define EXIFTAGTYPE_THRESH_HOLDING EXIF_SHORT
-
-// Cell Width
-// Use EXIFTAGTYPE_CELL_WIDTH as the exif_tag_type (EXIF_SHORT)
-//
-#define _ID_CELL_WIDTH 0x0108
-#define EXIFTAGID_CELL_WIDTH CONSTRUCT_TAGID(CELL_WIDTH, _ID_CELL_WIDTH)
-#define EXIFTAGTYPE_CELL_WIDTH EXIF_SHORT
-// Cell Height
-// Use EXIFTAGTYPE_CELL_HEIGHT as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_CELL_HEIGHT 0x0109
-#define EXIFTAGID_CELL_HEIGHT CONSTRUCT_TAGID(CELL_HEIGHT, _ID_CELL_HEIGHT)
-#define EXIFTAGTYPE_CELL_HEIGHT EXIF_SHORT
-// Fill Order
-// Use EXIFTAGTYPE_FILL_ORDER as the exif_tag_type (EXIF_SHORT)
-// 1 = Normal
-// 2 = Reversed
-#define _ID_FILL_ORDER 0x010A
-#define EXIFTAGID_FILL_ORDER CONSTRUCT_TAGID(FILL_ORDER, _ID_FILL_ORDER)
-#define EXIFTAGTYPE_FILL_ORDER EXIF_SHORT
-
-// DOCUMENT NAME
-// Use EXIFTAGTYPE_DOCUMENT_NAME as the exif_tag_type (EXIF_ASCII)
-//
-#define _ID_DOCUMENT_NAME 0x010D
-#define EXIFTAGID_DOCUMENT_NAME CONSTRUCT_TAGID(DOCUMENT_NAME, _ID_DOCUMENT_NAME)
-#define EXIFTAGTYPE_DOCUMENT_NAME EXIF_ASCII
-
-// Image title
-// Use EXIFTAGTYPE_IMAGE_DESCRIPTION as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_IMAGE_DESCRIPTION 0x010e
-#define EXIFTAGID_IMAGE_DESCRIPTION CONSTRUCT_TAGID(IMAGE_DESCRIPTION, _ID_IMAGE_DESCRIPTION)
-#define EXIFTAGTYPE_IMAGE_DESCRIPTION EXIF_ASCII
-// Image input equipment manufacturer
-// Use EXIFTAGTYPE_MAKE as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_MAKE 0x010f
-#define EXIFTAGID_MAKE CONSTRUCT_TAGID(MAKE, _ID_MAKE)
-#define EXIFTAGTYPE_MAKE EXIF_ASCII
-// Image input equipment model
-// Use EXIFTAGTYPE_MODEL as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_MODEL 0x0110
-#define EXIFTAGID_MODEL CONSTRUCT_TAGID(MODEL, _ID_MODEL)
-#define EXIFTAGTYPE_MODEL EXIF_ASCII
-// Image data location
-// Use EXIFTAGTYPE_STRIP_OFFSETS as the exif_tag_type (EXIF_LONG)
-// Count = StripsPerImage when PlanarConfiguration = 1
-// = SamplesPerPixel * StripsPerImage when PlanarConfiguration = 2
-#define _ID_STRIP_OFFSETS 0x0111
-#define EXIFTAGID_STRIP_OFFSETS CONSTRUCT_TAGID(STRIP_OFFSETS, _ID_STRIP_OFFSETS)
-#define EXIFTAGTYPE_STRIP_OFFSETS EXIF_LONG
-// Orientation of image
-// Use EXIFTAGTYPE_ORIENTATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_ORIENTATION 0x0112
-#define EXIFTAGID_ORIENTATION CONSTRUCT_TAGID(ORIENTATION, _ID_ORIENTATION)
-#define EXIFTAGTYPE_ORIENTATION EXIF_SHORT
-// Number of components
-// Use EXIFTAGTYPE_SAMPLES_PER_PIXEL as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SAMPLES_PER_PIXEL 0x0115
-#define EXIFTAGID_SAMPLES_PER_PIXEL CONSTRUCT_TAGID(SAMPLES_PER_PIXEL, _ID_SAMPLES_PER_PIXEL)
-#define EXIFTAGTYPE_SAMPLES_PER_PIXEL EXIF_SHORT
-// Number of rows per strip
-// Use EXIFTAGTYPE_ROWS_PER_STRIP as the exif_tag_type (EXIF_LONG)
-// Count should be 1
-#define _ID_ROWS_PER_STRIP 0x0116
-#define EXIFTAGID_ROWS_PER_STRIP CONSTRUCT_TAGID(ROWS_PER_STRIP, _ID_ROWS_PER_STRIP)
-#define EXIFTAGTYPE_ROWS_PER_STRIP EXIF_LONG
-// Bytes per compressed strip
-// Use EXIFTAGTYPE_STRIP_BYTE_COUNTS as the exif_tag_type (EXIF_LONG)
-// Count = StripsPerImage when PlanarConfiguration = 1
-// = SamplesPerPixel * StripsPerImage when PlanarConfiguration = 2
-#define _ID_STRIP_BYTE_COUNTS 0x0117
-#define EXIFTAGID_STRIP_BYTE_COUNTS CONSTRUCT_TAGID(STRIP_BYTE_COUNTS, _ID_STRIP_BYTE_COUNTS)
-#define EXIFTAGTYPE_STRIP_BYTE_COUNTS EXIF_LONG
-// MinSampleValue
-// Use EXIFTAGTYPE_MIN_SAMPLE_VALUE as the exif_tag_type (EXIF_SHORT)
-#define _ID_MIN_SAMPLE_VALUE 0x0118
-#define EXIFTAGID_MIN_SAMPLE_VALUE CONSTRUCT_TAGID(MIN_SAMPLE_VALUE, _ID_MIN_SAMPLE_VALUE)
-#define EXIFTAGTYPE_MIN_SAMPLE_VALUE EXIF_SHORT
-// MaxSampleValue
-// Use EXIFTAGTYPE_MAX_SAMPLE_VALUE as the exif_tag_type (EXIF_SHORT)
-#define _ID_MAX_SAMPLE_VALUE 0x0119
-#define EXIFTAGID_MAX_SAMPLE_VALUE CONSTRUCT_TAGID(MAX_SAMPLE_VALUE, _ID_MAX_SAMPLE_VALUE)
-#define EXIFTAGTYPE_MAX_SAMPLE_VALUE EXIF_SHORT
-
-// Image resolution in width direction
-// Use EXIFTAGTYPE_X_RESOLUTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_X_RESOLUTION 0x011a
-#define EXIFTAGID_X_RESOLUTION CONSTRUCT_TAGID(X_RESOLUTION, _ID_X_RESOLUTION)
-#define EXIFTAGTYPE_X_RESOLUTION EXIF_RATIONAL
-// Image resolution in height direction
-// Use EXIFTAGTYPE_Y_RESOLUTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_Y_RESOLUTION 0x011b
-#define EXIFTAGID_Y_RESOLUTION CONSTRUCT_TAGID(Y_RESOLUTION, _ID_Y_RESOLUTION)
-#define EXIFTAGTYPE_Y_RESOLUTION EXIF_RATIONAL
-// Image data arrangement
-// Use EXIFTAGTYPE_PLANAR_CONFIGURATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_PLANAR_CONFIGURATION 0x011c
-#define EXIFTAGID_PLANAR_CONFIGURATION CONSTRUCT_TAGID(PLANAR_CONFIGURATION, _ID_PLANAR_CONFIGURATION)
-#define EXIFTAGTYPE_PLANAR_CONFIGURATION EXIF_SHORT
-// PageName
-// Use EXIFTAGTYPE_PAGE_NAME as the exif_tag_type (EXIF_ASCII)
-// Count should be 1
-#define _ID_PAGE_NAME 0x011d
-#define EXIFTAGID_PAGE_NAME CONSTRUCT_TAGID(PAGE_NAME, _ID_PAGE_NAME)
-#define EXIFTAGTYPE_PAGE_NAME EXIF_ASCII
-// XPosition
-// Use EXIFTAGTYPE_X_POSITION as the exif_tag_type (EXIF_RATIONAL)
-//
-#define _ID_X_POSITION 0x011e
-#define EXIFTAGID_X_POSITION CONSTRUCT_TAGID(X_POSITION, _ID_X_POSITION)
-#define EXIFTAGTYPE_X_POSITION EXIF_RATIONAL
-// YPosition
-// Use EXIFTAGTYPE_Y_POSITION as the exif_tag_type (EXIF_RATIONAL)
-//
-#define _ID_Y_POSITION 0x011f
-#define EXIFTAGID_Y_POSITION CONSTRUCT_TAGID(Y_POSITION, _ID_Y_POSITION)
-#define EXIFTAGTYPE_Y_POSITION EXIF_RATIONAL
-
-// FREE_OFFSET
-// Use EXIFTAGTYPE_FREE_OFFSET as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_FREE_OFFSET 0x0120
-#define EXIFTAGID_FREE_OFFSET CONSTRUCT_TAGID(FREE_OFFSET, _ID_FREE_OFFSET)
-#define EXIFTAGTYPE_FREE_OFFSET EXIF_LONG
-// FREE_BYTE_COUNTS
-// Use EXIFTAGTYPE_FREE_BYTE_COUNTS as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_FREE_BYTE_COUNTS 0x0121
-#define EXIFTAGID_FREE_BYTE_COUNTS CONSTRUCT_TAGID(FREE_BYTE_COUNTS, _ID_FREE_BYTE_COUNTS)
-#define EXIFTAGTYPE_FREE_BYTE_COUNTS EXIF_LONG
-
-// GrayResponseUnit
-// Use EXIFTAGTYPE_GRAY_RESPONSE_UNIT as the exif_tag_type (EXIF_SHORT)
-//
-#define _ID_GRAY_RESPONSE_UNIT 0x0122
-#define EXIFTAGID_GRAY_RESPONSE_UNIT CONSTRUCT_TAGID(GRAY_RESPONSE_UNIT, _ID_GRAY_RESPONSE_UNIT)
-#define EXIFTAGTYPE_GRAY_RESPONSE_UNIT EXIF_SHORT
-// GrayResponseCurve
-// Use EXIFTAGTYPE_GRAY_RESPONSE_CURVE as the exif_tag_type (EXIF_SHORT)
-//
-#define _ID_GRAY_RESPONSE_CURVE 0x0123
-#define EXIFTAGID_GRAY_RESPONSE_CURVE CONSTRUCT_TAGID(GRAY_RESPONSE_CURVE , _ID_GRAY_RESPONSE_CURVE )
-#define EXIFTAGTYPE_GRAY_RESPONSE_CURVE EXIF_SHORT
-
-// T4_OPTION
-// Use EXIFTAGTYPE_T4_OPTION as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_T4_OPTION 0x0124
-#define EXIFTAGID_T4_OPTION CONSTRUCT_TAGID(T4_OPTION, _ID_T4_OPTION)
-#define EXIFTAGTYPE_T4_OPTION EXIF_LONG
-// T6_OPTION
-// Use EXIFTAGTYPE_T6_OPTION as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_T6_OPTION 0x0125
-#define EXIFTAGID_T6_OPTION CONSTRUCT_TAGID(T6_OPTION, _ID_T6_OPTION)
-#define EXIFTAGTYPE_T6_OPTION EXIF_LONG
-
-// Unit of X and Y resolution
-// Use EXIFTAGTYPE_RESOLUTION_UNIT as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_RESOLUTION_UNIT 0x0128
-#define EXIFTAGID_RESOLUTION_UNIT CONSTRUCT_TAGID(RESOLUTION_UNIT, _ID_RESOLUTION_UNIT)
-#define EXIFTAGTYPE_RESOLUTION_UNIT EXIF_SHORT
-
-// Page Number
-// Use EXIFTAGTYPE_PAGE_NUMBER as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_PAGE_NUMBER 0x0129
-#define EXIFTAGID_PAGE_NUMBER CONSTRUCT_TAGID(PAGE_NUMBER, _ID_PAGE_NUMBER)
-#define EXIFTAGTYPE_PAGE_NUMBER EXIF_SHORT
-// Transfer function
-// Use EXIFTAGTYPE_TRANSFER_FUNCTION as the exif_tag_type (EXIF_SHORT)
-// Count should be 3*256
-#define _ID_TRANSFER_FUNCTION 0x012d
-#define EXIFTAGID_TRANSFER_FUNCTION CONSTRUCT_TAGID(TRANSFER_FUNCTION, _ID_TRANSFER_FUNCTION)
-#define EXIFTAGTYPE_TRANSFER_FUNCTION EXIF_SHORT
-// Software used
-// Use EXIFTAGTYPE_SOFTWARE as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_SOFTWARE 0x0131
-#define EXIFTAGID_SOFTWARE CONSTRUCT_TAGID(SOFTWARE, _ID_SOFTWARE)
-#define EXIFTAGTYPE_SOFTWARE EXIF_ASCII
-// File change date and time
-// Use EXIFTAGTYPE_DATE_TIME as the exif_tag_type (EXIF_ASCII)
-// Count should be 20
-#define _ID_DATE_TIME 0x0132
-#define EXIFTAGID_DATE_TIME CONSTRUCT_TAGID(DATE_TIME, _ID_DATE_TIME)
-#define EXIFTAGTYPE_DATE_TIME EXIF_ASCII
-// ARTIST, person who created this image
-// Use EXIFTAGTYPE_ARTIST as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_ARTIST 0x013b
-#define EXIFTAGID_ARTIST CONSTRUCT_TAGID(ARTIST, _ID_ARTIST)
-#define EXIFTAGTYPE_ARTIST EXIF_ASCII
-// Host Computer Name
-// Use EXIFTAGTYPE_HOST_COMPUTER as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_HOST_COMPUTER 0x013c
-#define EXIFTAGID_HOST_COMPUTER CONSTRUCT_TAGID(HOST_COMPUTER , _ID_HOST_COMPUTER )
-#define EXIFTAGTYPE_HOST_COMPUTER EXIF_ASCII
-// Predictor
-// Use EXIFTAGTYPE_PREDICTOR as the exif_tag_type (EXIF_SHORT)
-// Count can be any
-#define _ID_PREDICTOR 0x013d
-#define EXIFTAGID_PREDICTOR CONSTRUCT_TAGID(PREDICTOR , _ID_PREDICTOR )
-#define EXIFTAGTYPE_PREDICTOR EXIF_SHORT
-// White point chromaticity
-// Use EXIFTAGTYPE_WHITE_POINT as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 2
-#define _ID_WHITE_POINT 0x013e
-#define EXIFTAGID_WHITE_POINT CONSTRUCT_TAGID(WHITE_POINT, _ID_WHITE_POINT)
-#define EXIFTAGTYPE_WHITE_POINT EXIF_RATIONAL
-// Chromaticities of primaries
-// Use EXIFTAGTYPE_PRIMARY_CHROMATICITIES as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_PRIMARY_CHROMATICITIES 0x013f
-#define EXIFTAGID_PRIMARY_CHROMATICITIES CONSTRUCT_TAGID(PRIMARY_CHROMATICITIES, _ID_PRIMARY_CHROMATICITIES)
-#define EXIFTAGTYPE_PRIMARY_CHROMATICITIES EXIF_RATIONAL
-
-// COLOR_MAP
-// Use EXIFTAGTYPE_COLOR_MAP as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_COLOR_MAP 0x0140
-#define EXIFTAGID_COLOR_MAP CONSTRUCT_TAGID(COLOR_MAP, _ID_COLOR_MAP)
-#define EXIFTAGTYPE_COLOR_MAP EXIF_SHORT
-// HALFTONE_HINTS
-// Use EXIFTAGTYPE_HALFTONE_HINTS as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_HALFTONE_HINTS 0x0141
-#define EXIFTAGID_HALFTONE_HINTS CONSTRUCT_TAGID(HALFTONE_HINTS, _ID_HALFTONE_HINTS)
-#define EXIFTAGTYPE_HALFTONE_HINTS EXIF_SHORT
-
-// TILE_WIDTH
-// Use EXIFTAGTYPE_TILE_WIDTH as the exif_tag_type (EXIF_LONG)
-// Count should be 6
-#define _ID_TILE_WIDTH 0x0142
-#define EXIFTAGID_TILE_WIDTH CONSTRUCT_TAGID(TILE_WIDTH, _ID_TILE_WIDTH)
-#define EXIFTAGTYPE_TILE_WIDTH EXIF_LONG
-// TILE_LENGTH
-// Use EXIFTAGTYPE_TILE_LENGTH as the exif_tag_type (EXIF_LONG)
-// Count should be 6
-#define _ID_TILE_LENGTH 0x0143
-#define EXIFTAGID_TILE_LENGTH CONSTRUCT_TAGID(TILE_LENGTH , _ID_TILE_LENGTH )
-#define EXIFTAGTYPE_TILE_LENGTH EXIF_LONG
-// TILE_OFFSET
-// Use EXIFTAGTYPE_TILE_OFFSET as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_TILE_OFFSET 0x0144
-#define EXIFTAGID_TILE_OFFSET CONSTRUCT_TAGID(TILE_OFFSET , _ID_TILE_OFFSET )
-#define EXIFTAGTYPE_TILE_OFFSET EXIF_LONG
-// tile Byte Counts
-// Use EXIFTAGTYPE_TILE_OFFSET as the exif_tag_type (EXIF_LONG)
-//
-#define _ID_TILE_BYTE_COUNTS 0x0145
-#define EXIFTAGID_TILE_BYTE_COUNTS CONSTRUCT_TAGID(TILE_BYTE_COUNTS , _ID_TILE_BYTE_COUNTS )
-#define EXIFTAGTYPE_TILE_BYTE_COUNTS EXIF_LONG
-
-// INK_SET
-// Use EXIFTAGTYPE_TILE_LENGTH as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_INK_SET 0x014c
-#define EXIFTAGID_INK_SET CONSTRUCT_TAGID(INK_SET , _ID_INK_SET )
-#define EXIFTAGTYPE_INK_SET EXIF_SHORT
-// INK_NAMES
-// Use EXIFTAGTYPE_INK_NAMES as the exif_tag_type (EXIF_ASCII)
-// Count should be 6
-#define _ID_INK_NAMES 0x014D
-#define EXIFTAGID_INK_NAMES CONSTRUCT_TAGID(INK_NAMES , _ID_INK_NAMES)
-#define EXIFTAGTYPE_INK_NAMES EXIF_ASCII
-// NUMBER_OF_INKS
-// Use EXIFTAGTYPE_NUMBER_OF_INKS as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_NUMBER_OF_INKS 0x014e
-#define EXIFTAGID_NUMBER_OF_INKS CONSTRUCT_TAGID(NUMBER_OF_INKS , _ID_NUMBER_OF_INKS )
-#define EXIFTAGTYPE_NUMBER_OF_INKS EXIF_SHORT
-
-// DOT_RANGE
-// Use EXIFTAGTYPE_DOT_RANGE as the exif_tag_type (EXIF_ASCII)
-// Count should be 6
-#define _ID_DOT_RANGE 0x0150
-#define EXIFTAGID_DOT_RANGE CONSTRUCT_TAGID(DOT_RANGE , _ID_DOT_RANGE )
-#define EXIFTAGTYPE_DOT_RANGE EXIF_ASCII
-
-// TARGET_PRINTER
-// Use EXIFTAGTYPE_TARGET_PRINTER as the exif_tag_type (EXIF_ASCII)
-// Count should be 6
-#define _ID_TARGET_PRINTER 0x0151
-#define EXIFTAGID_TARGET_PRINTER CONSTRUCT_TAGID(TARGET_PRINTER , _ID_TARGET_PRINTER)
-#define EXIFTAGTYPE_TARGET_PRINTER EXIF_ASCII
-// EXTRA_SAMPLES
-// Use EXIFTAGTYPE_EXTRA_SAMPLES as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_EXTRA_SAMPLES 0x0152
-#define EXIFTAGID_EXTRA_SAMPLES CONSTRUCT_TAGID(EXTRA_SAMPLES , _ID_EXTRA_SAMPLES )
-#define EXIFTAGTYPE_EXTRA_SAMPLES EXIF_SHORT
-
-// SAMPLE_FORMAT
-// Use EXIFTAGTYPE_SAMPLE_FORMAT as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_SAMPLE_FORMAT 0x0153
-#define EXIFTAGID_SAMPLE_FORMAT CONSTRUCT_TAGID(SAMPLE_FORMAT , _ID_SAMPLE_FORMAT )
-#define EXIFTAGTYPE_SAMPLE_FORMAT EXIF_SHORT
-
-// Table of values that extends the range of the transfer function.
-// Use EXIFTAGTYPE_TRANSFER_RANGE as the exif_tag_type (EXIF_SHORT)
-// Count should be 6
-#define _ID_TRANSFER_RANGE 0x0156
-#define EXIFTAGID_TRANSFER_RANGE CONSTRUCT_TAGID(TRANSFER_RANGE , _ID_TRANSFER_RANGE )
-#define EXIFTAGTYPE_TRANSFER_RANGE EXIF_SHORT
-
-// JPEG compression process.
-// Use EXIFTAGTYPE_JPEG_PROC as the exif_tag_type (EXIF_SHORT)
-//
-#define _ID_JPEG_PROC 0x0200
-#define EXIFTAGID_JPEG_PROC CONSTRUCT_TAGID(JPEG_PROC , _ID_JPEG_PROC )
-#define EXIFTAGTYPE_JPEG_PROC EXIF_SHORT
-
-
-// Offset to JPEG SOI
-// Use EXIFTAGTYPE_JPEG_INTERCHANGE_FORMAT as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_INTERCHANGE_FORMAT 0x0201
-#define EXIFTAGID_JPEG_INTERCHANGE_FORMAT CONSTRUCT_TAGID(JPEG_INTERCHANGE_FORMAT, _ID_JPEG_INTERCHANGE_FORMAT)
-#define EXIFTAGTYPE_JPEG_INTERCHANGE_FORMAT EXIF_LONG
-// Bytes of JPEG data
-// Use EXIFTAGTYPE_JPEG_INTERCHANGE_FORMAT_LENGTH as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_INTERCHANGE_FORMAT_LENGTH 0x0202
-#define EXIFTAGID_JPEG_INTERCHANGE_FORMAT_LENGTH CONSTRUCT_TAGID(JPEG_INTERCHANGE_FORMAT_LENGTH, _ID_JPEG_INTERCHANGE_FORMAT_LENGTH)
-#define EXIFTAGTYPE_JPEG_INTERCHANGE_FORMAT_LENGTH EXIF_LONG
-
-// Length of the restart interval.
-// Use EXIFTAGTYPE_JPEG_RESTART_INTERVAL as the exif_tag_type (EXIF_SHORT)
-// Count is undefined
-#define _ID_JPEG_RESTART_INTERVAL 0x0203
-#define EXIFTAGID_JPEG_RESTART_INTERVAL CONSTRUCT_TAGID(JPEG_RESTART_INTERVAL, _ID_JPEG_RESTART_INTERVAL)
-#define EXIFTAGTYPE_JPEG_RESTART_INTERVAL EXIF_SHORT
-
-// JPEGLosslessPredictors
-// Use EXIFTAGTYPE_JPEG_LOSSLESS_PREDICTORS as the exif_tag_type (EXIF_SHORT)
-// Count is undefined
-#define _ID_JPEG_LOSSLESS_PREDICTORS 0x0205
-#define EXIFTAGID_JPEG_LOSSLESS_PREDICTORS CONSTRUCT_TAGID(JPEG_LOSSLESS_PREDICTORS, _ID_JPEG_LOSSLESS_PREDICTORS)
-#define EXIFTAGTYPE_JPEG_LOSSLESS_PREDICTORS EXIF_SHORT
-
-// JPEGPointTransforms
-// Use EXIFTAGTYPE_JPEG_POINT_TRANSFORMS as the exif_tag_type (EXIF_SHORT)
-// Count is undefined
-#define _ID_JPEG_POINT_TRANSFORMS 0x0206
-#define EXIFTAGID_JPEG_POINT_TRANSFORMS CONSTRUCT_TAGID(JPEG_POINT_TRANSFORMS, _ID_JPEG_POINT_TRANSFORMS)
-#define EXIFTAGTYPE_JPEG_POINT_TRANSFORMS EXIF_SHORT
-
-// JPEG_Q_TABLES
-// Use EXIFTAGTYPE_JPEG_Q_TABLES as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_Q_TABLES 0x0207
-#define EXIFTAGID_JPEG_Q_TABLES CONSTRUCT_TAGID(JPEG_Q_TABLES, _ID_JPEG_Q_TABLES)
-#define EXIFTAGTYPE_JPEG_Q_TABLES EXIF_LONG
-// JPEG_DC_TABLES
-// Use EXIFTAGTYPE_JPEG_DC_TABLES as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_DC_TABLES 0x0208
-#define EXIFTAGID_JPEG_DC_TABLES CONSTRUCT_TAGID(JPEG_DC_TABLES, _ID_JPEG_DC_TABLES)
-#define EXIFTAGTYPE_JPEG_DC_TABLES EXIF_LONG
-// JPEG_AC_TABLES
-// Use EXIFTAGTYPE_JPEG_AC_TABLES as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_JPEG_AC_TABLES 0x0209
-#define EXIFTAGID_JPEG_AC_TABLES CONSTRUCT_TAGID(JPEG_AC_TABLES, _ID_JPEG_AC_TABLES)
-#define EXIFTAGTYPE_JPEG_AC_TABLES EXIF_LONG
-
-// Color space transformation matrix coefficients
-// Use EXIFTAGTYPE_YCBCR_COEFFICIENTS as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_YCBCR_COEFFICIENTS 0x0211
-#define EXIFTAGID_YCBCR_COEFFICIENTS CONSTRUCT_TAGID(YCBCR_COEFFICIENTS, _ID_YCBCR_COEFFICIENTS)
-#define EXIFTAGTYPE_YCBCR_COEFFICIENTS EXIF_RATIONAL
-// Subsampling ratio of Y to C
-// Use EXIFTAGTYPE_YCBCR_SUB_SAMPLING as the exif_tag_type (EXIF_SHORT)
-// Count should be 2
-#define _ID_YCBCR_SUB_SAMPLING 0x0212
-#define EXIFTAGID_YCBCR_SUB_SAMPLING CONSTRUCT_TAGID(YCBCR_SUB_SAMPLING, _ID_YCBCR_SUB_SAMPLING)
-#define EXIFTAGTYPE_YCBCR_SUB_SAMPLING EXIF_SHORT
-// Y and C positioning
-// Use EXIFTAGTYPE_YCBCR_POSITIONING as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_YCBCR_POSITIONING 0x0213
-#define EXIFTAGID_YCBCR_POSITIONING CONSTRUCT_TAGID(YCBCR_POSITIONING, _ID_YCBCR_POSITIONING)
-#define EXIFTAGTYPE_YCBCR_POSITIONING EXIF_SHORT
-// Pair of black and white reference values
-// Use EXIFTAGTYPE_REFERENCE_BLACK_WHITE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_REFERENCE_BLACK_WHITE 0x0214
-#define EXIFTAGID_REFERENCE_BLACK_WHITE CONSTRUCT_TAGID(REFERENCE_BLACK_WHITE, _ID_REFERENCE_BLACK_WHITE)
-#define EXIFTAGTYPE_REFERENCE_BLACK_WHITE EXIF_RATIONAL
-// GAMMA
-// Use EXIFTAGTYPE_GAMMA as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_GAMMA 0x0301
-#define EXIFTAGID_GAMMA CONSTRUCT_TAGID(GAMMA, _ID_GAMMA)
-#define EXIFTAGTYPE_GAMMA EXIF_RATIONAL
-// Null-terminated character string that identifies an ICC profile.
-// Use EXIFTAGTYPE_ICC_PROFILE_DESCRIPTOR as the exif_tag_type (EXIF_ASCII)
-// Count should be 6
-#define _ID_ICC_PROFILE_DESCRIPTOR 0x0302
-#define EXIFTAGID_ICC_PROFILE_DESCRIPTOR CONSTRUCT_TAGID(ICC_PROFILE_DESCRIPTOR, _ID_ICC_PROFILE_DESCRIPTOR)
-#define EXIFTAGTYPE_ICC_PROFILE_DESCRIPTOR EXIF_ASCII
-// SRGB_RENDERING_INTENT
-// Use EXIFTAGTYPE_SRGB_RENDERING_INTENT as the exif_tag_type (EXIF_BYTE)
-// Count should be 6
-#define _ID_SRGB_RENDERING_INTENT 0x0303
-#define EXIFTAGID_SRGB_RENDERING_INTENT CONSTRUCT_TAGID(SRGB_RENDERING_INTENT, _ID_SRGB_RENDERING_INTENT)
-#define EXIFTAGTYPE_SRGB_RENDERING_INTENT EXIF_BYTE
-
-// Null-terminated character string that specifies the title of the image.
-// Use EXIFTAGTYPE_IMAGE_TITLE as the exif_tag_type (EXIF_ASCII )
-//
-#define _ID_IMAGE_TITLE 0x0320
-#define EXIFTAGID_IMAGE_TITLE CONSTRUCT_TAGID(IMAGE_TITLE, _ID_IMAGE_TITLE)
-#define EXIFTAGTYPE_IMAGE_TITLE EXIF_ASCII
-
-// Copyright holder
-// Use EXIFTAGTYPE_COPYRIGHT as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_COPYRIGHT 0x8298
-#define EXIFTAGID_COPYRIGHT CONSTRUCT_TAGID(COPYRIGHT, _ID_COPYRIGHT)
-#define EXIFTAGTYPE_COPYRIGHT EXIF_ASCII
-// Old Subfile Type
-// Use EXIFTAGTYPE_NEW_SUBFILE_TYPE as the exif_tag_type (EXIF_SHORT)
-// Count can be any
-#define _ID_NEW_SUBFILE_TYPE 0x00fe
-#define EXIFTAGID_NEW_SUBFILE_TYPE CONSTRUCT_TAGID(NEW_SUBFILE_TYPE, _ID_NEW_SUBFILE_TYPE)
-#define EXIFTAGTYPE_NEW_SUBFILE_TYPE EXIF_SHORT
-
-// New Subfile Type
-// Use EXIFTAGTYPE_NEW_SUBFILE_TYPE as the exif_tag_type (EXIF_LONG)
-// Count can be any
-#define _ID_SUBFILE_TYPE 0x00ff
-#define EXIFTAGID_SUBFILE_TYPE CONSTRUCT_TAGID(SUBFILE_TYPE, _ID_SUBFILE_TYPE)
-#define EXIFTAGTYPE_SUBFILE_TYPE EXIF_LONG
-
-// Image width (of thumbnail)
-// Use EXIFTAGTYPE_TN_IMAGE_WIDTH as the exif_tag_type (EXIF_LONG)
-// Count should be 1
-#define _ID_TN_IMAGE_WIDTH 0x0100
-#define EXIFTAGID_TN_IMAGE_WIDTH CONSTRUCT_TAGID(TN_IMAGE_WIDTH, _ID_TN_IMAGE_WIDTH)
-#define EXIFTAGTYPE_TN_IMAGE_WIDTH EXIF_LONG
-// Image height (of thumbnail)
-// Use EXIFTAGTYPE_TN_IMAGE_LENGTH as the exif_tag_type (EXIF_SHORT_OR_LONG)
-// Count should be 1
-#define _ID_TN_IMAGE_LENGTH 0x0101
-#define EXIFTAGID_TN_IMAGE_LENGTH CONSTRUCT_TAGID(TN_IMAGE_LENGTH, _ID_TN_IMAGE_LENGTH)
-#define EXIFTAGTYPE_TN_IMAGE_LENGTH EXIF_LONG
-// Number of bits per component (of thumbnail)
-// Use EXIFTAGTYPE_TN_BITS_PER_SAMPLE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_BITS_PER_SAMPLE 0x0102
-#define EXIFTAGID_TN_BITS_PER_SAMPLE CONSTRUCT_TAGID(TN_BITS_PER_SAMPLE, _ID_TN_BITS_PER_SAMPLE)
-#define EXIFTAGTYPE_TN_BITS_PER_SAMPLE EXIF_SHORT
-// Compression scheme (of thumbnail)
-// Use EXIFTAGTYPE_TN_COMPRESSION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_COMPRESSION 0x0103
-#define EXIFTAGID_TN_COMPRESSION CONSTRUCT_TAGID(TN_COMPRESSION, _ID_TN_COMPRESSION)
-#define EXIFTAGTYPE_TN_COMPRESSION EXIF_SHORT
-// Pixel composition (of thumbnail)
-// Use EXIFTAGTYPE_TN_PHOTOMETRIC_INTERPRETATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_PHOTOMETRIC_INTERPRETATION 0x0106
-#define EXIFTAGID_TN_PHOTOMETRIC_INTERPRETATION CONSTRUCT_TAGID(TN_PHOTOMETRIC_INTERPRETATION, _ID_TN_PHOTOMETRIC_INTERPRETATION)
-#define EXIFTAGTYPE_TN_PHOTOMETRIC_INTERPRETATION EXIF_SHORT
-// Image title (of thumbnail)
-// Use EXIFTAGTYPE_TN_IMAGE_DESCRIPTION as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_IMAGE_DESCRIPTION 0x010e
-#define EXIFTAGID_TN_IMAGE_DESCRIPTION CONSTRUCT_TAGID(TN_IMAGE_DESCRIPTION, _ID_TN_IMAGE_DESCRIPTION)
-#define EXIFTAGTYPE_TN_IMAGE_DESCRIPTION EXIF_ASCII
-// Image input equipment manufacturer (of thumbnail)
-// Use EXIFTAGTYPE_TN_MAKE as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_MAKE 0x010f
-#define EXIFTAGID_TN_MAKE CONSTRUCT_TAGID(TN_MAKE, _ID_TN_MAKE)
-#define EXIFTAGTYPE_TN_MAKE EXIF_ASCII
-// Image input equipment model (of thumbnail)
-// Use EXIFTAGTYPE_TN_MODEL as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_MODEL 0x0110
-#define EXIFTAGID_TN_MODEL CONSTRUCT_TAGID(TN_MODEL, _ID_TN_MODEL)
-#define EXIFTAGTYPE_TN_MODEL EXIF_ASCII
-// Image data location (of thumbnail)
-// Use EXIFTAGTYPE_TN_STRIP_OFFSETS as the exif_tag_type (EXIF_LONG)
-// Count = StripsPerImage when PlanarConfiguration = 1
-// = SamplesPerPixel * StripsPerImage when PlanarConfiguration = 2
-#define _ID_TN_STRIP_OFFSETS 0x0111
-#define EXIFTAGID_TN_STRIP_OFFSETS CONSTRUCT_TAGID(STRIP_TN_OFFSETS, _ID_TN_STRIP_OFFSETS)
-#define EXIFTAGTYPE_TN_STRIP_OFFSETS EXIF_LONG
-// Orientation of image (of thumbnail)
-// Use EXIFTAGTYPE_TN_ORIENTATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_ORIENTATION 0x0112
-#define EXIFTAGID_TN_ORIENTATION CONSTRUCT_TAGID(TN_ORIENTATION, _ID_TN_ORIENTATION)
-#define EXIFTAGTYPE_TN_ORIENTATION EXIF_SHORT
-// Number of components (of thumbnail)
-// Use EXIFTAGTYPE_TN_SAMPLES_PER_PIXEL as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_SAMPLES_PER_PIXEL 0x0115
-#define EXIFTAGID_TN_SAMPLES_PER_PIXEL CONSTRUCT_TAGID(TN_SAMPLES_PER_PIXEL, _ID_TN_SAMPLES_PER_PIXEL)
-#define EXIFTAGTYPE_TN_SAMPLES_PER_PIXEL EXIF_SHORT
-// Number of rows per strip (of thumbnail)
-// Use EXIFTAGTYPE_TN_ROWS_PER_STRIP as the exif_tag_type (EXIF_LONG)
-// Count should be 1
-#define _ID_TN_ROWS_PER_STRIP 0x0116
-#define EXIFTAGID_TN_ROWS_PER_STRIP CONSTRUCT_TAGID(TN_ROWS_PER_STRIP, _ID_TN_ROWS_PER_STRIP)
-#define EXIFTAGTYPE_TN_ROWS_PER_STRIP EXIF_LONG
-// Bytes per compressed strip (of thumbnail)
-// Use EXIFTAGTYPE_TN_STRIP_BYTE_COUNTS as the exif_tag_type (EXIF_LONG)
-// Count = StripsPerImage when PlanarConfiguration = 1
-// = SamplesPerPixel * StripsPerImage when PlanarConfiguration = 2
-#define _ID_TN_STRIP_BYTE_COUNTS 0x0117
-#define EXIFTAGID_TN_STRIP_BYTE_COUNTS CONSTRUCT_TAGID(TN_STRIP_BYTE_COUNTS, _ID_TN_STRIP_BYTE_COUNTS)
-#define EXIFTAGTYPE_TN_STRIP_BYTE_COUNTS EXIF_LONG
-// Image resolution in width direction (of thumbnail)
-// Use EXIFTAGTYPE_TN_X_RESOLUTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_TN_X_RESOLUTION 0x011a
-#define EXIFTAGID_TN_X_RESOLUTION CONSTRUCT_TAGID(TN_X_RESOLUTION, _ID_TN_X_RESOLUTION)
-#define EXIFTAGTYPE_TN_X_RESOLUTION EXIF_RATIONAL
-// Image resolution in height direction (of thumbnail)
-// Use EXIFTAGTYPE_TN_Y_RESOLUTION as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_TN_Y_RESOLUTION 0x011b
-#define EXIFTAGID_TN_Y_RESOLUTION CONSTRUCT_TAGID(TN_Y_RESOLUTION, _ID_TN_Y_RESOLUTION)
-#define EXIFTAGTYPE_TN_Y_RESOLUTION EXIF_RATIONAL
-// Image data arrangement (of thumbnail)
-// Use EXIFTAGTYPE_TN_PLANAR_CONFIGURATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_PLANAR_CONFIGURATION 0x011c
-#define EXIFTAGID_TN_PLANAR_CONFIGURATION CONSTRUCT_TAGID(TN_PLANAR_CONFIGURATION, _ID_TN_PLANAR_CONFIGURATION)
-#define EXIFTAGTYPE_TN_PLANAR_CONFIGURATION EXIF_SHORT
-// Unit of X and Y resolution (of thumbnail)
-// Use EXIFTAGTYPE_TN_RESOLUTION_UNIT as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_RESOLUTION_UNIT 0x128
-#define EXIFTAGID_TN_RESOLUTION_UNIT CONSTRUCT_TAGID(TN_RESOLUTION_UNIT, _ID_TN_RESOLUTION_UNIT)
-#define EXIFTAGTYPE_TN_RESOLUTION_UNIT EXIF_SHORT
-// Transfer function (of thumbnail)
-// Use EXIFTAGTYPE_TN_TRANSFER_FUNCTION as the exif_tag_type (EXIF_SHORT)
-// Count should be 3*256
-#define _ID_TN_TRANSFER_FUNCTION 0x012d
-#define EXIFTAGID_TN_TRANSFER_FUNCTION CONSTRUCT_TAGID(TN_TRANSFER_FUNCTION, _ID_TN_TRANSFER_FUNCTION)
-#define EXIFTAGTYPE_TN_TRANSFER_FUNCTION EXIF_SHORT
-// Software used (of thumbnail)
-// Use EXIFTAGTYPE_TN_SOFTWARE as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_SOFTWARE 0x0131
-#define EXIFTAGID_TN_SOFTWARE CONSTRUCT_TAGID(TN_SOFTWARE, _ID_TN_SOFTWARE)
-#define EXIFTAGTYPE_TN_SOFTWARE EXIF_ASCII
-// File change date and time (of thumbnail)
-// Use EXIFTAGTYPE_TN_DATE_TIME as the exif_tag_type (EXIF_ASCII)
-// Count should be 20
-#define _ID_TN_DATE_TIME 0x0132
-#define EXIFTAGID_TN_DATE_TIME CONSTRUCT_TAGID(TN_DATE_TIME, _ID_TN_DATE_TIME)
-#define EXIFTAGTYPE_TN_DATE_TIME EXIF_ASCII
-// ARTIST, person who created this image (of thumbnail)
-// Use EXIFTAGTYPE_TN_ARTIST as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_ARTIST 0x013b
-#define EXIFTAGID_TN_ARTIST CONSTRUCT_TAGID(TN_ARTIST, _ID_TN_ARTIST)
-#define EXIFTAGTYPE_TN_ARTIST EXIF_ASCII
-// White point chromaticity (of thumbnail)
-// Use EXIFTAGTYPE_TN_WHITE_POINT as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 2
-#define _ID_TN_WHITE_POINT 0x013e
-#define EXIFTAGID_TN_WHITE_POINT CONSTRUCT_TAGID(TN_WHITE_POINT, _ID_TN_WHITE_POINT)
-#define EXIFTAGTYPE_TN_WHITE_POINT EXIF_RATIONAL
-// Chromaticities of primaries (of thumbnail)
-// Use EXIFTAGTYPE_TN_PRIMARY_CHROMATICITIES as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_TN_PRIMARY_CHROMATICITIES 0x013f
-#define EXIFTAGID_TN_PRIMARY_CHROMATICITIES CONSTRUCT_TAGID(TN_PRIMARY_CHROMATICITIES, _ID_TN_PRIMARY_CHROMATICITIES)
-#define EXIFTAGTYPE_TN_PRIMARY_CHROMATICITIES EXIF_RATIONAL
-// Offset to JPEG SOI (of thumbnail)
-// Use EXIFTAGTYPE_TN_JPEGINTERCHANGE_FORMAT as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_TN_JPEGINTERCHANGE_FORMAT 0x0201
-#define EXIFTAGID_TN_JPEGINTERCHANGE_FORMAT CONSTRUCT_TAGID(TN_JPEGINTERCHANGE_FORMAT, _ID_TN_JPEGINTERCHANGE_FORMAT)
-#define EXIFTAGTYPE_TN_JPEGINTERCHANGE_FORMAT EXIF_LONG
-// Bytes of JPEG data (of thumbnail)
-// Use EXIFTAGTYPE_TN_JPEGINTERCHANGE_FORMAT_L as the exif_tag_type (EXIF_LONG)
-// Count is undefined
-#define _ID_TN_JPEGINTERCHANGE_FORMAT_L 0x0202
-#define EXIFTAGID_TN_JPEGINTERCHANGE_FORMAT_L CONSTRUCT_TAGID(TN_JPEGINTERCHANGE_FORMAT_L, _ID_TN_JPEGINTERCHANGE_FORMAT_L)
-#define EXIFTAGTYPE_TN_JPEGINTERCHANGE_FORMAT_L EXIF_LONG
-// Color space transformation matrix coefficients (of thumbnail)
-// Use EXIFTAGTYPE_TN_YCBCR_COEFFICIENTS as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 3
-#define _ID_TN_YCBCR_COEFFICIENTS 0x0211
-#define EXIFTAGID_TN_YCBCR_COEFFICIENTS CONSTRUCT_TAGID(TN_YCBCR_COEFFICIENTS, _ID_TN_YCBCR_COEFFICIENTS)
-#define EXIFTAGTYPE_TN_YCBCR_COEFFICIENTS EXIF_RATIONAL
-// Subsampling ratio of Y to C (of thumbnail)
-// Use EXIFTAGTYPE_TN_YCBCR_SUB_SAMPLING as the exif_tag_type (EXIF_SHORT)
-// Count should be 2
-#define _ID_TN_YCBCR_SUB_SAMPLING 0x0212
-#define EXIFTAGID_TN_YCBCR_SUB_SAMPLING CONSTRUCT_TAGID(TN_YCBCR_SUB_SAMPLING, _ID_TN_YCBCR_SUB_SAMPLING)
-#define EXIFTAGTYPE_TN_YCBCR_SUB_SAMPLING EXIF_SHORT
-// Y and C positioning (of thumbnail)
-// Use EXIFTAGTYPE_TN_YCBCR_POSITIONING as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_TN_YCBCR_POSITIONING 0x0213
-#define EXIFTAGID_TN_YCBCR_POSITIONING CONSTRUCT_TAGID(TN_YCBCR_POSITIONING, _ID_TN_YCBCR_POSITIONING)
-#define EXIFTAGTYPE_TN_YCBCR_POSITIONING EXIF_SHORT
-// Pair of black and white reference values (of thumbnail)
-// Use EXIFTAGTYPE_TN_REFERENCE_BLACK_WHITE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 6
-#define _ID_TN_REFERENCE_BLACK_WHITE 0x0214
-#define EXIFTAGID_TN_REFERENCE_BLACK_WHITE CONSTRUCT_TAGID(TN_REFERENCE_BLACK_WHITE, _ID_TN_REFERENCE_BLACK_WHITE)
-#define EXIFTAGTYPE_TN_REFERENCE_BLACK_WHITE EXIF_RATIONAL
-// Copyright holder (of thumbnail)
-// Use EXIFTAGTYPE_TN_COPYRIGHT as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_TN_COPYRIGHT 0x8298
-#define EXIFTAGID_TN_COPYRIGHT CONSTRUCT_TAGID(TN_COPYRIGHT, _ID_TN_COPYRIGHT)
-#define EXIFTAGTYPE_TN_COPYRIGHT EXIF_ASCII
-// Exposure time
-// Use EXIFTAGTYPE_EXPOSURE_TIME as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_EXPOSURE_TIME 0x829a
-#define EXIFTAGID_EXPOSURE_TIME CONSTRUCT_TAGID(EXPOSURE_TIME, _ID_EXPOSURE_TIME)
-#define EXIFTAGTYPE_EXPOSURE_TIME EXIF_RATIONAL
-// F number
-// Use EXIFTAGTYPE_F_NUMBER as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_F_NUMBER 0x829d
-#define EXIFTAGID_F_NUMBER CONSTRUCT_TAGID(F_NUMBER, _ID_F_NUMBER)
-#define EXIFTAGTYPE_F_NUMBER EXIF_RATIONAL
-// Exif IFD pointer (NOT INTENDED to be accessible to user)
-#define _ID_EXIF_IFD_PTR 0x8769
-#define EXIFTAGID_EXIF_IFD_PTR CONSTRUCT_TAGID(EXIF_IFD, _ID_EXIF_IFD_PTR)
-#define EXIFTAGTYPE_EXIF_IFD_PTR EXIF_LONG
-
-// ICC_PROFILE (NOT INTENDED to be accessible to user)
-#define _ID_ICC_PROFILE 0x8773
-#define EXIFTAGID_ICC_PROFILE CONSTRUCT_TAGID(ICC_PROFILE, _ID_ICC_PROFILE)
-#define EXIFTAGTYPE_ICC_PROFILE EXIF_LONG
-// Exposure program
-// Use EXIFTAGTYPE_EXPOSURE_PROGRAM as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXPOSURE_PROGRAM 0x8822
-#define EXIFTAGID_EXPOSURE_PROGRAM CONSTRUCT_TAGID(EXPOSURE_PROGRAM, _ID_EXPOSURE_PROGRAM)
-#define EXIFTAGTYPE_EXPOSURE_PROGRAM EXIF_SHORT
-// Spectral sensitivity
-// Use EXIFTAGTYPE_SPECTRAL_SENSITIVITY as the exif_tag_type (EXIF_ASCII)
-// Count can be any
-#define _ID_SPECTRAL_SENSITIVITY 0x8824
-#define EXIFTAGID_SPECTRAL_SENSITIVITY CONSTRUCT_TAGID(SPECTRAL_SENSITIVITY, _ID_SPECTRAL_SENSITIVITY)
-#define EXIFTAGTYPE_SPECTRAL_SENSITIVITY EXIF_ASCII
-// GPS IFD pointer (NOT INTENDED to be accessible to user)
-#define _ID_GPS_IFD_PTR 0x8825
-#define EXIFTAGID_GPS_IFD_PTR CONSTRUCT_TAGID(GPS_IFD, _ID_GPS_IFD_PTR)
-#define EXIFTAGTYPE_GPS_IFD_PTR EXIF_LONG
-// ISO Speed Rating
-// Use EXIFTAGTYPE_ISO_SPEED_RATING as the exif_tag_type (EXIF_SHORT)
-// Count can be any
-#define _ID_ISO_SPEED_RATING 0x8827
-#define EXIFTAGID_ISO_SPEED_RATING CONSTRUCT_TAGID(ISO_SPEED_RATING, _ID_ISO_SPEED_RATING)
-#define EXIFTAGTYPE_ISO_SPEED_RATING EXIF_SHORT
-// Optoelectric conversion factor
-// Use EXIFTAGTYPE_OECF as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_OECF 0x8828
-#define EXIFTAGID_OECF CONSTRUCT_TAGID(OECF, _ID_OECF)
-#define EXIFTAGTYPE_OECF EXIF_UNDEFINED
-// Exif version
-// Use EXIFTAGTYPE_EXIF_VERSION as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 4
-#define _ID_EXIF_VERSION 0x9000
-#define EXIFTAGID_EXIF_VERSION CONSTRUCT_TAGID(EXIF_VERSION, _ID_EXIF_VERSION)
-#define EXIFTAGTYPE_EXIF_VERSION EXIF_UNDEFINED
-// Date and time of original data gerneration
-// Use EXIFTAGTYPE_EXIF_DATE_TIME_ORIGINAL as the exif_tag_type (EXIF_ASCII)
-// It should be 20 characters long including the null-terminating character.
-#define _ID_EXIF_DATE_TIME_ORIGINAL 0x9003
-#define EXIFTAGID_EXIF_DATE_TIME_ORIGINAL CONSTRUCT_TAGID(EXIF_DATE_TIME_ORIGINAL, _ID_EXIF_DATE_TIME_ORIGINAL)
-#define EXIFTAGTYPE_EXIF_DATE_TIME_ORIGINAL EXIF_ASCII
-// Date and time of digital data generation
-// Use EXIFTAGTYPE_EXIF_DATE_TIME_DIGITIZED as the exif_tag_type (EXIF_ASCII)
-// It should be 20 characters long including the null-terminating character.
-#define _ID_EXIF_DATE_TIME_DIGITIZED 0x9004
-#define EXIFTAGID_EXIF_DATE_TIME_DIGITIZED CONSTRUCT_TAGID(EXIF_DATE_TIME_DIGITIZED, _ID_EXIF_DATE_TIME_DIGITIZED)
-#define EXIFTAGTYPE_EXIF_DATE_TIME_DIGITIZED EXIF_ASCII
-// Meaning of each component
-// Use EXIFTAGTYPE_EXIF_COMPONENTS_CONFIG as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 4
-#define _ID_EXIF_COMPONENTS_CONFIG 0x9101
-#define EXIFTAGID_EXIF_COMPONENTS_CONFIG CONSTRUCT_TAGID(EXIF_COMPONENTS_CONFIG, _ID_EXIF_COMPONENTS_CONFIG)
-#define EXIFTAGTYPE_EXIF_COMPONENTS_CONFIG EXIF_UNDEFINED
-// Meaning of Image compression mode
-// Use EXIFTAGTYPE_EXIF_COMPRESSED_BITS_PER_PIXEL as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_EXIF_COMPRESSED_BITS_PER_PIXEL 0x9102
-#define EXIFTAGID_EXIF_COMPRESSED_BITS_PER_PIXEL CONSTRUCT_TAGID(EXIF_COMPRESSED_BITS_PER_PIXEL, _ID_EXIF_COMPRESSED_BITS_PER_PIXEL)
-#define EXIFTAGTYPE_EXIF_COMPRESSED_BITS_PER_PIXEL EXIF_RATIONAL
-// Shutter speed
-// Use EXIFTAGTYPE_SHUTTER_SPEED as the exif_tag_type (EXIF_SRATIONAL)
-// Count should be 1
-#define _ID_SHUTTER_SPEED 0x9201
-#define EXIFTAGID_SHUTTER_SPEED CONSTRUCT_TAGID(SHUTTER_SPEED, _ID_SHUTTER_SPEED)
-#define EXIFTAGTYPE_SHUTTER_SPEED EXIF_SRATIONAL
-// Aperture
-// Use EXIFTAGTYPE_APERTURE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_APERTURE 0x9202
-#define EXIFTAGID_APERTURE CONSTRUCT_TAGID(APERTURE, _ID_APERTURE)
-#define EXIFTAGTYPE_APERTURE EXIF_RATIONAL
-// Brigthness
-// Use EXIFTAGTYPE_BRIGHTNESS as the exif_tag_type (EXIF_SRATIONAL)
-// Count should be 1
-#define _ID_BRIGHTNESS 0x9203
-#define EXIFTAGID_BRIGHTNESS CONSTRUCT_TAGID(BRIGHTNESS, _ID_BRIGHTNESS)
-#define EXIFTAGTYPE_BRIGHTNESS EXIF_SRATIONAL
-// Exposure bias
-// Use EXIFTAGTYPE_EXPOSURE_BIAS_VALUE as the exif_tag_type (EXIF_SRATIONAL)
-// Count should be 1
-#define _ID_EXPOSURE_BIAS_VALUE 0x9204
-#define EXIFTAGID_EXPOSURE_BIAS_VALUE CONSTRUCT_TAGID(EXPOSURE_BIAS_VALUE, _ID_EXPOSURE_BIAS_VALUE)
-#define EXIFTAGTYPE_EXPOSURE_BIAS_VALUE EXIF_SRATIONAL
-// Maximum lens aperture
-// Use EXIFTAGTYPE_MAX_APERTURE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_MAX_APERTURE 0x9205
-#define EXIFTAGID_MAX_APERTURE CONSTRUCT_TAGID(MAX_APERTURE, _ID_MAX_APERTURE)
-#define EXIFTAGTYPE_MAX_APERTURE EXIF_RATIONAL
-// Subject distance
-// Use EXIFTAGTYPE_SUBJECT_DISTANCE as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_SUBJECT_DISTANCE 0x9206
-#define EXIFTAGID_SUBJECT_DISTANCE CONSTRUCT_TAGID(SUBJECT_DISTANCE, _ID_SUBJECT_DISTANCE)
-#define EXIFTAGTYPE_SUBJECT_DISTANCE EXIF_RATIONAL
-// Metering mode
-// Use EXIFTAGTYPE_METERING_MODE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_METERING_MODE 0x9207
-#define EXIFTAGID_METERING_MODE CONSTRUCT_TAGID(METERING_MODE, _ID_METERING_MODE)
-#define EXIFTAGTYPE_METERING_MODE EXIF_SHORT
-// Light source
-// Use EXIFTAGTYPE_LIGHT_SOURCE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_LIGHT_SOURCE 0x9208
-#define EXIFTAGID_LIGHT_SOURCE CONSTRUCT_TAGID(LIGHT_SOURCE, _ID_LIGHT_SOURCE)
-#define EXIFTAGTYPE_LIGHT_SOURCE EXIF_SHORT
-// Flash
-// Use EXIFTAGTYPE_FLASH as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_FLASH 0x9209
-#define EXIFTAGID_FLASH CONSTRUCT_TAGID(FLASH, _ID_FLASH)
-#define EXIFTAGTYPE_FLASH EXIF_SHORT
-// Lens focal length
-// Use EXIFTAGTYPE_FOCAL_LENGTH as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_FOCAL_LENGTH 0x920a
-#define EXIFTAGID_FOCAL_LENGTH CONSTRUCT_TAGID(FOCAL_LENGTH, _ID_FOCAL_LENGTH)
-#define EXIFTAGTYPE_FOCAL_LENGTH EXIF_RATIONAL
-// Subject area
-// Use EXIFTAGTYPE_SUBJECT_AREA as exif_tag_type (EXIF_SHORT)
-// Count should be 2 or 3 or 4
-#define _ID_SUBJECT_AREA 0x9214
-#define EXIFTAGID_SUBJECT_AREA CONSTRUCT_TAGID(SUBJECT_AREA, _ID_SUBJECT_AREA)
-#define EXIFTAGTYPE_SUBJECT_AREA EXIF_SHORT
-// Maker note
-// Use EXIFTAGTYPE_EXIF_MAKER_NOTE as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_EXIF_MAKER_NOTE 0x927c
-#define EXIFTAGID_EXIF_MAKER_NOTE CONSTRUCT_TAGID(EXIF_MAKER_NOTE, _ID_EXIF_MAKER_NOTE)
-#define EXIFTAGTYPE_EXIF_MAKER_NOTE EXIF_UNDEFINED
-// User comments
-// Use EXIFTAGTYPE_EXIF_USER_COMMENT as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_EXIF_USER_COMMENT 0x9286
-#define EXIFTAGID_EXIF_USER_COMMENT CONSTRUCT_TAGID(EXIF_USER_COMMENT, _ID_EXIF_USER_COMMENT)
-#define EXIFTAGTYPE_EXIF_USER_COMMENT EXIF_UNDEFINED
-// Date time sub-seconds
-// Use EXIFTAGTYPE_SUBSEC_TIME as the exif_tag_type (EXIF_ASCII)
-// Count could be any
-#define _ID_SUBSEC_TIME 0x9290
-#define EXIFTAGID_SUBSEC_TIME CONSTRUCT_TAGID(SUBSEC_TIME, _ID_SUBSEC_TIME)
-#define EXIFTAGTYPE_SEBSEC_TIME EXIF_ASCII
-// Date time original sub-seconds
-// use EXIFTAGTYPE_SUBSEC_TIME_ORIGINAL as the exif_tag_type (EXIF_ASCII)
-// Count could be any
-#define _ID_SUBSEC_TIME_ORIGINAL 0x9291
-#define EXIFTAGID_SUBSEC_TIME_ORIGINAL CONSTRUCT_TAGID(SUBSEC_TIME_ORIGINAL, _ID_SUBSEC_TIME_ORIGINAL)
-#define EXIFTAGTYPE_SUBSEC_TIME_ORIGINAL EXIF_ASCII
-// Date time digitized sub-seconds
-// use EXIFTAGTYPE_SUBSEC_TIME_DIGITIZED as the exif_tag_type (EXIF_ASCII)
-// Count could be any
-#define _ID_SUBSEC_TIME_DIGITIZED 0x9292
-#define EXIFTAGID_SUBSEC_TIME_DIGITIZED CONSTRUCT_TAGID(SUBSEC_TIME_DIGITIZED, _ID_SUBSEC_TIME_DIGITIZED)
-#define EXIFTAGTYPE_SUBSEC_TIME_DIGITIZED EXIF_ASCII
-// Supported Flashpix version
-// Use EXIFTAGTYPE_EXIF_FLASHPIX_VERSION as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 4
-#define _ID_EXIF_FLASHPIX_VERSION 0xa000
-#define EXIFTAGID_EXIF_FLASHPIX_VERSION CONSTRUCT_TAGID(EXIF_FLASHPIX_VERSION, _ID_EXIF_FLASHPIX_VERSION)
-#define EXIFTAGTYPE_EXIF_FLASHPIX_VERSION EXIF_UNDEFINED
-// Color space information
-// Use EXIFTAGTYPE_EXIF_COLOR_SPACE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXIF_COLOR_SPACE 0xa001
-#define EXIFTAGID_EXIF_COLOR_SPACE CONSTRUCT_TAGID(EXIF_COLOR_SPACE, _ID_EXIF_COLOR_SPACE)
-#define EXIFTAGTYPE_EXIF_COLOR_SPACE EXIF_SHORT
-// Valid image width
-// Use EXIFTAGTYPE_EXIF_PIXEL_X_DIMENSION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXIF_PIXEL_X_DIMENSION 0xa002
-#define EXIFTAGID_EXIF_PIXEL_X_DIMENSION CONSTRUCT_TAGID(EXIF_PIXEL_X_DIMENSION, _ID_EXIF_PIXEL_X_DIMENSION)
-#define EXIFTAGTYPE_EXIF_PIXEL_X_DIMENSION EXIF_SHORT
-// Valid image height
-// Use EXIFTAGTYPE_EXIF_PIXEL_Y_DIMENSION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXIF_PIXEL_Y_DIMENSION 0xa003
-#define EXIFTAGID_EXIF_PIXEL_Y_DIMENSION CONSTRUCT_TAGID(EXIF_PIXEL_Y_DIMENSION, _ID_EXIF_PIXEL_Y_DIMENSION)
-#define EXIFTAGTYPE_EXIF_PIXEL_Y_DIMENSION EXIF_SHORT
-// Related audio file
-// Use EXIFTAGTYPE_EXIF_RELATED_SOUND_FILE as the exif_tag_type (EXIF_ASCII)
-// Count should be 13
-#define _ID_RELATED_SOUND_FILE 0xa004
-#define EXIFTAGID_RELATED_SOUND_FILE CONSTRUCT_TAGID(RELATED_SOUND_FILE, _ID_RELATED_SOUND_FILE)
-#define EXIFTAGTYPE_RELATED_SOUND_FILE EXIF_ASCII
-// Interop IFD pointer (NOT INTENDED to be accessible to user)
-#define _ID_INTEROP_IFD_PTR 0xa005
-#define EXIFTAGID_INTEROP_IFD_PTR CONSTRUCT_TAGID(INTEROP, _ID_INTEROP_IFD_PTR)
-#define EXIFTAGTYPE_INTEROP_IFD_PTR EXIF_LONG
-// Flash energy
-// Use EXIFTAGTYPE_EXIF_FLASH_ENERGY as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_FLASH_ENERGY 0xa20b
-#define EXIFTAGID_FLASH_ENERGY CONSTRUCT_TAGID(FLASH_ENERGY, _ID_FLASH_ENERGY)
-#define EXIFTAGTYPE_FLASH_ENERGY EXIF_RATIONAL
-// Spatial frequency response
-// Use EXIFTAGTYPE_SPATIAL_FREQ_RESPONSE as exif_tag_type (EXIF_UNDEFINED)
-// Count would be any
-#define _ID_SPATIAL_FREQ_RESPONSE 0xa20c
-#define EXIFTAGID_SPATIAL_FREQ_RESPONSE CONSTRUCT_TAGID(SPATIAL_FREQ_RESPONSE, _ID_SPATIAL_FREQ_RESPONSE)
-#define EXIFTAGTYPE_SPATIAL_FREQ_RESPONSE EXIF_UNDEFINED
-// Focal plane x resolution
-// Use EXIFTAGTYPE_FOCAL_PLANE_X_RESOLUTION as exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_FOCAL_PLANE_X_RESOLUTION 0xa20e
-#define EXIFTAGID_FOCAL_PLANE_X_RESOLUTION CONSTRUCT_TAGID(FOCAL_PLANE_X_RESOLUTION, _ID_FOCAL_PLANE_X_RESOLUTION)
-#define EXIFTAGTYPE_FOCAL_PLANE_X_RESOLUTION EXIF_RATIONAL
-// Focal plane y resolution
-// Use EXIFTAGTYPE_FOCAL_PLANE_Y_RESOLUTION as exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_FOCAL_PLANE_Y_RESOLUTION 0xa20f
-#define EXIFTAGID_FOCAL_PLANE_Y_RESOLUTION CONSTRUCT_TAGID(FOCAL_PLANE_Y_RESOLUTION, _ID_FOCAL_PLANE_Y_RESOLUTION)
-#define EXIFTAGTYPE_FOCAL_PLANE_Y_RESOLUTION EXIF_RATIONAL
-// Focal plane resolution unit
-// Use EXIFTAGTYPE_FOCAL_PLANE_RESOLUTION_UNIT as exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_FOCAL_PLANE_RESOLUTION_UNIT 0xa210
-#define EXIFTAGID_FOCAL_PLANE_RESOLUTION_UNIT CONSTRUCT_TAGID(FOCAL_PLANE_RESOLUTION_UNIT, _ID_FOCAL_PLANE_RESOLUTION_UNIT)
-#define EXIFTAGTYPE_FOCAL_PLANE_RESOLUTION_UNIT EXIF_SHORT
-// Subject location
-// Use EXIFTAGTYPE_SUBJECT_LOCATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 2
-#define _ID_SUBJECT_LOCATION 0xa214
-#define EXIFTAGID_SUBJECT_LOCATION CONSTRUCT_TAGID(SUBJECT_LOCATION, _ID_SUBJECT_LOCATION)
-#define EXIFTAGTYPE_SUBJECT_LOCATION EXIF_SHORT
-// Exposure index
-// Use EXIFTAGTYPE_EXPOSURE_INDEX as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_EXPOSURE_INDEX 0xa215
-#define EXIFTAGID_EXPOSURE_INDEX CONSTRUCT_TAGID(EXPOSURE_INDEX, _ID_EXPOSURE_INDEX)
-#define EXIFTAGTYPE_EXPOSURE_INDEX EXIF_RATIONAL
-// Sensing method
-// Use EXIFTAGTYPE_SENSING_METHOD as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SENSING_METHOD 0xa217
-#define EXIFTAGID_SENSING_METHOD CONSTRUCT_TAGID(SENSING_METHOD, _ID_SENSING_METHOD)
-#define EXIFTAGTYPE_SENSING_METHOD EXIF_SHORT
-// File source
-// Use EXIFTAGTYPE_FILE_SOURCE as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 1
-#define _ID_FILE_SOURCE 0xa300
-#define EXIFTAGID_FILE_SOURCE CONSTRUCT_TAGID(FILE_SOURCE, _ID_FILE_SOURCE)
-#define EXIFTAGTYPE_FILE_SOURCE EXIF_UNDEFINED
-// Scene type
-// Use EXIFTAGTYPE_SCENE_TYPE as the exif_tag_type (EXIF_UNDEFINED)
-// Count should be 1
-#define _ID_SCENE_TYPE 0xa301
-#define EXIFTAGID_SCENE_TYPE CONSTRUCT_TAGID(SCENE_TYPE, _ID_SCENE_TYPE)
-#define EXIFTAGTYPE_SCENE_TYPE EXIF_UNDEFINED
-// CFA pattern
-// Use EXIFTAGTYPE_CFA_PATTERN as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_CFA_PATTERN 0xa302
-#define EXIFTAGID_CFA_PATTERN CONSTRUCT_TAGID(CFA_PATTERN, _ID_CFA_PATTERN)
-#define EXIFTAGTYPE_CFA_PATTERN EXIF_UNDEFINED
-// Custom image processing
-// Use EXIFTAGTYPE_CUSTOM_RENDERED as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_CUSTOM_RENDERED 0xa401
-#define EXIFTAGID_CUSTOM_RENDERED CONSTRUCT_TAGID(CUSTOM_RENDERED, _ID_CUSTOM_RENDERED)
-#define EXIFTAGTYPE_CUSTOM_RENDERED EXIF_SHORT
-// Exposure mode
-// Use EXIFTAGTYPE_EXPOSURE_MODE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_EXPOSURE_MODE 0xa402
-#define EXIFTAGID_EXPOSURE_MODE CONSTRUCT_TAGID(EXPOSURE_MODE, _ID_EXPOSURE_MODE)
-#define EXIFTAGTYPE_EXPOSURE_MODE EXIF_SHORT
-// White balance
-// Use EXIFTAGTYPE_WHITE_BALANCE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_WHITE_BALANCE 0xa403
-#define EXIFTAGID_WHITE_BALANCE CONSTRUCT_TAGID(WHITE_BALANCE, _ID_WHITE_BALANCE)
-#define EXIFTAGTYPE_WHITE_BALANCE EXIF_SHORT
-// Digital zoom ratio
-// Use EXIFTAGTYPE_DIGITAL_ZOOM_RATIO as the exif_tag_type (EXIF_RATIONAL)
-// Count should be 1
-#define _ID_DIGITAL_ZOOM_RATIO 0xa404
-#define EXIFTAGID_DIGITAL_ZOOM_RATIO CONSTRUCT_TAGID(DIGITAL_ZOOM_RATIO, _ID_DIGITAL_ZOOM_RATIO)
-#define EXIFTAGTYPE_DIGITAL_ZOOM_RATIO EXIF_RATIONAL
-// Focal length in 35mm film
-// Use EXIFTAGTYPE_FOCAL_LENGTH_35MM as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_FOCAL_LENGTH_35MM 0xa405
-#define EXIFTAGID_FOCAL_LENGTH_35MM CONSTRUCT_TAGID(FOCAL_LENGTH_35MM, _ID_FOCAL_LENGTH_35MM)
-#define EXIFTAGTYPE_FOCAL_LENGTH_35MM EXIF_SHORT
-// Scene capture type
-// Use EXIFTAGTYPE_SCENE_CAPTURE_TYPE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SCENE_CAPTURE_TYPE 0xa406
-#define EXIFTAGID_SCENE_CAPTURE_TYPE CONSTRUCT_TAGID(SCENE_CAPTURE_TYPE, _ID_SCENE_CAPTURE_TYPE)
-#define EXIFTAGTYPE_SCENE_CAPTURE_TYPE EXIF_SHORT
-// Gain control
-// Use EXIFTAGTYPE_GAIN_CONTROL as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_GAIN_CONTROL 0xa407
-#define EXIFTAGID_GAIN_CONTROL CONSTRUCT_TAGID(GAIN_CONTROL, _ID_GAIN_CONTROL)
-#define EXIFTAGTYPE_GAIN_CONTROL EXIF_SHORT
-// Contrast
-// Use EXIFTAGTYPE_CONTRAST as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_CONTRAST 0xa408
-#define EXIFTAGID_CONTRAST CONSTRUCT_TAGID(CONTRAST, _ID_CONTRAST)
-#define EXIFTAGTYPE_CONTRAST EXIF_SHORT
-// Saturation
-// Use EXIFTAGTYPE_SATURATION as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SATURATION 0xa409
-#define EXIFTAGID_SATURATION CONSTRUCT_TAGID(SATURATION, _ID_SATURATION)
-#define EXIFTAGTYPE_SATURATION EXIF_SHORT
-// Sharpness
-// Use EXIFTAGTYPE_SHARPNESS as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SHARPNESS 0xa40a
-#define EXIFTAGID_SHARPNESS CONSTRUCT_TAGID(SHARPNESS, _ID_SHARPNESS)
-#define EXIFTAGTYPE_SHARPNESS EXIF_SHORT
-// Device settings description
-// Use EXIFTAGID_DEVICE_SETTINGS_DESCRIPTION as exif_tag_type (EXIF_UNDEFINED)
-// Count could be any
-#define _ID_DEVICE_SETTINGS_DESCRIPTION 0xa40b
-#define EXIFTAGID_DEVICE_SETTINGS_DESCRIPTION CONSTRUCT_TAGID(DEVICE_SETTINGS_DESCRIPTION, _ID_DEVICE_SETTINGS_DESCRIPTION)
-#define EXIFTAGTYPE_DEVIC_SETTIGNS_DESCRIPTION EXIF_UNDEFINED
-// Subject distance range
-// Use EXIFTAGTYPE_SUBJECT_DISTANCE_RANGE as the exif_tag_type (EXIF_SHORT)
-// Count should be 1
-#define _ID_SUBJECT_DISTANCE_RANGE 0xa40c
-#define EXIFTAGID_SUBJECT_DISTANCE_RANGE CONSTRUCT_TAGID(SUBJECT_DISTANCE_RANGE, _ID_SUBJECT_DISTANCE_RANGE)
-#define EXIFTAGTYPE_SUBJECT_DISTANCE_RANGE EXIF_SHORT
-// Unique image id
-// Use EXIFTAG_TYPE_IMAGE_UIDas the exif_tag_type (EXIF_ASCII)
-// Count should be 33
-#define _ID_IMAGE_UID 0xa420
-#define EXIFTAGID_IMAGE_UID CONSTRUCT_TAGID(IMAGE_UID, _ID_IMAGE_UID)
-#define EXIFTAGTYPE_IMAGE_UID EXIF_ASCII
-// PIM tag
-// Use EXIFTAGTYPE_PIM_TAG as the exif_tag_type (EXIF_UNDEFINED)
-// Count can be any
-#define _ID_PIM 0xc4a5
-#define EXIFTAGID_PIM_TAG CONSTRUCT_TAGID(PIM, _ID_PIM)
-#define EXIFTAGTYPE_PIM_TAG EXIF_UNDEFINED
-
-#endif /* __QCAMERA_INTF_H__ */
diff --git a/camera/QCamera/HAL2/core/src/QCameraHAL.cpp b/camera/QCamera/HAL2/core/src/QCameraHAL.cpp
deleted file mode 100644
index 2264bcd..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraHAL.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
-** Copyright (c) 2011 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QCameraHAL"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-
-
-/* include QCamera Hardware Interface Header*/
-#include "QCameraHAL.h"
-
-int HAL_numOfCameras = 0;
-mm_camera_info_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS];
-camera_metadata_t *HAL_staticInfo[MSM_MAX_CAMERA_SENSORS];
-
-namespace android {
-/* HAL function implementation goes here*/
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-extern "C" int HAL_getNumberOfCameras()
-{
- /* try to query every time we get the call!*/
- uint8_t num_camera = 0;
- mm_camera_info_t * handle_base = 0;
- ALOGV("%s: E", __func__);
-
- handle_base= camera_query(&num_camera);
-
- if (!handle_base) {
- HAL_numOfCameras = 0;
- }
- else
- {
- camera_info_t* p_camera_info = NULL;
- HAL_numOfCameras=num_camera;
-
- ALOGI("Handle base =0x%p",handle_base);
- ALOGI("getCameraInfo: numOfCameras = %d", HAL_numOfCameras);
- for(int i = 0; i < HAL_numOfCameras; i++) {
- ALOGI("Handle [%d]=0x%p",i,handle_base+i);
- HAL_camerahandle[i]=handle_base + i;
- p_camera_info = &(HAL_camerahandle[i]->camera_info);
- if (p_camera_info) {
- ALOGI("Camera sensor %d info:", i);
- ALOGI("camera_id: %d", p_camera_info->camera_id);
- ALOGI("modes_supported: %x", p_camera_info->modes_supported);
- ALOGI("position: %d", p_camera_info->position);
- ALOGI("sensor_mount_angle: %d", p_camera_info->sensor_mount_angle);
- }
- }
- }
-
- ALOGV("%s: X", __func__);
-
- return HAL_numOfCameras;
-}
-
-extern "C" int HAL_getCameraInfo(int cameraId, struct camera_info* cameraInfo)
-{
- mm_camera_info_t *mm_camer_obj = 0;
- ALOGV("%s: E", __func__);
- mm_camera_vtbl_t *p_camera_vtbl=NULL;
- status_t ret;
-
- if (!HAL_numOfCameras || HAL_numOfCameras < cameraId || !cameraInfo)
- return INVALID_OPERATION;
- else
- mm_camer_obj = HAL_camerahandle[cameraId];
-
- if (!mm_camer_obj)
- return INVALID_OPERATION;
- else {
- cameraInfo->facing =
- (FRONT_CAMERA == mm_camer_obj->camera_info.position)?
- CAMERA_FACING_FRONT : CAMERA_FACING_BACK;
-
- cameraInfo->orientation = mm_camer_obj->camera_info.sensor_mount_angle;
- }
-
- if (HAL_staticInfo[cameraId])
- goto end;
-
- /*
- * We need to open the camera in order to get the full list of static properties
- * required in the Google Camera API 2.0
- */
- p_camera_vtbl=camera_open(cameraId, NULL);
-
- if(p_camera_vtbl == NULL) {
- ALOGE("%s:camera_open failed",__func__);
- return INVALID_OPERATION;
- }
- p_camera_vtbl->ops->sync(p_camera_vtbl->camera_handle);
-
- ret = getStaticInfo(&HAL_staticInfo[cameraId], p_camera_vtbl, true);
- if (ret != OK) {
- ALOGE("%s: Unable to allocate static info: %s (%d)",
- __FUNCTION__, strerror(-ret), ret);
- return ret;
- }
- ret = getStaticInfo(&HAL_staticInfo[cameraId], p_camera_vtbl, false);
- if (ret != OK) {
- ALOGE("%s: Unable to fill in static info: %s (%d)",
- __FUNCTION__, strerror(-ret), ret);
- return ret;
- }
- p_camera_vtbl->ops->camera_close(p_camera_vtbl->camera_handle);
-
-end:
- cameraInfo->device_version = HARDWARE_DEVICE_API_VERSION(2, 0);
- cameraInfo->static_camera_characteristics =
- HAL_staticInfo[cameraId];
-
- ALOGV("%s: X", __func__);
- return OK;
-}
-
-}; // namespace android
diff --git a/camera/QCamera/HAL2/core/src/QCameraHWI.cpp b/camera/QCamera/HAL2/core/src/QCameraHWI.cpp
deleted file mode 100644
index 8b3114e..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraHWI.cpp
+++ /dev/null
@@ -1,492 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define LOG_NIDEBUG 0
-//#define LOG_NDEBUG 0
-
-#define LOG_TAG "QCameraHWI"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-
-/* QCameraHardwareInterface class implementation goes here*/
-/* following code implement the contol logic of this class*/
-
-namespace android {
-
-extern void stream_cb_routine(mm_camera_super_buf_t *bufs,
- void *userdata);
-extern void superbuf_cb_routine(mm_camera_super_buf_t *bufs,
- void *userdata);
-
-
-/*Command Thread startup function*/
-
-void *command_thread(void *obj)
-{
- QCameraHardwareInterface *pme = (QCameraHardwareInterface *)obj;
- ALOGD("%s: E", __func__);
- if (pme != NULL) {
- pme->runCommandThread(obj);
- }
- else ALOGW("not starting command thread: the object went away!");
- ALOGD("%s: X", __func__);
- return NULL;
-}
-
-int QCameraHardwareInterface::tryRestartStreams(
- camera_metadata_entry_t& streams)
-{
- int rc = 0;
- bool needRestart = false;
- bool needRecordingHint = false;
-
- for (uint32_t i = 0; i < streams.count; i++) {
- int streamId = streams.data.u8[i];
- QCameraStream *stream = QCameraStream::getStreamAtId(streamId);
- if (!stream->mInit) {
- needRestart = true;
- if (stream->mFormat == CAMERA_YUV_420_NV12)
- needRecordingHint = true;
- }
- }
-
- if (!needRestart)
- goto end;
-
- QCameraStream::streamOffAll();
-
- if (needRecordingHint) {
- uint32_t recordingHint = 1;
- rc = mCameraHandle->ops->set_parm(mCameraHandle->camera_handle,
- MM_CAMERA_PARM_RECORDING_HINT, &recordingHint);
- if (rc < 0) {
- ALOGE("set_parm MM_CAMERA_PARM_RECORDING_HINT returns %d", rc);
- return rc;
- }
- }
-
-end:
- for (uint32_t i = 0; i < streams.count; i++) {
- int streamId = streams.data.u8[i];
- QCameraStream *stream = QCameraStream::getStreamAtId(streamId);
- if (!stream->mInit) {
- rc = stream->prepareStream();
- if (rc < 0) {
- ALOGE("prepareStream for stream %d failed %d", streamId, rc);
- return rc;
- }
- }
- }
- for (uint32_t i = 0; i < streams.count; i++) {
- int streamId = streams.data.u8[i];
- QCameraStream *stream = QCameraStream::getStreamAtId(streamId);
-
- if (!stream->mActive) {
- rc = stream->streamOn();
- if (rc < 0) {
- ALOGE("streamOn for stream %d failed %d", streamId, rc);
- return rc;
- }
- }
- }
- return rc;
-}
-
-void QCameraHardwareInterface::runCommandThread(void *data)
-{
-
- /**
- * This function implements the main service routine for the incoming
- * frame requests, this thread routine is started everytime we get a
- * notify_request_queue_not_empty trigger, this thread makes the
- * assumption that once it receives a NULL on a dequest_request call
- * there will be a fresh notify_request_queue_not_empty call that is
- * invoked thereby launching a new instance of this thread. Therefore,
- * once we get a NULL on a dequeue request we simply let this thread die
- */
- int res;
- camera_metadata_t *request=NULL;
- mPendingRequests=0;
-
- while(mRequestQueueSrc) {
- ALOGV("%s:Dequeue request using mRequestQueueSrc:%p",__func__,mRequestQueueSrc);
- mRequestQueueSrc->dequeue_request(mRequestQueueSrc,&request);
- if(request==NULL) {
- ALOGE("%s:No more requests available from src command \
- thread dying",__func__);
- return;
- }
- mPendingRequests++;
-
- /* Set the metadata values */
-
- /* Wait for the SOF for the new metadata values to be applied */
-
- /* Check the streams that need to be active in the stream request */
- sort_camera_metadata(request);
-
- camera_metadata_entry_t streams;
- res = find_camera_metadata_entry(request,
- ANDROID_REQUEST_OUTPUT_STREAMS,
- &streams);
- if (res != NO_ERROR) {
- ALOGE("%s: error reading output stream tag", __FUNCTION__);
- return;
- }
-
- res = tryRestartStreams(streams);
- if (res != NO_ERROR) {
- ALOGE("error tryRestartStreams %d", res);
- return;
- }
-
- /* 3rd pass: Turn on all streams requested */
- for (uint32_t i = 0; i < streams.count; i++) {
- int streamId = streams.data.u8[i];
- QCameraStream *stream = QCameraStream::getStreamAtId(streamId);
-
- /* Increment the frame pending count in each stream class */
-
- /* Assuming we will have the stream obj in had at this point may be
- * may be multiple objs in which case we loop through array of streams */
- stream->onNewRequest();
- }
- ALOGV("%s:Freeing request using mRequestQueueSrc:%p",__func__,mRequestQueueSrc);
- /* Free the request buffer */
- mRequestQueueSrc->free_request(mRequestQueueSrc,request);
- mPendingRequests--;
- ALOGV("%s:Completed request",__func__);
- }
-
- QCameraStream::streamOffAll();
-}
-
-/*Mem Hooks*/
-int32_t get_buffer_hook(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- QCameraHardwareInterface *pme=(QCameraHardwareInterface *)user_data;
- return pme->getBuf(camera_handle, ch_id, stream_id,
- user_data, frame_offset_info,
- num_bufs,initial_reg_flag,
- bufs);
-
-}
-
-int32_t put_buffer_hook(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs)
-{
- QCameraHardwareInterface *pme=(QCameraHardwareInterface *)user_data;
- return pme->putBuf(camera_handle, ch_id, stream_id,
- user_data, num_bufs, bufs);
-
-}
-
-int QCameraHardwareInterface::getBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t mm_stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- status_t ret=NO_ERROR;
- ALOGE("%s: E, stream_id = %d\n", __func__, mm_stream_id);
- QCameraStream_preview *stream = (QCameraStream_preview *)
- QCameraStream::getStreamAtMmId(mm_stream_id);
-
- ALOGE("%s: len:%d, y_off:%d, cbcr:%d num buffers: %d planes:%d streamid:%d",
- __func__,
- frame_offset_info->frame_len,
- frame_offset_info->mp[0].len,
- frame_offset_info->mp[1].len,
- num_bufs,frame_offset_info->num_planes,
- mm_stream_id);
- /*************Preiew Stream*****************/
- ALOGE("Interface requesting Preview Buffers");
- stream->mFrameOffsetInfo=*frame_offset_info;
- if(NO_ERROR!=stream->initBuffers()){
- return BAD_VALUE;
- }
- ALOGE("Debug : %s : initDisplayBuffers",__func__);
- for(int i=0;i<num_bufs;i++) {
- bufs[i] = stream->mDisplayBuf[i];
- initial_reg_flag[i] =
- (stream->mPreviewMemory.local_flag[i] == BUFFER_OWNED);
- ALOGE("initial_reg_flag[%d]:%d",i,initial_reg_flag[i]);
- }
- return 0;
-}
-
-int QCameraHardwareInterface::putBuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t mm_stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs)
-{
- ALOGE("%s:E, stream_id = %d",__func__, mm_stream_id);
- QCameraStream_preview *stream = (QCameraStream_preview *)
- QCameraStream::getStreamAtMmId(mm_stream_id);
- stream->deinitBuffers();
- return 0;
-}
-
-
-QCameraHardwareInterface::
-QCameraHardwareInterface(int cameraId, int mode)
- : mCameraId(cameraId)
-{
-
- cam_ctrl_dimension_t mDimension;
-
- /* Open camera stack! */
- memset(&mMemHooks, 0, sizeof(mm_camear_mem_vtbl_t));
- mMemHooks.user_data=this;
- mMemHooks.get_buf=get_buffer_hook;
- mMemHooks.put_buf=put_buffer_hook;
-
- mCameraHandle=camera_open(mCameraId, &mMemHooks);
- ALOGV("Cam open returned %p",mCameraHandle);
- if(mCameraHandle == NULL) {
- ALOGE("startCamera: cam_ops_open failed: id = %d", mCameraId);
- return;
- }
- mCameraHandle->ops->sync(mCameraHandle->camera_handle);
-
- mChannelId=mCameraHandle->ops->ch_acquire(mCameraHandle->camera_handle);
- if(mChannelId<=0)
- {
- ALOGE("%s:Channel aquire failed",__func__);
- mCameraHandle->ops->camera_close(mCameraHandle->camera_handle);
- return;
- }
-
- /* Initialize # of frame requests the HAL is handling to zero*/
- mPendingRequests=0;
-}
-
-QCameraHardwareInterface::~QCameraHardwareInterface()
-{
- mCameraHandle->ops->camera_close(mCameraHandle->camera_handle);
-}
-
-void QCameraHardwareInterface::release()
-{
-}
-
-bool QCameraHardwareInterface::isCameraReady()
-{
- return true;
-}
-
-int QCameraHardwareInterface::set_request_queue_src_ops(
- const camera2_request_queue_src_ops_t *request_src_ops)
-{
- ALOGE("%s:E mRequestQueueSrc:%p",__func__,request_src_ops);
- mRequestQueueSrc = request_src_ops;
- ALOGE("%s:X",__func__);
- return 0;
-}
-
-int QCameraHardwareInterface::notify_request_queue_not_empty()
-{
-
- pthread_attr_t attr;
- if(pthread_attr_init(&attr)!=0) {
- ALOGE("%s:pthread_attr_init failed",__func__);
- return BAD_VALUE;
- }
- if(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)!=0){
- ALOGE("%s:pthread_attr_setdetachstate failed",__func__);
- return BAD_VALUE;
- }
- if(pthread_create(&mCommandThread,&attr,
- command_thread, (void *)this)!=0) {
- ALOGE("%s:pthread_create failed to launch command_thread",__func__);
- return BAD_VALUE;
- }
-
- return NO_ERROR;
-}
-
-int QCameraHardwareInterface::set_frame_queue_dst_ops(
- const camera2_frame_queue_dst_ops_t *frame_dst_ops)
-{
- mFrameQueueDst = frame_dst_ops;
- return OK;
-}
-
-int QCameraHardwareInterface::get_in_progress_count()
-{
- return mPendingRequests;
-}
-
-int QCameraHardwareInterface::construct_default_request(
- int request_template, camera_metadata_t **request)
-{
- status_t ret;
- ALOGD("%s:E:request_template:%d ",__func__,request_template);
-
- if (request == NULL)
- return BAD_VALUE;
- if (request_template < 0 || request_template >= CAMERA2_TEMPLATE_COUNT)
- return BAD_VALUE;
-
- ret = constructDefaultRequest(request_template, request, true);
- if (ret != OK) {
- ALOGE("%s: Unable to allocate default request: %s (%d)",
- __FUNCTION__, strerror(-ret), ret);
- return ret;
- }
- ret = constructDefaultRequest(request_template, request, false);
- if (ret != OK) {
- ALOGE("%s: Unable to fill in default request: %s (%d)",
- __FUNCTION__, strerror(-ret), ret);
- return ret;
- }
-
- ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO");
- mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO;
- ret = mCameraHandle->ops->set_parm(
- mCameraHandle->camera_handle,
- MM_CAMERA_PARM_OP_MODE,
- &op_mode);
- ALOGE("OP Mode Set");
-
- return ret;
-}
-
-int QCameraHardwareInterface::allocate_stream(
- uint32_t width,
- uint32_t height, int format,
- const camera2_stream_ops_t *stream_ops,
- uint32_t *stream_id,
- uint32_t *format_actual,
- uint32_t *usage,
- uint32_t *max_buffers)
-{
- int ret = OK;
- QCameraStream *stream = NULL;
- camera_mode_t myMode = (camera_mode_t)(CAMERA_MODE_2D|CAMERA_NONZSL_MODE);
- ALOGE("%s : BEGIN",__func__);
-
- ALOGE("Mymode Preview = %d",myMode);
- stream = QCameraStream_preview::createInstance(
- mCameraHandle->camera_handle,
- mChannelId,
- width,
- height,
- format,
- mCameraHandle,
- myMode);
- ALOGE("%s: createInstance done", __func__);
- if (!stream) {
- ALOGE("%s: error - can't creat preview stream!", __func__);
- return BAD_VALUE;
- }
-
- stream->setPreviewWindow(stream_ops);
- *stream_id = stream->getStreamId();
- *max_buffers= stream->getMaxBuffers();
- ALOGE("%s: stream_id = %d\n", __func__, *stream_id);
- *usage = GRALLOC_USAGE_HW_CAMERA_WRITE | CAMERA_GRALLOC_HEAP_ID
- | CAMERA_GRALLOC_FALLBACK_HEAP_ID;
- /* Set to an arbitrary format SUPPORTED by gralloc */
- //*format_actual = HAL_PIXEL_FORMAT_YCbCr_422_SP;
- *format_actual = HAL_PIXEL_FORMAT_YCrCb_420_SP;
- /*TODO: For hardware encoder, add CAMERA_GRALLOC_CACHING_ID */
- stream->setHALCameraControl(this);
-
- ALOGV("%s : END",__func__);
- return ret;
-}
-
-int QCameraHardwareInterface::register_stream_buffers(
- uint32_t stream_id, int num_buffers,
- buffer_handle_t *buffers)
-{
- struct private_handle_t *private_handle =
- (struct private_handle_t *)buffers[0];
- QCameraStream_preview *stream = (QCameraStream_preview *)
- QCameraStream::getStreamAtId(stream_id);
-
- if(!stream) {
- ALOGE("%s: Request for unknown stream",__func__);
- return BAD_VALUE;
- }
-
- if(NO_ERROR!=stream->registerStreamBuffers(num_buffers, buffers)) {
- ALOGE("%s:registerStreamBuffers failed",__func__);
- return BAD_VALUE;
- }
-
- return NO_ERROR;
-}
-
-int QCameraHardwareInterface::release_stream(uint32_t stream_id)
-{
- QCameraStream *stream = QCameraStream::getStreamAtId(stream_id);
-
- QCameraStream_preview::deleteInstance(stream);
-
- return OK;
-}
-
-int QCameraHardwareInterface::allocate_reprocess_stream(
- uint32_t width,
- uint32_t height,
- uint32_t format,
- const camera2_stream_in_ops_t *reprocess_stream_ops,
- uint32_t *stream_id,
- uint32_t *consumer_usage,
- uint32_t *max_buffers)
-{
- return INVALID_OPERATION;
-}
-
-int QCameraHardwareInterface::release_reprocess_stream(uint32_t stream_id)
-{
- return INVALID_OPERATION;
-}
-
-int QCameraHardwareInterface::get_metadata_vendor_tag_ops(vendor_tag_query_ops_t **ops)
-{
- *ops = NULL;
- return OK;
-}
-
-int QCameraHardwareInterface::set_notify_callback(camera2_notify_callback notify_cb,
- void *user)
-{
- mNotifyCb = notify_cb;
- mNotifyUserPtr = user;
- return OK;
-}
-}; // namespace android
diff --git a/camera/QCamera/HAL2/core/src/QCameraHWI_Metatags.cpp b/camera/QCamera/HAL2/core/src/QCameraHWI_Metatags.cpp
deleted file mode 100644
index 3d09228..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraHWI_Metatags.cpp
+++ /dev/null
@@ -1,746 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_NIDEBUG 0
-
-#define ALOG_TAG __FILE__
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <cutils/properties.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include <hardware/camera2.h>
-#include <mm_camera_interface.h>
-
-
-namespace android {
-
-
-const uint32_t QCAvailableFormats[4] = {
- HAL_PIXEL_FORMAT_RAW_SENSOR,
- HAL_PIXEL_FORMAT_BLOB,
- HAL_PIXEL_FORMAT_YV12,
- HAL_PIXEL_FORMAT_YCrCb_420_SP
-};
-
-const uint32_t QCAvailableRawSizes[2] = {
- 640, 480
-};
-
-
-const nsecs_t QCExposureTimeRange[2] =
- {1000L, 30000000000L} ; // 1 us - 30 sec
-const nsecs_t QCFrameDurationRange[2] =
- {33331760L, 30000000000L}; // ~1/30 s - 30 sec
-const nsecs_t QCMinVerticalBlank = 10000L;
-
-const uint8_t QCColorFilterArrangement = ANDROID_SENSOR_RGGB;
-
-// Output image data characteristics
-const uint32_t QCMaxRawValue = 4000;
-const uint32_t QCBlackLevel = 1000;
-
-const uint64_t QCAvailableRawMinDurations[1] = {
- QCFrameDurationRange[0]
-};
-
-const uint32_t QCAvailableProcessedSizes[4] = {
- 640, 480, 320, 240
- // Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-const uint64_t QCAvailableProcessedMinDurations[1] = {
- QCFrameDurationRange[0]
-};
-
-
-const uint32_t QCAvailableJpegSizes[2] = {
- 640, 480
- // Sensor::kResolution[0], Sensor::kResolution[1]
-};
-
-const uint64_t QCAvailableJpegMinDurations[1] = {
- QCFrameDurationRange[0]
-};
-
-static status_t addOrSize(camera_metadata_t *request,
- bool sizeRequest,
- size_t *entryCount,
- size_t *dataCount,
- uint32_t tag,
- const void *entryData,
- size_t entryDataCount) {
- status_t res;
- if (!sizeRequest) {
- return add_camera_metadata_entry(request, tag, entryData,
- entryDataCount);
- } else {
- int type = get_camera_metadata_tag_type(tag);
- if (type < 0 ) return BAD_VALUE;
- (*entryCount)++;
- (*dataCount) += calculate_camera_metadata_entry_data_size(type,
- entryDataCount);
- return OK;
- }
-}
-
-extern "C" status_t getStaticInfo(camera_metadata_t **info,
- mm_camera_vtbl_t *camera_vtbl, bool sizeRequest)
-{
- size_t entryCount = 0;
- size_t dataCount = 0;
- status_t ret;
-
- if(!camera_vtbl) return BAD_VALUE;
-
- bool mFacingBack = (camera_vtbl->camera_info->camera_info.position==BACK_CAMERA)?
- true:false;
-
-#define ADD_OR_SIZE( tag, data, count ) \
- if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \
- tag, data, count) ) != OK ) return ret
-
- // android.lens
-
- static float minFocusDistance = 0;
- ADD_OR_SIZE(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE,
- &minFocusDistance, 1);
- ADD_OR_SIZE(ANDROID_LENS_HYPERFOCAL_DISTANCE,
- &minFocusDistance, 1);
-
- static float focalLength = 0.0f;
- camera_vtbl->ops->get_parm(camera_vtbl->camera_handle,
- MM_CAMERA_PARM_FOCAL_LENGTH,
- (void *)&focalLength);
- ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS,
- &focalLength, 1);
-
- static float aperture = 2.8f;
- camera_vtbl->ops->get_parm(camera_vtbl->camera_handle,
- MM_CAMERA_PARM_APERTURE,
- (void *)&aperture);
- ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_APERTURES,
- &aperture, 1);
-
- static float filterDensity = 0;
- ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_FILTER_DENSITY,
- &filterDensity, 1);
-
- static const uint8_t availableOpticalStabilization =
- ANDROID_LENS_OPTICAL_STABILIZATION_OFF;
- ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_OPTICAL_STABILIZATION,
- &availableOpticalStabilization, 1);
-
- static const int32_t lensShadingMapSize[] = {1, 1};
- ADD_OR_SIZE(ANDROID_LENS_SHADING_MAP_SIZE, lensShadingMapSize,
- sizeof(lensShadingMapSize)/sizeof(int32_t));
-
- static const float lensShadingMap[3 * 1 * 1 ] =
- { 1.f, 1.f, 1.f };
- ADD_OR_SIZE(ANDROID_LENS_SHADING_MAP, lensShadingMap,
- sizeof(lensShadingMap)/sizeof(float));
-
- // Identity transform
- static const int32_t geometricCorrectionMapSize[] = {2, 2};
- ADD_OR_SIZE(ANDROID_LENS_GEOMETRIC_CORRECTION_MAP_SIZE,
- geometricCorrectionMapSize,
- sizeof(geometricCorrectionMapSize)/sizeof(int32_t));
-
- static const float geometricCorrectionMap[2 * 3 * 2 * 2] = {
- 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
- 1.f, 0.f, 1.f, 0.f, 1.f, 0.f,
- 0.f, 1.f, 0.f, 1.f, 0.f, 1.f,
- 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
- ADD_OR_SIZE(ANDROID_LENS_GEOMETRIC_CORRECTION_MAP,
- geometricCorrectionMap,
- sizeof(geometricCorrectionMap)/sizeof(float));
-
- int32_t lensFacing = mFacingBack ?
- ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT;
- ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1);
-
- float lensPosition[3];
- if (mFacingBack) {
- // Back-facing camera is center-top on device
- lensPosition[0] = 0;
- lensPosition[1] = 20;
- lensPosition[2] = -5;
- } else {
- // Front-facing camera is center-right on device
- lensPosition[0] = 20;
- lensPosition[1] = 20;
- lensPosition[2] = 0;
- }
- ADD_OR_SIZE(ANDROID_LENS_POSITION, lensPosition, sizeof(lensPosition)/
- sizeof(float));
-
-#if 0
- // android.sensor
-
- ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME_RANGE,
- QCExposureTimeRange, 2);
-
- ADD_OR_SIZE(ANDROID_SENSOR_MAX_FRAME_DURATION,
- &QCFrameDurationRange[1], 1);
-
- ADD_OR_SIZE(ANDROID_SENSOR_AVAILABLE_SENSITIVITIES,
- QCAvailableSensitivities,
- sizeof(QCAvailableSensitivities)
- /sizeof(uint32_t));
-
- ADD_OR_SIZE(ANDROID_SENSOR_COLOR_FILTER_ARRANGEMENT,
- &QCColorFilterArrangement, 1);
-#endif
- static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm
- ADD_OR_SIZE(ANDROID_SENSOR_PHYSICAL_SIZE,
- sensorPhysicalSize, 2);
-
- const unsigned int kResolution[2] = {640, 480};
- ADD_OR_SIZE(ANDROID_SENSOR_PIXEL_ARRAY_SIZE,
- kResolution, 2);
-
- ADD_OR_SIZE(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE,
- kResolution, 2);
-
-#if 0
- ADD_OR_SIZE(ANDROID_SENSOR_WHITE_LEVEL,
- &QCMaxRawValue, 1);
-
- static const int32_t blackLevelPattern[4] = {
- QCBlackLevel, QCBlackLevel,
- QCBlackLevel, QCBlackLevel
- };
- ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
- blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t));
-
-#endif
- //TODO: sensor color calibration fields
-
- // android.flash
- static const uint8_t flashAvailable = 0;
- ADD_OR_SIZE(ANDROID_FLASH_AVAILABLE, &flashAvailable, 1);
-
- static const int64_t flashChargeDuration = 0;
- ADD_OR_SIZE(ANDROID_FLASH_CHARGE_DURATION, &flashChargeDuration, 1);
-
- // android.tonemap
-
- static const int32_t tonemapCurvePoints = 128;
- ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
-
-#if 1
- // android.scaler
- ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS,
- QCAvailableFormats,
- sizeof(QCAvailableFormats)/sizeof(uint32_t));
-
- ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
- QCAvailableRawSizes,
- sizeof(QCAvailableRawSizes)/sizeof(uint32_t));
-
- ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
- QCAvailableRawMinDurations,
- sizeof(QCAvailableRawMinDurations)/sizeof(uint64_t));
-
- ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
- QCAvailableProcessedSizes,
- sizeof(QCAvailableProcessedSizes)/sizeof(uint32_t));
-
- ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
- QCAvailableProcessedMinDurations,
- sizeof(QCAvailableProcessedMinDurations)/sizeof(uint64_t));
-
- ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
- QCAvailableJpegSizes,
- sizeof(QCAvailableJpegSizes)/sizeof(uint32_t));
-
- ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
- QCAvailableJpegMinDurations,
- sizeof(QCAvailableJpegMinDurations)/sizeof(uint64_t));
-
- static const float maxZoom = 10;
- ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_ZOOM,
- &maxZoom, 1);
-
- // android.jpeg
-
- static const int32_t jpegThumbnailSizes[] = {
- 160, 120,
- 320, 240
- };
- ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
- jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t));
-
- static const int32_t jpegMaxSize = 300000;
- ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
-
- // android.stats
-
- static const uint8_t availableFaceDetectModes[] = {
- ANDROID_STATS_FACE_DETECTION_OFF
- };
- ADD_OR_SIZE(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES,
- availableFaceDetectModes,
- sizeof(availableFaceDetectModes));
-
- static const int32_t maxFaceCount = 0;
- ADD_OR_SIZE(ANDROID_STATS_MAX_FACE_COUNT,
- &maxFaceCount, 1);
-
- static const int32_t histogramSize = 64;
- ADD_OR_SIZE(ANDROID_STATS_HISTOGRAM_BUCKET_COUNT,
- &histogramSize, 1);
-
- static const int32_t maxHistogramCount = 1000;
- ADD_OR_SIZE(ANDROID_STATS_MAX_HISTOGRAM_COUNT,
- &maxHistogramCount, 1);
-
- static const int32_t sharpnessMapSize[2] = {64, 64};
- ADD_OR_SIZE(ANDROID_STATS_SHARPNESS_MAP_SIZE,
- sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t));
-
- static const int32_t maxSharpnessMapValue = 1000;
- ADD_OR_SIZE(ANDROID_STATS_MAX_SHARPNESS_MAP_VALUE,
- &maxSharpnessMapValue, 1);
-
- // android.control
-
- static const uint8_t availableSceneModes[] = {
- ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
- availableSceneModes, sizeof(availableSceneModes));
-
- static const uint8_t availableEffects[] = {
- ANDROID_CONTROL_EFFECT_OFF
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS,
- availableEffects, sizeof(availableEffects));
-
- int32_t max3aRegions = 0;
- ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS,
- &max3aRegions, 1);
-
- static const uint8_t availableAeModes[] = {
- ANDROID_CONTROL_AE_OFF,
- ANDROID_CONTROL_AE_ON
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES,
- availableAeModes, sizeof(availableAeModes));
-
- static const camera_metadata_rational exposureCompensationStep = {
- 1, 3
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP,
- &exposureCompensationStep, 1);
-
- int32_t exposureCompensationRange[] = {-9, 9};
- ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE,
- exposureCompensationRange,
- sizeof(exposureCompensationRange)/sizeof(int32_t));
-
- static const int32_t availableTargetFpsRanges[] = {
- 5, 30, 15, 30
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
- availableTargetFpsRanges,
- sizeof(availableTargetFpsRanges)/sizeof(int32_t));
-
- static const uint8_t availableAntibandingModes[] = {
- ANDROID_CONTROL_AE_ANTIBANDING_OFF,
- ANDROID_CONTROL_AE_ANTIBANDING_AUTO
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
- availableAntibandingModes, sizeof(availableAntibandingModes));
-
- static const uint8_t availableAwbModes[] = {
- ANDROID_CONTROL_AWB_OFF,
- ANDROID_CONTROL_AWB_AUTO,
- ANDROID_CONTROL_AWB_INCANDESCENT,
- ANDROID_CONTROL_AWB_FLUORESCENT,
- ANDROID_CONTROL_AWB_DAYLIGHT,
- ANDROID_CONTROL_AWB_SHADE
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
- availableAwbModes, sizeof(availableAwbModes));
-
- static const uint8_t availableAfModes[] = {
- ANDROID_CONTROL_AF_OFF
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES,
- availableAfModes, sizeof(availableAfModes));
-
- static const uint8_t availableVstabModes[] = {
- ANDROID_CONTROL_VIDEO_STABILIZATION_OFF
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
- availableVstabModes, sizeof(availableVstabModes));
-#endif
-#undef ADD_OR_SIZE
- /** Allocate metadata if sizing */
- if (sizeRequest) {
- ALOGV("Allocating %d entries, %d extra bytes for "
- "static camera info",
- entryCount, dataCount);
- *info = allocate_camera_metadata(entryCount, dataCount);
- if (*info == NULL) {
- ALOGE("Unable to allocate camera static info"
- "(%d entries, %d bytes extra data)",
- entryCount, dataCount);
- return NO_MEMORY;
- }
- }
- return OK;
-}
-
-extern "C" status_t constructDefaultRequest(int request_template,
- camera_metadata_t **request, bool sizeRequest)
-{
- size_t entryCount = 0;
- size_t dataCount = 0;
- status_t ret;
-
-#define ADD_OR_SIZE( tag, data, count ) \
- if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \
- tag, data, count) ) != OK ) return ret
-
- static const int64_t USEC = 1000LL;
- static const int64_t MSEC = USEC * 1000LL;
- static const int64_t SEC = MSEC * 1000LL;
-
- /** android.request */
-
- static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_NONE;
- ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1);
-
- static const int32_t id = 0;
- ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1);
-
- static const int32_t frameCount = 0;
- ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1);
-
- // OUTPUT_STREAMS set by user
- entryCount += 1;
- dataCount += 5; // TODO: Should be maximum stream number
-
- /** android.lens */
-
- static const float focusDistance = 0;
- ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
-
- static const float aperture = 2.8f;
- ADD_OR_SIZE(ANDROID_LENS_APERTURE, &aperture, 1);
-
- static const float focalLength = 5.0f;
- ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1);
-
- static const float filterDensity = 0;
- ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1);
-
- static const uint8_t opticalStabilizationMode =
- ANDROID_LENS_OPTICAL_STABILIZATION_OFF;
- ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
- &opticalStabilizationMode, 1);
-
- // FOCUS_RANGE set only in frame
-
- /** android.sensor */
-
- static const int64_t exposureTime = 10 * MSEC;
- ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1);
-
- static const int64_t frameDuration = 33333333L; // 1/30 s
- ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1);
-
- static const int32_t sensitivity = 100;
- ADD_OR_SIZE(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1);
-
- // TIMESTAMP set only in frame
-
- /** android.flash */
-
- static const uint8_t flashMode = ANDROID_FLASH_OFF;
- ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1);
-
- static const uint8_t flashPower = 10;
- ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1);
-
- static const int64_t firingTime = 0;
- ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1);
-
- /** Processing block modes */
- uint8_t hotPixelMode = 0;
- uint8_t demosaicMode = 0;
- uint8_t noiseMode = 0;
- uint8_t shadingMode = 0;
- uint8_t geometricMode = 0;
- uint8_t colorMode = 0;
- uint8_t tonemapMode = 0;
- uint8_t edgeMode = 0;
- switch (request_template) {
- case CAMERA2_TEMPLATE_PREVIEW:
- hotPixelMode = ANDROID_PROCESSING_FAST;
- demosaicMode = ANDROID_PROCESSING_FAST;
- noiseMode = ANDROID_PROCESSING_FAST;
- shadingMode = ANDROID_PROCESSING_FAST;
- geometricMode = ANDROID_PROCESSING_FAST;
- colorMode = ANDROID_PROCESSING_FAST;
- tonemapMode = ANDROID_PROCESSING_FAST;
- edgeMode = ANDROID_PROCESSING_FAST;
- break;
- case CAMERA2_TEMPLATE_STILL_CAPTURE:
- hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
- demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
- noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
- shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
- geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
- colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
- tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
- edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
- break;
- case CAMERA2_TEMPLATE_VIDEO_RECORD:
- hotPixelMode = ANDROID_PROCESSING_FAST;
- demosaicMode = ANDROID_PROCESSING_FAST;
- noiseMode = ANDROID_PROCESSING_FAST;
- shadingMode = ANDROID_PROCESSING_FAST;
- geometricMode = ANDROID_PROCESSING_FAST;
- colorMode = ANDROID_PROCESSING_FAST;
- tonemapMode = ANDROID_PROCESSING_FAST;
- edgeMode = ANDROID_PROCESSING_FAST;
- break;
- case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
- hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
- demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
- noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
- shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
- geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
- colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
- tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
- edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
- break;
- case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
- hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
- demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
- noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
- shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
- geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
- colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
- tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
- edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
- break;
- default:
- hotPixelMode = ANDROID_PROCESSING_FAST;
- demosaicMode = ANDROID_PROCESSING_FAST;
- noiseMode = ANDROID_PROCESSING_FAST;
- shadingMode = ANDROID_PROCESSING_FAST;
- geometricMode = ANDROID_PROCESSING_FAST;
- colorMode = ANDROID_PROCESSING_FAST;
- tonemapMode = ANDROID_PROCESSING_FAST;
- edgeMode = ANDROID_PROCESSING_FAST;
- break;
- }
- ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1);
- ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1);
- ADD_OR_SIZE(ANDROID_NOISE_MODE, &noiseMode, 1);
- ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1);
- ADD_OR_SIZE(ANDROID_GEOMETRIC_MODE, &geometricMode, 1);
- ADD_OR_SIZE(ANDROID_COLOR_MODE, &colorMode, 1);
- ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1);
- ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1);
-
- /** android.noise */
- static const uint8_t noiseStrength = 5;
- ADD_OR_SIZE(ANDROID_NOISE_STRENGTH, &noiseStrength, 1);
-
- /** android.color */
- static const float colorTransform[9] = {
- 1.0f, 0.f, 0.f,
- 0.f, 1.f, 0.f,
- 0.f, 0.f, 1.f
- };
- ADD_OR_SIZE(ANDROID_COLOR_TRANSFORM, colorTransform, 9);
-
- /** android.tonemap */
- static const float tonemapCurve[4] = {
- 0.f, 0.f,
- 1.f, 1.f
- };
- ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4);
- ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4);
- ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4);
-
- /** android.edge */
- static const uint8_t edgeStrength = 5;
- ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
-
- /** android.scaler */
- static const int32_t cropRegion[3] = {
- 0, 0, /*kResolution[0]*/
- };
- ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
-
- /** android.jpeg */
- static const int32_t jpegQuality = 80;
- ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1);
-
- static const int32_t thumbnailSize[2] = {
- 640, 480
- };
- ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2);
-
- static const int32_t thumbnailQuality = 80;
- ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1);
-
- static const double gpsCoordinates[2] = {
- 0, 0
- };
- ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2);
-
- static const uint8_t gpsProcessingMethod[32] = "None";
- ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32);
-
- static const int64_t gpsTimestamp = 0;
- ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1);
-
- static const int32_t jpegOrientation = 0;
- ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1);
-
- /** android.stats */
-
- static const uint8_t faceDetectMode = ANDROID_STATS_FACE_DETECTION_OFF;
- ADD_OR_SIZE(ANDROID_STATS_FACE_DETECT_MODE, &faceDetectMode, 1);
-
- static const uint8_t histogramMode = ANDROID_STATS_OFF;
- ADD_OR_SIZE(ANDROID_STATS_HISTOGRAM_MODE, &histogramMode, 1);
-
- static const uint8_t sharpnessMapMode = ANDROID_STATS_OFF;
- ADD_OR_SIZE(ANDROID_STATS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
-
- // faceRectangles, faceScores, faceLandmarks, faceIds, histogram,
- // sharpnessMap only in frames
-
- /** android.control */
-
- uint8_t controlIntent = 0;
- switch (request_template) {
- case CAMERA2_TEMPLATE_PREVIEW:
- controlIntent = ANDROID_CONTROL_INTENT_PREVIEW;
- break;
- case CAMERA2_TEMPLATE_STILL_CAPTURE:
- controlIntent = ANDROID_CONTROL_INTENT_STILL_CAPTURE;
- break;
- case CAMERA2_TEMPLATE_VIDEO_RECORD:
- controlIntent = ANDROID_CONTROL_INTENT_VIDEO_RECORD;
- break;
- case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
- controlIntent = ANDROID_CONTROL_INTENT_VIDEO_SNAPSHOT;
- break;
- case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
- controlIntent = ANDROID_CONTROL_INTENT_ZERO_SHUTTER_LAG;
- break;
- default:
- controlIntent = ANDROID_CONTROL_INTENT_CUSTOM;
- break;
- }
- ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
-
- static const uint8_t controlMode = ANDROID_CONTROL_AUTO;
- ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1);
-
- static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_OFF;
- ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
-
- static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;
- ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
-
- static const uint8_t aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH;
- ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
-
- const unsigned int kResolution[2] = {640, 480};
- static const int32_t controlRegions[5] = {
- 0, 0, kResolution[0], kResolution[1], 1000
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
-
- static const int32_t aeExpCompensation = 0;
- ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION, &aeExpCompensation, 1);
-
- static const int32_t aeTargetFpsRange[2] = {
- 10, 30
- };
- ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2);
-
- static const uint8_t aeAntibandingMode =
- ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
- ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1);
-
- static const uint8_t awbMode =
- ANDROID_CONTROL_AWB_AUTO;
- ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
-
- ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5);
-
- uint8_t afMode = 0;
- switch (request_template) {
- case CAMERA2_TEMPLATE_PREVIEW:
- afMode = ANDROID_CONTROL_AF_AUTO;
- break;
- case CAMERA2_TEMPLATE_STILL_CAPTURE:
- afMode = ANDROID_CONTROL_AF_AUTO;
- break;
- case CAMERA2_TEMPLATE_VIDEO_RECORD:
- afMode = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO;
- break;
- case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
- afMode = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO;
- break;
- case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
- afMode = ANDROID_CONTROL_AF_CONTINUOUS_PICTURE;
- break;
- default:
- afMode = ANDROID_CONTROL_AF_AUTO;
- break;
- }
- ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1);
-
- ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5);
-
- static const uint8_t vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
- ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1);
-
- // aeState, awbState, afState only in frame
-
- /** Allocate metadata if sizing */
- if (sizeRequest) {
- ALOGV("Allocating %d entries, %d extra bytes for "
- "request template type %d",
- entryCount, dataCount, request_template);
- *request = allocate_camera_metadata(entryCount, dataCount);
- if (*request == NULL) {
- ALOGE("Unable to allocate new request template type %d "
- "(%d entries, %d bytes extra data)", request_template,
- entryCount, dataCount);
- return NO_MEMORY;
- }
- }
- return OK;
-#undef ADD_OR_SIZE
-}
-
-};
diff --git a/camera/QCamera/HAL2/core/src/QCameraStream.cpp b/camera/QCamera/HAL2/core/src/QCameraStream.cpp
deleted file mode 100644
index 73e57ce..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraStream.cpp
+++ /dev/null
@@ -1,466 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG __FILE__
-#include <utils/Log.h>
-#include <utils/threads.h>
-
-#include "QCameraHWI.h"
-#include "QCameraStream.h"
-
-/* QCameraStream class implementation goes here*/
-/* following code implement the control logic of this class*/
-
-namespace android {
-
-StreamQueue::StreamQueue(){
- mInitialized = false;
-}
-
-StreamQueue::~StreamQueue(){
- flush();
-}
-
-void StreamQueue::init(){
- Mutex::Autolock l(&mQueueLock);
- mInitialized = true;
- mQueueWait.signal();
-}
-
-void StreamQueue::deinit(){
- Mutex::Autolock l(&mQueueLock);
- mInitialized = false;
- mQueueWait.signal();
-}
-
-bool StreamQueue::isInitialized(){
- Mutex::Autolock l(&mQueueLock);
- return mInitialized;
-}
-
-bool StreamQueue::enqueue(
- void * element){
- Mutex::Autolock l(&mQueueLock);
- if(mInitialized == false)
- return false;
-
- mContainer.add(element);
- mQueueWait.signal();
- return true;
-}
-
-bool StreamQueue::isEmpty(){
- return (mInitialized && mContainer.isEmpty());
-}
-void* StreamQueue::dequeue(){
-
- void *frame;
- mQueueLock.lock();
- while(mInitialized && mContainer.isEmpty()){
- mQueueWait.wait(mQueueLock);
- }
-
- if(!mInitialized){
- mQueueLock.unlock();
- return NULL;
- }
-
- frame = mContainer.itemAt(0);
- mContainer.removeAt(0);
- mQueueLock.unlock();
- return frame;
-}
-
-void StreamQueue::flush(){
- Mutex::Autolock l(&mQueueLock);
- mContainer.clear();
-}
-
-
-// ---------------------------------------------------------------------------
-// QCameraStream
-// ---------------------------------------------------------------------------
-
-void superbuf_cb_routine(mm_camera_super_buf_t *bufs,
- void *userdata)
-{
- QCameraHardwareInterface *p_obj=(QCameraHardwareInterface*) userdata;
- ALOGE("%s: E",__func__);
-
- //Implement call to JPEG routine in Snapshot here
- if(bufs->bufs[0]->stream_id == p_obj->mStreamSnapMain->mMmStreamId){
- ALOGE("%s : jpeg callback for MM_CAMERA_SNAPSHOT_MAIN", __func__);
- p_obj->mStreamSnapMain->receiveRawPicture(bufs);
- }
-
-
- for(int i=0;i<bufs->num_bufs;i++) {
-
- p_obj->mCameraHandle->ops->qbuf(p_obj->mCameraHandle->camera_handle,
- p_obj->mChannelId,
- bufs->bufs[i]);
-
- }
-
-
-}
-
-void stream_cb_routine(mm_camera_super_buf_t *bufs,
- void *userdata)
-{
- ALOGE("%s E ", __func__);
- QCameraStream *p_obj=(QCameraStream*) userdata;
- ALOGE("DEBUG4:ExtMode:%d,streamid:%d",p_obj->mExtImgMode,bufs->bufs[0]->stream_id);
- switch(p_obj->mExtImgMode) {
- case MM_CAMERA_PREVIEW:
- ALOGE("%s : callback for MM_CAMERA_PREVIEW", __func__);
- ((QCameraStream_preview *)p_obj)->dataCallback(bufs);
- break;
- case MM_CAMERA_VIDEO:
- ALOGE("%s : callback for MM_CAMERA_VIDEO", __func__);
- ((QCameraStream_preview *)p_obj)->dataCallback(bufs);
- break;
- case MM_CAMERA_SNAPSHOT_MAIN:
-#if 0
- if(p_obj->mHalCamCtrl->getHDRMode()) {
- ALOGE("%s: Skipping Q Buf for HDR mode",__func__);
- break;
- }
-#endif
-
- ALOGE("%s : callback for MM_CAMERA_SNAPSHOT_MAIN", __func__);
- p_obj->p_mm_ops->ops->qbuf(p_obj->mCameraHandle,
- p_obj->mChannelId,
- bufs->bufs[0]);
- break;
- case MM_CAMERA_SNAPSHOT_THUMBNAIL:
- break;
- default:
- break;
-
- }
- ALOGE("%s X ", __func__);
-}
-
-QCameraStream *QCameraStream::mStreamTable[STREAM_TABLE_SIZE];
-
-void QCameraStream::dataCallback(mm_camera_super_buf_t *bufs)
-{
- if(mPendingCount!=0) {
- ALOGD("Got frame request");
- pthread_mutex_lock(&mFrameDeliveredMutex);
- mPendingCount--;
- ALOGD("Completed frame request");
- pthread_cond_signal(&mFrameDeliveredCond);
- pthread_mutex_unlock(&mFrameDeliveredMutex);
- processPreviewFrame(bufs);
- } else {
- p_mm_ops->ops->qbuf(mCameraHandle,
- mChannelId, bufs->bufs[0]);
- }
-}
-
-void QCameraStream::onNewRequest()
-{
- ALOGI("%s:E",__func__);
- pthread_mutex_lock(&mFrameDeliveredMutex);
- ALOGI("Sending Frame request");
- mPendingCount++;
- pthread_cond_wait(&mFrameDeliveredCond,&mFrameDeliveredMutex);
- ALOGV("Got frame");
- pthread_mutex_unlock(&mFrameDeliveredMutex);
- ALOGV("%s:X",__func__);
-}
-
-int32_t QCameraStream::streamOn()
-{
- status_t rc=NO_ERROR;
- mm_camera_stream_config_t stream_config;
- ALOGE("%s:streamid:%d",__func__,mMmStreamId);
- Mutex::Autolock lock(mLock);
- if(mActive){
- ALOGE("%s: Stream:%d is already active",
- __func__,mMmStreamId);
- return rc;
- }
-
- if (mInit == true) {
- /* this is the restart case */
- memset(&stream_config, 0, sizeof(mm_camera_stream_config_t));
- stream_config.fmt.fmt=(cam_format_t)mFormat;
- stream_config.fmt.meta_header=MM_CAMEAR_META_DATA_TYPE_DEF;
- stream_config.fmt.width=mWidth;
- stream_config.fmt.height=mHeight;
- stream_config.fmt.rotation = 0;
- ALOGE("<DEBUG>::%s: Width :%d Height:%d Format:%d",__func__,mWidth,mHeight,mFormat);
- stream_config.num_of_bufs=mNumBuffers;
- stream_config.need_stream_on=true;
- rc=p_mm_ops->ops->config_stream(mCameraHandle,
- mChannelId,
- mMmStreamId,
- &stream_config);
- ALOGE("%s: config_stream, rc = %d", __func__, rc);
- }
-
- rc = p_mm_ops->ops->start_streams(mCameraHandle,
- mChannelId,
- 1,
- &mMmStreamId);
- if(rc==NO_ERROR)
- mActive = true;
- return rc;
-}
-
-int32_t QCameraStream::streamOff(bool isAsyncCmd)
-{
- status_t rc=NO_ERROR;
- Mutex::Autolock lock(mLock);
- if(!mActive) {
- ALOGE("%s: Stream:%d is not active",
- __func__,mMmStreamId);
- return rc;
- }
-
- rc = p_mm_ops->ops->stop_streams(mCameraHandle,
- mChannelId,
- 1,
- &mMmStreamId);
-
- mActive=false;
- return rc;
-
-}
-
-/* initialize a streaming channel*/
-status_t QCameraStream::initStream(mm_camera_img_mode imgmode,
- cam_format_t format)
-{
- int rc = MM_CAMERA_OK;
- status_t ret = NO_ERROR;
- mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO;
- cam_ctrl_dimension_t dim;
- int i;
- mm_camera_stream_config_t stream_config;
-
- ALOGE("QCameraStream::initStream : E");
-
- mFormat = format;
- /*TODO: Convert between TEMPLATE to img_mode */
- mExtImgMode = imgmode;
- /***********Allocate Stream**************/
-
- rc=p_mm_ops->ops->add_stream(mCameraHandle,
- mChannelId,
- stream_cb_routine,
- (void *)this,
- mExtImgMode,
- 0/*sensor_idx*/);
-
- if (rc < 0)
- goto error1;
-
- mMmStreamId=rc;
- ALOGE("%s: mMmStreamId = %d\n", __func__, mMmStreamId);
-
- memset(&stream_config, 0, sizeof(mm_camera_stream_config_t));
- stream_config.fmt.fmt=format;
- stream_config.fmt.meta_header=MM_CAMEAR_META_DATA_TYPE_DEF;
- stream_config.fmt.width=mWidth;
- stream_config.fmt.height=mHeight;
- ALOGE("<DEBUG>::%s: Width :%d Height:%d Format:%d",__func__,mWidth,mHeight,format);
- stream_config.num_of_bufs=mNumBuffers;
- stream_config.need_stream_on=true;
- rc=p_mm_ops->ops->config_stream(mCameraHandle,
- mChannelId,
- mMmStreamId,
- &stream_config);
- if(MM_CAMERA_OK != rc)
- goto error2;
-
- goto end;
-
-
-error2:
- ALOGE("%s: Error configuring stream",__func__);
- p_mm_ops->ops->del_stream(mCameraHandle,mChannelId,
- mMmStreamId);
-
-error1:
- return BAD_VALUE;
-end:
- ALOGE("Setting mInit to true");
- mInit=true;
- return NO_ERROR;
-
-}
-
-status_t QCameraStream::deinitStream()
-{
-
- int rc = MM_CAMERA_OK;
-
- ALOGI("%s: E, Stream = %d\n", __func__, mMmStreamId);
-
- rc= p_mm_ops->ops->del_stream(mCameraHandle,mChannelId,
- mMmStreamId);
-
- ALOGI("%s: X, Stream = %d\n", __func__, mMmStreamId);
- mInit=false;
- return NO_ERROR;
-}
-
-status_t QCameraStream::setMode(int enable) {
- ALOGE("%s :myMode %x ", __func__, myMode);
- if (enable) {
- myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE);
- } else {
- myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE);
- }
- return NO_ERROR;
-}
-
-status_t QCameraStream::setFormat()
-{
- ALOGE("%s: E",__func__);
-
- char mDeviceName[PROPERTY_VALUE_MAX];
- property_get("ro.product.device",mDeviceName," ");
-
- ALOGE("%s: X",__func__);
- return NO_ERROR;
-}
-
-QCameraStream::QCameraStream (){
- mInit = false;
- mActive = false;
- /* memset*/
- memset(&mCrop, 0, sizeof(mm_camera_rect_t));
-}
-
-QCameraStream::QCameraStream(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- mm_camera_vtbl_t *mm_ops,
- camera_mode_t mode)
- :myMode(mode)
-{
- mInit = false;
- mActive = false;
-
- mCameraHandle=CameraHandle;
- mChannelId=ChannelId;
- mWidth=Width;
- mHeight=Height;
- p_mm_ops=mm_ops;
-
- /* memset*/
- memset(&mCrop, 0, sizeof(mm_camera_rect_t));
-
- mPendingCount=0;
- pthread_mutex_init(&mFrameDeliveredMutex, NULL);
- pthread_cond_init(&mFrameDeliveredCond, NULL);
-}
-
-QCameraStream::~QCameraStream () {;}
-
-int QCameraStream::allocateStreamId() {
- int i = 0;
- for (i = 0; i < STREAM_TABLE_SIZE; i++)
- if (mStreamTable[i] == NULL) {
- mStreamTable[i] = this;
- break;
- }
- if (i == STREAM_TABLE_SIZE)
- return INVALID_OPERATION;
- ALOGE("%s: mStreamTable[%d] = %p\n", __func__, i, mStreamTable[i]);
- return i;
-}
-
-int QCameraStream::deallocateStreamId(int id) {
- if (id < 0 || id >= STREAM_TABLE_SIZE)
- return BAD_VALUE;
- mStreamTable[id] = NULL;
- return OK;
-}
-
-QCameraStream *QCameraStream::getStreamAtId(int id) {
- if (id < 0 || id >= STREAM_TABLE_SIZE)
- return NULL;
- else
- return mStreamTable[id];
-}
-
-QCameraStream *QCameraStream::getStreamAtMmId(uint32_t mm_id) {
- /*TODO: More efficient to do direct lookup. But it requires
- *mm-camera-interface to expose a macro for handle-index mapping*/
- for (int i = 0; i < STREAM_TABLE_SIZE; i++) {
- ALOGE("%s: %d: ", __func__, i);
- if (mStreamTable[i])
- ALOGE("%s: mMmStreamId = %d", __func__, mStreamTable[i]->mMmStreamId);
- if (mStreamTable[i] && (mStreamTable[i]->mMmStreamId == mm_id))
- return mStreamTable[i];
- }
- ALOGE("%s: Cannot find stream with interface id %d", __func__, mm_id);
- return NULL;
-}
-
-void QCameraStream::streamOffAll()
-{
- for (int i = 0; i < STREAM_TABLE_SIZE; i++) {
- if (mStreamTable[i]) {
- if (mStreamTable[i]->mActive) {
- ALOGI("%s: stream off stream[%d]", __func__, i);
- mStreamTable[i]->streamOff(0);
- ALOGI("%s: stream off stream[%d] done", __func__, i);
- }
- if (mStreamTable[i]->mInit) {
- ALOGI("%s: deinit stream[%d]", __func__, i);
- mStreamTable[i]->deinitStream();
- ALOGI("%s: deinit stream[%d] done", __func__, i);
- }
- }
- }
-}
-
-status_t QCameraStream::init() {
- return NO_ERROR;
-}
-
-status_t QCameraStream::start() {
- return NO_ERROR;
-}
-
-void QCameraStream::stop() {
- return;
-}
-
-void QCameraStream::release() {
- return;
-}
-
-void QCameraStream::setHALCameraControl(QCameraHardwareInterface* ctrl) {
-
- /* provide a frame data user,
- for the queue monitor thread to call the busy queue is not empty*/
- mHalCamCtrl = ctrl;
-}
-
-}; // namespace android
diff --git a/camera/QCamera/HAL2/core/src/QCameraStream_Preview.cpp b/camera/QCamera/HAL2/core/src/QCameraStream_Preview.cpp
deleted file mode 100644
index 54a95a6..0000000
--- a/camera/QCamera/HAL2/core/src/QCameraStream_Preview.cpp
+++ /dev/null
@@ -1,591 +0,0 @@
-/*
-** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
-**
-** 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.
-*/
-
-/*#error uncomment this for compiler test!*/
-
-#define ALOG_TAG "QCameraHWI_Preview"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include "QCameraHAL.h"
-#include "QCameraHWI.h"
-#include <genlock.h>
-#include <gralloc_priv.h>
-
-#define UNLIKELY(exp) __builtin_expect(!!(exp), 0)
-
-/* QCameraHWI_Preview class implementation goes here*/
-/* following code implement the preview mode's image capture & display logic of this class*/
-
-namespace android {
-
-status_t QCameraStream_preview::setPreviewWindow(const camera2_stream_ops_t* window)
-{
- status_t retVal = NO_ERROR;
- ALOGE(" %s: E ", __FUNCTION__);
- if( window == NULL) {
- ALOGW(" Setting NULL preview window ");
- /* TODO: Current preview window will be invalidated.
- * Release all the buffers back */
- // relinquishBuffers();
- }
- Mutex::Autolock lock(mLock);
- mPreviewWindow = window;
- ALOGV(" %s : X ", __FUNCTION__ );
- return retVal;
-}
-
-int QCameraStream_preview::registerStreamBuffers(int num_buffers,
- buffer_handle_t *buffers)
-{
- int err;
-
- mNumBuffers = num_buffers;
- mPreviewMemory.buffer_count = num_buffers;
- for (int i = 0; i < num_buffers; i++) {
- mPreviewMemory.buffer_handle[i] = buffers[i];
- mPreviewMemory.private_buffer_handle[i] = (struct private_handle_t *)buffers[i];
- ALOGD("%s:Buffer Size:%d",__func__, mPreviewMemory.private_buffer_handle[i]->size);
- }
- mDisplayBuf = new mm_camera_buf_def_t[num_buffers];
- if (!mDisplayBuf) {
- ALOGE("Unable to allocate mDisplayBuf");
- return NO_MEMORY;
- }
-
- return OK;
-}
-
-status_t QCameraStream_preview::initBuffers()
-{
- status_t ret = NO_ERROR;
- int width = mWidth; /* width of channel */
- int height = mHeight; /* height of channel */
- uint32_t frame_len = mFrameOffsetInfo.frame_len; /* frame planner length */
- int buffer_num = mNumBuffers; /* number of buffers for display */
- const char *pmem_region;
- uint8_t num_planes = mFrameOffsetInfo.num_planes;
- uint32_t planes[VIDEO_MAX_PLANES];
- void *vaddr = NULL;
- buffer_handle_t *buffer_handle;
-
- ALOGE("%s:BEGIN",__func__);
- memset(mNotifyBuffer, 0, sizeof(mNotifyBuffer));
-
- this->myMode=myMode; /*Need to assign this in constructor after translating from mask*/
- num_planes = mFrameOffsetInfo.num_planes;
- for(int i=0; i < num_planes; i++)
- planes[i] = mFrameOffsetInfo.mp[i].len;
-
-
- mPreviewMemoryLock.lock();
- memset(mDisplayBuf, 0, sizeof(mm_camera_buf_def_t) * mNumBuffers);
-
- /*allocate memory for the buffers*/
- for(int i = 0; i < mNumBuffers; i++){
- mDisplayBuf[i].num_planes = num_planes;
- mDisplayBuf[i].buf_idx = i;
-
- /* Plane 0 needs to be set seperately. Set other planes
- * in a loop. */
- mDisplayBuf[i].planes[0].length = planes[0];
- mDisplayBuf[i].planes[0].m.userptr = mPreviewMemory.private_buffer_handle[i]->fd;
- mDisplayBuf[i].planes[0].data_offset = mFrameOffsetInfo.mp[0].offset;
- mDisplayBuf[i].planes[0].reserved[0] =0;
- for (int j = 1; j < num_planes; j++) {
- mDisplayBuf[i].planes[j].length = planes[j];
- mDisplayBuf[i].planes[j].m.userptr = mPreviewMemory.private_buffer_handle[i]->fd;
- mDisplayBuf[i].planes[j].data_offset = mFrameOffsetInfo.mp[j].offset;
- mDisplayBuf[i].planes[j].reserved[0] =
- mDisplayBuf[i].planes[j-1].reserved[0] +
- mDisplayBuf[i].planes[j-1].length;
- }
-
- for (int j = 0; j < num_planes; j++)
- ALOGE("Planes: %d length: %d userptr: %lu offset: %d\n", j,
- mDisplayBuf[i].planes[j].length,
- mDisplayBuf[i].planes[j].m.userptr,
- mDisplayBuf[i].planes[j].reserved[0]);
-
- mDisplayBuf[i].stream_id = mMmStreamId;
- mDisplayBuf[i].fd = mPreviewMemory.private_buffer_handle[i]->fd;
- ALOGE("DEBUG2:Display buf[%d] fd:%d",i,mDisplayBuf[i].fd);
- mDisplayBuf[i].frame_len = mFrameOffsetInfo.frame_len;
- }/*end of for loop*/
-
- /* Dequeue N frames from native window and queue into interface. Only dequeue our requested buffers */
- for (int i = 0; i < mNumBuffers; i++)
- mPreviewMemory.local_flag[i] = BUFFER_NOT_REGGED;
- for (int i = 0; i < OPAQUE_BUFFER_COUNT; i++) {
- ALOGE("mPreview Window %p",mPreviewWindow);
- int err = mPreviewWindow->dequeue_buffer(mPreviewWindow, &buffer_handle);
- if (err == NO_ERROR && buffer_handle) {
- int j;
- for (j = 0; j < mPreviewMemory.buffer_count; j++) {
- if (mPreviewMemory.buffer_handle[j] == *buffer_handle) {
- mPreviewMemory.local_flag[j] = BUFFER_OWNED;
- ALOGE("%s: [%d]: local_flag = 1", __func__, j);
- break;
- }
- }
- if (j == mPreviewMemory.buffer_count) {
- ALOGE("Cannot find matching handle in the table.");
- return INVALID_OPERATION;
- }
- } else {
- ALOGE("dequeue_buffer failed.");
- return INVALID_OPERATION;
- }
- }
-
- /* register the streaming buffers for the channel*/
- mPreviewMemoryLock.unlock();
- ALOGE("%s:END",__func__);
- return NO_ERROR;
-
-error:
- mPreviewMemoryLock.unlock();
-
- ALOGV("%s: X", __func__);
- return ret;
-}
-
-void QCameraStream_preview::deinitBuffers()
-{
- mPreviewMemoryLock.lock();
- for (int i = 0; i < mNumBuffers; i++) {
- if (mPreviewMemory.local_flag[i] == BUFFER_OWNED) {
- mPreviewWindow->cancel_buffer(mPreviewWindow,
- &mPreviewMemory.buffer_handle[i]);
- mPreviewMemory.local_flag[i] = BUFFER_NOT_OWNED;
- }
- }
- mPreviewMemoryLock.unlock();
-}
-
-void QCameraStream_preview::dumpFrameToFile(mm_camera_buf_def_t *newFrame)
-{
- int32_t enabled = 0;
- int frm_num;
- uint32_t skip_mode;
- char value[PROPERTY_VALUE_MAX];
- char buf[32];
- int w, h;
- static int count = 0;
- int file_fd;
- int rc = 0;
- int len;
- unsigned long addr;
- unsigned long * tmp = (unsigned long *)newFrame->buffer;
- addr = *tmp;
-
- len = newFrame->frame_len;
- count++;
- if(count < 100) {
- snprintf(buf, sizeof(buf), "/data/mzhu%d.yuv", count);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
-
- rc = write(file_fd, (const void *)addr, len);
- ALOGE("%s: file='%s', vaddr_old=0x%x, addr_map = 0x%p, len = %d, rc = %d",
- __func__, buf, (uint32_t)newFrame->buffer, (void *)addr, len, rc);
- close(file_fd);
- ALOGE("%s: dump %s, rc = %d, len = %d", __func__, buf, rc, len);
- }
-}
-
-int QCameraStream_preview::prepareStream()
-{
- mm_camera_img_mode img_mode;
- cam_format_t format;
- struct private_handle_t *private_handle = mPreviewMemory.private_buffer_handle[0];
-
- ALOGE("%s: private_handle->format = %d, flags = %d", __func__,
- private_handle->format, private_handle->flags);
- if (private_handle->flags & private_handle_t::PRIV_FLAGS_VIDEO_ENCODER)
- img_mode = MM_CAMERA_VIDEO;
- else if (private_handle->flags & private_handle_t::PRIV_FLAGS_CAMERA_WRITE)
- img_mode = MM_CAMERA_PREVIEW;
- else {
- ALOGE("%s: Invalid flags %d\n", __func__, private_handle->flags);
- return BAD_VALUE;
- }
-
- switch (private_handle->format) {
- case HAL_PIXEL_FORMAT_YCbCr_420_SP:
- format = CAMERA_YUV_420_NV12;
- break;
- case HAL_PIXEL_FORMAT_YCrCb_420_SP:
- format = CAMERA_YUV_420_NV21;
- break;
- default:
- ALOGE("%s: Invalid format!!!", __func__);
- return BAD_VALUE;
- }
- if(NO_ERROR!=initStream(img_mode, format)) {
- ALOGE("Init stream failed");
- return BAD_VALUE;
- }
- return OK;
-}
-
-status_t QCameraStream_preview::processPreviewFrame (
- mm_camera_super_buf_t *frame)
-{
- ALOGV("%s",__func__);
- int err = 0;
- int msgType = 0;
- int i;
- camera_frame_metadata_t *metadata = NULL;
-
- Mutex::Autolock lock(mLock);
- if(!mActive) {
- ALOGE("Preview Stopped. Returning callback");
- return NO_ERROR;
- }
-
- if(mHalCamCtrl==NULL) {
- ALOGE("%s: X: HAL control object not set",__func__);
- /*Call buf done*/
- return BAD_VALUE;
- }
- nsecs_t timeStamp = seconds_to_nanoseconds(frame->bufs[0]->ts.tv_sec) ;
- timeStamp += frame->bufs[0]->ts.tv_nsec;
-
- if(mFirstFrameRcvd == false) {
- //mm_camera_util_profile("HAL: First preview frame received");
- mFirstFrameRcvd = true;
- }
-
- // dumpFrameToFile(frame->bufs[0]);
-
- mPreviewMemoryLock.lock();
- mNotifyBuffer[frame->bufs[0]->buf_idx] = *frame;
- ALOGE("processPreviewFrame: timeStamp = %lld", (int64_t)timeStamp);
- err = mPreviewWindow->enqueue_buffer(mPreviewWindow, (int64_t)timeStamp,
- &mPreviewMemory.buffer_handle[frame->bufs[0]->buf_idx]);
- if(err != 0) {
- ALOGE("%s: enqueue_buffer failed, err = %d", __func__, err);
- }
- mPreviewMemory.local_flag[frame->bufs[0]->buf_idx] = BUFFER_NOT_OWNED;
-
- buffer_handle_t *buffer_handle = NULL;
- err = mPreviewWindow->dequeue_buffer(mPreviewWindow, &buffer_handle);
- if (err == NO_ERROR && buffer_handle != NULL) {
- int rc = MM_CAMERA_OK;
- ALOGD("%s: dequed buf hdl =%p", __func__, *buffer_handle);
- for(i = 0; i < mPreviewMemory.buffer_count; i++) {
- if(mPreviewMemory.buffer_handle[i] == *buffer_handle) {
- ALOGE("<DEBUG2>:Found buffer in idx:%d",i);
- break;
- }
- }
- if (mPreviewMemory.local_flag[i] == BUFFER_NOT_REGGED) {
- mm_camera_buf_def_t buf = mDisplayBuf[i];
- mPreviewMemory.local_flag[i] = BUFFER_OWNED;
- rc = p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, &buf);
- } else {
- mPreviewMemory.local_flag[i] = BUFFER_OWNED;
- rc = p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mNotifyBuffer[i].bufs[0]);
- }
-
- if(rc != MM_CAMERA_OK) {
- /* how to handle the error of qbuf? */
- ALOGE("BUF DONE FAILED");
- }
- }
- /* Save the last displayed frame. We'll be using it to fill the gap between
- when preview stops and postview start during snapshot.*/
- mLastQueuedFrame = &(mDisplayBuf[frame->bufs[0]->buf_idx]);
- mPreviewMemoryLock.unlock();
-
- return NO_ERROR;
-}
-
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-QCameraStream_preview::QCameraStream_preview(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- int requestedFormat,
- mm_camera_vtbl_t *mm_ops,
- camera_mode_t mode) :
- QCameraStream(CameraHandle,
- ChannelId,
- Width,
- Height,
- mm_ops,
- mode),
- mLastQueuedFrame(NULL),
- mDisplayBuf(NULL),
- mNumFDRcvd(0)
-{
- mHalCamCtrl = NULL;
- ALOGE("%s: E", __func__);
-
- mStreamId = allocateStreamId();
-
- switch (requestedFormat) {
- case CAMERA2_HAL_PIXEL_FORMAT_OPAQUE:
- mMaxBuffers = 5;
- break;
- case HAL_PIXEL_FORMAT_BLOB:
- mMaxBuffers = 1;
- break;
- default:
- ALOGE("Unsupported requested format %d", requestedFormat);
- mMaxBuffers = 1;
- break;
- }
- /*TODO: There has to be a better way to do this*/
- ALOGE("%s: X", __func__);
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-QCameraStream_preview::~QCameraStream_preview() {
- ALOGV("%s: E", __func__);
- if(mActive) {
- streamOff(0);
- }
- if(mInit) {
- deinitStream();
- }
- mInit = false;
- mActive = false;
- if (mDisplayBuf) {
- delete[] mDisplayBuf;
- mDisplayBuf = NULL;
- }
- deallocateStreamId(mStreamId);
- ALOGV("%s: X", __func__);
-
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-status_t QCameraStream_preview::init()
-{
- status_t ret = NO_ERROR;
- ALOGV("%s: E", __func__);
-
-#if 0
- if (!(myMode & CAMERA_ZSL_MODE)) {
- ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO");
- mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO;
- ret = p_mm_ops->ops->set_parm (mCameraHandle, MM_CAMERA_PARM_OP_MODE,
- &op_mode);
- ALOGE("OP Mode Set");
-
- if(MM_CAMERA_OK != ret) {
- ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_VIDEO err=%d\n", __func__, ret);
- return BAD_VALUE;
- }
- }else {
- ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_ZSL");
- mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_ZSL;
- ret =p_mm_ops->ops->set_parm (mCameraHandle, MM_CAMERA_PARM_OP_MODE,
- &op_mode);
- if(MM_CAMERA_OK != ret) {
- ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_ZSL err=%d\n", __func__, ret);
- return BAD_VALUE;
- }
- }
-
- setFormat();
- ret = QCameraStream::initStream();
- if (NO_ERROR!=ret) {
- ALOGE("%s E: can't init native cammera preview ch\n",__func__);
- return ret;
- }
-
- mInit = true;
-#endif
- return ret;
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-status_t QCameraStream_preview::start()
-{
- ALOGV("%s: E", __func__);
- status_t ret = NO_ERROR;
-
- Mutex::Autolock lock(mLock);
-
- /* call start() in parent class to start the monitor thread*/
- //QCameraStream::start ();
-
-#if 0
- ret = cam_config_prepare_buf(mCameraId, &mDisplayBuf);
- ALOGE("Debug : %s : cam_config_prepare_buf",__func__);
- if(ret != MM_CAMERA_OK) {
- ALOGV("%s:reg preview buf err=%d\n", __func__, ret);
- ret = BAD_VALUE;
- goto error;
- }else {
- ret = NO_ERROR;
- }
-#endif
- /* For preview, the OP_MODE we set is dependent upon whether we are
- starting camera or camcorder. For snapshot, anyway we disable preview.
- However, for ZSL we need to set OP_MODE to OP_MODE_ZSL and not
- OP_MODE_VIDEO. We'll set that for now in CamCtrl. So in case of
- ZSL we skip setting Mode here */
-
-
- /* call mm_camera action start(...) */
- ALOGE("Starting Preview/Video Stream. ");
- mFirstFrameRcvd = false;
-
- ALOGE("Starting Preview/Video Stream. ");
- ret = streamOn();
- if (MM_CAMERA_OK != ret) {
- ALOGE ("%s: preview streaming start err=%d\n", __func__, ret);
- ret = BAD_VALUE;
- goto end;
- }
-
- ALOGE("Debug : %s : Preview streaming Started",__func__);
- ret = NO_ERROR;
-
- mActive = true;
- goto end;
-
-end:
- ALOGE("%s: X", __func__);
- return ret;
- }
-
-
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
- void QCameraStream_preview::stop() {
- ALOGE("%s: E", __func__);
- int ret=MM_CAMERA_OK;
-
- if(!mActive) {
- return;
- }
- Mutex::Autolock lock(mLock);
- mActive = false;
- /* unregister the notify fn from the mmmm_camera_t object*/
-
- ALOGI("%s: Stop the thread \n", __func__);
- /* call stop() in parent class to stop the monitor thread*/
- //stream_info = mHalCamCtrl->getChannelInterface();
-
- ret = streamOff(0);
- if(MM_CAMERA_OK != ret) {
- ALOGE ("%s: camera preview stop err=%d\n", __func__, ret);
- }
-#if 0
- ret = cam_config_unprepare_buf(mCameraId, MM_CAMERA_CH_PREVIEW);
- if(ret != MM_CAMERA_OK) {
- ALOGE("%s:Unreg preview buf err=%d\n", __func__, ret);
- //ret = BAD_VALUE;
- }
-#endif
- /* In case of a clean stop, we need to clean all buffers*/
- ALOGE("Debug : %s : Buffer Unprepared",__func__);
- /*free camera_memory handles and return buffer back to surface*/
- ret= QCameraStream::deinitStream();
- ALOGE(": %s : De init Channel",__func__);
- if(ret != MM_CAMERA_OK) {
- ALOGE("%s:Deinit preview channel failed=%d\n", __func__, ret);
- //ret = BAD_VALUE;
- }
- ALOGE("%s: X", __func__);
-
- }
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
- void QCameraStream_preview::release() {
-
- ALOGE("%s : BEGIN",__func__);
- int ret=MM_CAMERA_OK,i;
-
- if(!mInit)
- {
- ALOGE("%s : Stream not Initalized",__func__);
- return;
- }
-
- if(mActive) {
- this->streamOff(0);
- }
-
-
- if(mInit) {
- deinitStream();
- }
- mInit = false;
- ALOGE("%s: END", __func__);
-
- }
-
-QCameraStream*
-QCameraStream_preview::createInstance(uint32_t CameraHandle,
- uint32_t ChannelId,
- uint32_t Width,
- uint32_t Height,
- int requestedFormat,
- mm_camera_vtbl_t *mm_ops,
- camera_mode_t mode)
-{
- QCameraStream* pme = new QCameraStream_preview(CameraHandle,
- ChannelId,
- Width,
- Height,
- requestedFormat,
- mm_ops,
- mode);
- return pme;
-}
-// ---------------------------------------------------------------------------
-// QCameraStream_preview
-// ---------------------------------------------------------------------------
-
-void QCameraStream_preview::deleteInstance(QCameraStream *p)
-{
- if (p){
- ALOGV("%s: BEGIN", __func__);
- p->release();
- delete p;
- p = NULL;
- ALOGV("%s: END", __func__);
- }
-}
-
-
-/* Temp helper function */
-void *QCameraStream_preview::getLastQueuedFrame(void)
-{
- return mLastQueuedFrame;
-}
-
-// ---------------------------------------------------------------------------
-// No code beyone this line
-// ---------------------------------------------------------------------------
-}; // namespace android
diff --git a/camera/QCamera/HAL2/test/Android.mk b/camera/QCamera/HAL2/test/Android.mk
deleted file mode 100644
index 8b13789..0000000
--- a/camera/QCamera/HAL2/test/Android.mk
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/camera/QCamera/HAL2/wrapper/QualcommCamera.cpp b/camera/QCamera/HAL2/wrapper/QualcommCamera.cpp
deleted file mode 100644
index c06bf33..0000000
--- a/camera/QCamera/HAL2/wrapper/QualcommCamera.cpp
+++ /dev/null
@@ -1,646 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- *
- */
-/*#error uncomment this for compiler test!*/
-
-//#define ALOG_NDEBUG 0
-#define ALOG_NIDEBUG 0
-#define LOG_TAG "QualcommCamera"
-#include <utils/Log.h>
-#include <utils/threads.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-
-#include "QCameraHAL.h"
-/* include QCamera Hardware Interface Header*/
-#include "QualcommCamera.h"
-
-extern "C" {
-#include <sys/time.h>
-}
-
-/**
- * The functions need to be provided by the camera HAL.
- *
- * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
- * and openCameraHardware() is 0 to N-1.
- */
-
-static hw_module_methods_t camera_module_methods = {
- open: camera_device_open,
-};
-
-static hw_module_t camera_common = {
- tag: HARDWARE_MODULE_TAG,
- module_api_version: CAMERA_MODULE_API_VERSION_2_0,
- hal_api_version: HARDWARE_HAL_API_VERSION,
- id: CAMERA_HARDWARE_MODULE_ID,
- name: "Qcamera",
- author:"Qcom",
- methods: &camera_module_methods,
- dso: NULL,
- reserved: {0},
-};
-
-camera_module_t HAL_MODULE_INFO_SYM = {
- common: camera_common,
- get_number_of_cameras: get_number_of_cameras,
- get_camera_info: get_camera_info,
-};
-
-camera2_device_ops_t camera_ops = {
- set_request_queue_src_ops: android::set_request_queue_src_ops,
- notify_request_queue_not_empty: android::notify_request_queue_not_empty,
- set_frame_queue_dst_ops: android::set_frame_queue_dst_ops,
- get_in_progress_count: android::get_in_progress_count,
- flush_captures_in_progress: android::flush_captures_in_progress,
- construct_default_request: android::construct_default_request,
-
- allocate_stream: android::allocate_stream,
- register_stream_buffers: android::register_stream_buffers,
- release_stream: android::release_stream,
-
- allocate_reprocess_stream: android::allocate_reprocess_stream,
- allocate_reprocess_stream_from_stream: android::allocate_reprocess_stream_from_stream,
- release_reprocess_stream: android::release_reprocess_stream,
-
- trigger_action: android::trigger_action,
- set_notify_callback: android::set_notify_callback,
- get_metadata_vendor_tag_ops: android::get_metadata_vendor_tag_ops,
- dump: android::dump,
-};
-
-namespace android {
-
-typedef struct {
- camera2_device_t hw_dev;
- QCameraHardwareInterface *hardware;
- int camera_released;
- int cameraId;
-} camera_hardware_t;
-
-QCameraHardwareInterface *util_get_Hal_obj(const camera2_device_t * device)
-{
- QCameraHardwareInterface *hardware = NULL;
- if(device && device->priv){
- camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
- hardware = camHal->hardware;
- }
- return hardware;
-}
-
-extern "C" int get_number_of_cameras()
-{
- /* try to query every time we get the call!*/
- ALOGE("Q%s: E", __func__);
- return android::HAL_getNumberOfCameras();
-}
-
-extern "C" int get_camera_info(int camera_id, struct camera_info *info)
-{
- int rc = -1;
- ALOGE("Q%s: E, id = %d", __func__, camera_id);
- if(info) {
- rc = android::HAL_getCameraInfo(camera_id, info);
- }
- ALOGE("Q%s: X, id = %d", __func__, camera_id);
- return rc;
-}
-
-
-/* HAL should return NULL if it fails to open camera hardware. */
-extern "C" int camera_device_open(
- const struct hw_module_t* module, const char* id,
- struct hw_device_t** hw_device)
-{
- int rc = -1;
- int mode = 0;
- camera2_device_t *device = NULL;
- ALOGE("Q%s: E, id = %s", __func__, id);
- if(module && id && hw_device) {
- int cameraId = atoi(id);
-
- if (!strcmp(module->name, camera_common.name)) {
- camera_hardware_t *camHal =
- (camera_hardware_t *) malloc(sizeof (camera_hardware_t));
- if(!camHal) {
- *hw_device = NULL;
- ALOGE("%s: end in no mem", __func__);
- return rc;
- }
- /* we have the camera_hardware obj malloced */
- memset(camHal, 0, sizeof (camera_hardware_t));
- camHal->hardware = new QCameraHardwareInterface(cameraId, mode);
- if (camHal->hardware && camHal->hardware->isCameraReady()) {
- camHal->cameraId = cameraId;
- device = &camHal->hw_dev;
- device->common.close = close_camera_device;
- device->common.version = CAMERA_DEVICE_API_VERSION_2_0;
- device->ops = &camera_ops;
- device->priv = (void *)camHal;
- rc = 0;
- } else {
- if (camHal->hardware) {
- delete camHal->hardware;
- camHal->hardware = NULL;
- }
- free(camHal);
- device = NULL;
- }
- }
- }
- /* pass actual hw_device ptr to framework. This amkes that we actally be use memberof() macro */
- *hw_device = (hw_device_t*)&device->common;
- ALOGE("%s: end rc %d", __func__, rc);
- return rc;
-}
-
-extern "C" int close_camera_device(hw_device_t *hw_dev)
-{
- ALOGE("Q%s: device =%p E", __func__, hw_dev);
- int rc = -1;
- camera2_device_t *device = (camera2_device_t *)hw_dev;
-
- if(device) {
- camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
- if(camHal ) {
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(!camHal->camera_released) {
- if(hardware != NULL) {
- hardware->release( );
- }
- }
- if(hardware != NULL)
- delete hardware;
- free(camHal);
- }
- rc = 0;
- }
- return rc;
-}
-
-int set_request_queue_src_ops(const struct camera2_device *device,
- const camera2_request_queue_src_ops_t *request_src_ops)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->set_request_queue_src_ops(request_src_ops);
- }
- return rc;
-}
-
-int notify_request_queue_not_empty(const struct camera2_device *device)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->notify_request_queue_not_empty();
- }
- return rc;
-}
-
-int set_frame_queue_dst_ops(const struct camera2_device *device,
- const camera2_frame_queue_dst_ops_t *frame_dst_ops)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->set_frame_queue_dst_ops(frame_dst_ops);
- }
- return rc;
-}
-
-int get_in_progress_count(const struct camera2_device *device)
-{
- int rc = INVALID_OPERATION;
- ALOGE("%s:E",__func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->get_in_progress_count();
- }
- ALOGE("%s:X",__func__);
- return rc;
-}
-
-int flush_captures_in_progress(const struct camera2_device *)
-{
- ALOGE("%s:E",__func__);
- ALOGE("%s:X",__func__);
- return INVALID_OPERATION;
-}
-
-int construct_default_request(const struct camera2_device *device,
- int request_template,
- camera_metadata_t **request)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->construct_default_request(request_template, request);
- }
- return rc;
-}
-
-int allocate_stream(const struct camera2_device *device,
- uint32_t width,
- uint32_t height,
- int format,
- const camera2_stream_ops_t *stream_ops,
- uint32_t *stream_id,
- uint32_t *format_actual,
- uint32_t *usage,
- uint32_t *max_buffers)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->allocate_stream(width, height, format, stream_ops,
- stream_id, format_actual, usage, max_buffers);
- }
- return rc;
-}
-
-int register_stream_buffers(
- const struct camera2_device *device,
- uint32_t stream_id,
- int num_buffers,
- buffer_handle_t *buffers)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->register_stream_buffers(stream_id, num_buffers, buffers);
- }
- return rc;
-}
-
-int release_stream(
- const struct camera2_device *device,
- uint32_t stream_id)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->release_stream(stream_id);
- }
- return rc;
-}
-
-int allocate_reprocess_stream(const struct camera2_device *,
- uint32_t width,
- uint32_t height,
- uint32_t format,
- const camera2_stream_in_ops_t *reprocess_stream_ops,
- uint32_t *stream_id,
- uint32_t *consumer_usage,
- uint32_t *max_buffers)
-{
- return INVALID_OPERATION;
-}
-
-int allocate_reprocess_stream_from_stream(const struct camera2_device *,
- uint32_t output_stream_id,
- const camera2_stream_in_ops_t *reprocess_stream_ops,
- uint32_t *stream_id)
-{
- return INVALID_OPERATION;
-}
-
-int release_reprocess_stream(
- const struct camera2_device *,
- uint32_t stream_id)
-{
- return INVALID_OPERATION;
-}
-
-int trigger_action(const struct camera2_device *,
- uint32_t trigger_id,
- int32_t ext1,
- int32_t ext2)
-{
- return INVALID_OPERATION;
-}
-
-int set_notify_callback(const struct camera2_device *device,
- camera2_notify_callback notify_cb,
- void *user)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->set_notify_callback(notify_cb, user);
- }
- return rc;
-}
-
-int get_metadata_vendor_tag_ops(const struct camera2_device *device,
- vendor_tag_query_ops_t **ops)
-{
- int rc = INVALID_OPERATION;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->get_metadata_vendor_tag_ops(ops);
- }
- return rc;
-}
-
-int dump(const struct camera2_device *, int fd)
-{
- return INVALID_OPERATION;
-}
-
-#if 0
-int set_preview_window(camera2_device_t * device,
- struct preview_stream_ops *window)
-{
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
-
- if(hardware != NULL) {
- rc = hardware->setPreviewWindow(window);
- }
- return rc;
-}
-
-void set_CallBacks(camera2_device_t * device,
- camera_notify_callback notify_cb,
- camera_data_callback data_cb,
- camera_data_timestamp_callback data_cb_timestamp,
- camera_request_memory get_memory,
- void *user)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->setCallbacks(notify_cb,data_cb, data_cb_timestamp, get_memory, user);
- }
-}
-
-void enable_msg_type(camera2_device_t * device, int32_t msg_type)
-{
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->enableMsgType(msg_type);
- }
-}
-
-void disable_msg_type(camera2_device_t * device, int32_t msg_type)
-{
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- ALOGE("Q%s: E", __func__);
- if(hardware != NULL){
- hardware->disableMsgType(msg_type);
- }
-}
-
-int msg_type_enabled(camera2_device_t * device, int32_t msg_type)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->msgTypeEnabled(msg_type);
- }
- return rc;
-}
-
-int start_preview(camera2_device_t * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->startPreview( );
- }
- ALOGE("Q%s: X", __func__);
- return rc;
-}
-
-void stop_preview(camera2_device_t * device)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->stopPreview( );
- }
-}
-
-int preview_enabled(camera2_device_t * device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->previewEnabled( );
- }
- return rc;
-}
-
-int store_meta_data_in_buffers(camera2_device_t *device, int enable)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->storeMetaDataInBuffers(enable);
- }
- return rc;
-}
-
-int start_recording(camera2_device_t *device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->startRecording( );
- }
- return rc;
-}
-
-void stop_recording(camera2_device_t *device)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->stopRecording( );
- }
-}
-
-int recording_enabled(camera2_device_t *device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->recordingEnabled( );
- }
- return rc;
-}
-
-void release_recording_frame(camera2_device_t *device,
- const void *opaque)
-{
- ALOGV("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->releaseRecordingFrame(opaque);
- }
-}
-
-int auto_focus(camera2_device_t *device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->autoFocus( );
- }
- return rc;
-}
-
-int cancel_auto_focus(camera2_device_t *device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->cancelAutoFocus( );
- }
- return rc;
-}
-
-int take_picture(camera2_device_t *device)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->takePicture( );
- }
- return rc;
-}
-
-int cancel_picture(camera2_device_t *device)
-
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->cancelPicture( );
- }
- return rc;
-}
-
-int set_parameters(camera2_device_t *device, const char *parms)
-
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL && parms){
- //QCameraParameters param;// = util_get_HAL_parameter(device);
- //String8 str = String8(parms);
-
- //param.unflatten(str);
- rc = hardware->setParameters(parms);
- //rc = 0;
- }
- return rc;
-}
-
-char* get_parameters(camera2_device_t *device)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- char *parms = NULL;
- hardware->getParameters(&parms);
- return parms;
- }
- return NULL;
-}
-
-void put_parameters(camera2_device_t *device, char *parm)
-
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- hardware->putParameters(parm);
- }
-}
-
-int send_command(camera2_device_t *device,
- int32_t cmd, int32_t arg1, int32_t arg2)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->sendCommand( cmd, arg1, arg2);
- }
- return rc;
-}
-
-void release(camera2_device_t *device)
-{
- ALOGE("Q%s: E", __func__);
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- camera_hardware_t *camHal = (camera_hardware_t *)device->priv;
- hardware->release( );
- camHal->camera_released = true;
- }
-}
-
-int dump(camera2_device_t *device, int fd)
-{
- ALOGE("Q%s: E", __func__);
- int rc = -1;
- QCameraHardwareInterface *hardware = util_get_Hal_obj(device);
- if(hardware != NULL){
- rc = hardware->dump( fd );
- }
- return rc;
-}
-#endif
-
-}; // namespace android
diff --git a/camera/QCamera/HAL2/wrapper/QualcommCamera.h b/camera/QCamera/HAL2/wrapper/QualcommCamera.h
deleted file mode 100644
index 64ebc7c..0000000
--- a/camera/QCamera/HAL2/wrapper/QualcommCamera.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- *
- */
-
-#ifndef ANDROID_HARDWARE_QUALCOMM_CAMERA_H
-#define ANDROID_HARDWARE_QUALCOMM_CAMERA_H
-
-#include <hardware/camera2.h>
-
-extern "C" {
-
- int get_number_of_cameras();
- int get_camera_info(int camera_id, struct camera_info *info);
-
- int camera_device_open(const struct hw_module_t* module, const char* id,
- struct hw_device_t** device);
-
- hw_device_t * open_camera_device(int cameraId);
-
- int close_camera_device( hw_device_t *);
-
-namespace android {
- int set_request_queue_src_ops(const struct camera2_device *,
- const camera2_request_queue_src_ops_t *request_src_ops);
-
- int notify_request_queue_not_empty(const struct camera2_device *);
-
- int set_frame_queue_dst_ops(const struct camera2_device *,
- const camera2_frame_queue_dst_ops_t *frame_dst_ops);
-
- int get_in_progress_count(const struct camera2_device *);
-
- int flush_captures_in_progress(const struct camera2_device *);
-
- int construct_default_request(const struct camera2_device *,
- int request_template,
- camera_metadata_t **request);
-
- int allocate_stream(const struct camera2_device *,
- uint32_t width,
- uint32_t height,
- int format,
- const camera2_stream_ops_t *stream_ops,
- uint32_t *stream_id,
- uint32_t *format_actual,
- uint32_t *usage,
- uint32_t *max_buffers);
-
- int register_stream_buffers(
- const struct camera2_device *,
- uint32_t stream_id,
- int num_buffers,
- buffer_handle_t *buffers);
-
- int release_stream(
- const struct camera2_device *,
- uint32_t stream_id);
-
- int allocate_reprocess_stream(const struct camera2_device *,
- uint32_t width,
- uint32_t height,
- uint32_t format,
- const camera2_stream_in_ops_t *reprocess_stream_ops,
- uint32_t *stream_id,
- uint32_t *consumer_usage,
- uint32_t *max_buffers);
-
- int allocate_reprocess_stream_from_stream(const struct camera2_device *,
- uint32_t output_stream_id,
- const camera2_stream_in_ops_t *stream_ops,
- uint32_t *stream_id);
-
- int release_reprocess_stream(
- const struct camera2_device *,
- uint32_t stream_id);
-
- int trigger_action(const struct camera2_device *,
- uint32_t trigger_id,
- int32_t ext1,
- int32_t ext2);
-
- int set_notify_callback(const struct camera2_device *,
- camera2_notify_callback notify_cb,
- void *user);
-
- int get_metadata_vendor_tag_ops(const struct camera2_device*,
- vendor_tag_query_ops_t **ops);
-
- int dump(const struct camera2_device *, int fd);
-}; // namespace android
-
-} //extern "C"
-
-#endif
diff --git a/camera/QCamera/stack/Android.mk b/camera/QCamera/stack/Android.mk
deleted file mode 100755
index 9bd33b3..0000000
--- a/camera/QCamera/stack/Android.mk
+++ /dev/null
@@ -1,4 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(LOCAL_PATH)/mm-camera-interface/Android.mk
-include $(LOCAL_PATH)/mm-jpeg-interface/Android.mk
-include $(LOCAL_PATH)/mm-camera-test/Android.mk
diff --git a/camera/QCamera/stack/common/cam_list.h b/camera/QCamera/stack/common/cam_list.h
deleted file mode 100755
index ea30d7f..0000000
--- a/camera/QCamera/stack/common/cam_list.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-/* This file is a slave copy from /vendor/qcom/propreitary/mm-cammera/common,
- * Please do not modify it directly here. */
-
-#ifndef __CAMLIST_H
-#define __CAMLIST_H
-
-#include <stddef.h>
-
-#define member_of(ptr, type, member) ({ \
- const typeof(((type *)0)->member) *__mptr = (ptr); \
- (type *)((char *)__mptr - offsetof(type,member));})
-
-struct cam_list {
- struct cam_list *next, *prev;
-};
-
-static inline void cam_list_init(struct cam_list *ptr)
-{
- ptr->next = ptr;
- ptr->prev = ptr;
-}
-
-static inline void cam_list_add_tail_node(struct cam_list *item,
- struct cam_list *head)
-{
- struct cam_list *prev = head->prev;
-
- head->prev = item;
- item->next = head;
- item->prev = prev;
- prev->next = item;
-}
-
-static inline void cam_list_del_node(struct cam_list *ptr)
-{
- struct cam_list *prev = ptr->prev;
- struct cam_list *next = ptr->next;
-
- next->prev = ptr->prev;
- prev->next = ptr->next;
- ptr->next = ptr;
- ptr->prev = ptr;
-}
-
-#endif /* __CAMLIST_H */
diff --git a/camera/QCamera/stack/mm-camera-interface/Android.mk b/camera/QCamera/stack/mm-camera-interface/Android.mk
deleted file mode 100755
index 33d0e14..0000000
--- a/camera/QCamera/stack/mm-camera-interface/Android.mk
+++ /dev/null
@@ -1,63 +0,0 @@
-#ifeq ($(call is-board-platform,msm8960),true)
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-MM_CAM_FILES := \
- src/mm_camera_interface.c \
- src/mm_camera_stream.c \
- src/mm_camera_channel.c \
- src/mm_camera.c \
- src/mm_camera_thread.c \
- src/mm_camera_data.c \
- src/mm_camera_sock.c \
- src/mm_camera_helper.c
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
- LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_CFLAGS += -D_ANDROID_
-LOCAL_COPY_HEADERS_TO := mm-camera-interface
-LOCAL_COPY_HEADERS := inc/mm_camera_interface.h
-LOCAL_COPY_HEADERS += ../common/cam_list.h
-
-LOCAL_C_INCLUDES := \
- $(LOCAL_PATH)/inc \
- $(LOCAL_PATH)/../common \
- $(LOCAL_PATH)/../../../ \
- $(TARGET_OUT_HEADERS)/mm-camera \
- $(TARGET_OUT_HEADERS)/mm-camera/common
-
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/media
-LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
-
-# (BEGIN) Need to remove later once dependency on jpeg removed
-LOCAL_C_INCLUDES += \
- $(TARGET_OUT_HEADERS)/mm-still \
- $(TARGET_OUT_HEADERS)/mm-still/jpeg \
- $(TARGET_OUT_HEADERS)/mm-core/omxcore \
- $(TARGET_OUT_HEADERS)/mm-still/mm-omx
-# (END) Need to remove later once dependency on jpeg removed
-
-LOCAL_C_INCLUDES+= hardware/qcom/media/mm-core/inc
-LOCAL_CFLAGS += -include bionic/libc/kernel/common/linux/socket.h
-LOCAL_CFLAGS += -include bionic/libc/kernel/common/linux/un.h
-
-LOCAL_SRC_FILES := $(MM_CAM_FILES)
-
-LOCAL_MODULE := libmmcamera_interface
-LOCAL_PRELINK_MODULE := false
-LOCAL_SHARED_LIBRARIES := libdl libcutils liblog
-LOCAL_MODULE_TAGS := optional
-
-# (BEGIN) Need to remove later once dependency on jpeg removed
-# LOCAL_SHARED_LIBRARIES += libmmjpeg_interface
-# (END) Need to remove later once dependency on jpeg removed
-
-include $(BUILD_SHARED_LIBRARY)
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
-#endif
diff --git a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera.h b/camera/QCamera/stack/mm-camera-interface/inc/mm_camera.h
deleted file mode 100755
index e96e8b6..0000000
--- a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera.h
+++ /dev/null
@@ -1,696 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#ifndef __MM_CAMERA_H__
-#define __MM_CAMERA_H__
-
-#include "mm_camera_interface.h"
-
-/**********************************************************************************
-* Data structure declare
-***********************************************************************************/
-/* num of streams allowed in a channel obj */
-//TODO: change for Stats
-#define MM_CAMEAR_STRAEM_NUM_MAX (16)
-/* num of channels allowed in a camera obj */
-#define MM_CAMERA_CHANNEL_MAX 1
-/* num of callbacks allowed for an event type */
-#define MM_CAMERA_EVT_ENTRY_MAX 4
-/* num of data callbacks allowed in a stream obj */
-#define MM_CAMERA_STREAM_BUF_CB_MAX 4
-/* num of data poll threads allowed in a channel obj */
-#define MM_CAMERA_CHANNEL_POLL_THREAD_MAX 1
-
-#define MM_CAMERA_DEV_NAME_LEN 32
-#define MM_CAMERA_DEV_OPEN_TRIES 2
-#define MM_CAMERA_DEV_OPEN_RETRY_SLEEP 20
-
-struct mm_channel;
-struct mm_stream;
-struct mm_camera_obj;
-
-/* common use */
-typedef struct {
- struct cam_list list;
- void* data;
-} mm_camera_q_node_t;
-
-typedef struct {
- mm_camera_q_node_t head; /* dummy head */
- uint32_t size;
- pthread_mutex_t lock;
-} mm_camera_queue_t;
-
-typedef enum
-{
- MM_CAMERA_ASYNC_CMD_TYPE_STOP, /* async stop */
- MM_CAMERA_ASYNC_CMD_TYPE_MAX
-} mm_camera_async_cmd_type_t;
-
-typedef struct {
- struct mm_channel* ch_obj;
- uint8_t num_streams;
- uint32_t stream_ids[MM_CAMEAR_STRAEM_NUM_MAX];
-} mm_camera_async_stop_cmd_t;
-
-typedef struct {
- mm_camera_async_cmd_type_t cmd_type;
- union {
- mm_camera_async_stop_cmd_t stop_cmd;
- } u;
-} mm_camera_async_cmd_t;
-
-typedef enum
-{
- MM_CAMERA_CMD_TYPE_DATA_CB, /* dataB CMD */
- MM_CAMERA_CMD_TYPE_EVT_CB, /* evtCB CMD */
- MM_CAMERA_CMD_TYPE_ASYNC_CB, /* asyncCB CMD */
- MM_CAMERA_CMD_TYPE_EXIT, /* EXIT */
- MM_CAMERA_CMD_TYPE_REQ_DATA_CB,/* request data */
- MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB, /* superbuf dataB CMD */
- MM_CAMERA_CMD_TYPE_MAX
-} mm_camera_cmdcb_type_t;
-
-typedef struct {
- uint32_t stream_id;
- uint32_t frame_idx;
- mm_camera_buf_def_t *buf; /* ref to buf */
-} mm_camera_buf_info_t;
-
-typedef struct {
- uint32_t num_buf_requested;
-} mm_camera_req_buf_t;
-
-typedef struct {
- mm_camera_cmdcb_type_t cmd_type;
- union {
- mm_camera_buf_info_t buf; /* frame buf if dataCB */
- mm_camera_event_t evt; /* evt if evtCB */
- mm_camera_async_cmd_t async; /* async cmd */
- mm_camera_super_buf_t superbuf; /* superbuf if superbuf dataCB*/
- mm_camera_req_buf_t req_buf; /* num of buf requested */
- } u;
-} mm_camera_cmdcb_t;
-
-typedef void (*mm_camera_cmd_cb_t)(mm_camera_cmdcb_t * cmd_cb, void* user_data);
-
-typedef struct {
- mm_camera_queue_t cmd_queue; /* cmd queue (queuing dataCB, asyncCB, or exitCMD) */
- pthread_t cmd_pid; /* cmd thread ID */
- sem_t cmd_sem; /* semaphore for cmd thread */
- mm_camera_cmd_cb_t cb; /* cb for cmd */
- void* user_data; /* user_data for cb */
-} mm_camera_cmd_thread_t;
-
-typedef enum {
- MM_CAMERA_POLL_TYPE_EVT,
- MM_CAMERA_POLL_TYPE_CH,
- MM_CAMERA_POLL_TYPE_MAX
-} mm_camera_poll_thread_type_t;
-
-/* function ptr defined for poll notify CB,
- * registered at poll thread with poll fd */
-typedef void (*mm_camera_poll_notify_t)(void *user_data);
-
-typedef struct {
- int32_t fd;
- mm_camera_poll_notify_t notify_cb;
- uint32_t handler;
- void* user_data;
-} mm_camera_poll_entry_t;
-
-typedef struct {
- mm_camera_poll_thread_type_t poll_type;
- /* array to store poll fd and cb info
- * for MM_CAMERA_POLL_TYPE_EVT, only index 0 is valid;
- * for MM_CAMERA_POLL_TYPE_CH, depends on valid stream fd */
- mm_camera_poll_entry_t poll_entries[MM_CAMEAR_STRAEM_NUM_MAX];
- int32_t pfds[2];
- pthread_t pid;
- int32_t state;
- int timeoutms;
- uint32_t cmd;
- struct pollfd poll_fds[MM_CAMEAR_STRAEM_NUM_MAX+1];
- uint8_t num_fds;
- pthread_mutex_t mutex;
- pthread_cond_t cond_v;
- int32_t status;
- //void *my_obj;
-} mm_camera_poll_thread_t;
-
-/* mm_stream */
-typedef enum {
- MM_STREAM_STATE_NOTUSED = 0, /* not used */
- MM_STREAM_STATE_INITED, /* inited */
- MM_STREAM_STATE_ACQUIRED, /* acquired, fd opened */
- MM_STREAM_STATE_CFG, /* fmt & dim configured */
- MM_STREAM_STATE_BUFFED, /* buf allocated */
- MM_STREAM_STATE_REG, /* buf regged, stream off */
- MM_STREAM_STATE_ACTIVE_STREAM_ON, /* active with stream on */
- MM_STREAM_STATE_ACTIVE_STREAM_OFF, /* active with stream off */
- MM_STREAM_STATE_MAX
-} mm_stream_state_type_t;
-
-typedef enum {
- MM_STREAM_EVT_ACQUIRE,
- MM_STREAM_EVT_RELEASE,
- MM_STREAM_EVT_SET_FMT,
- MM_STREAM_EVT_GET_BUF,
- MM_STREAM_EVT_PUT_BUF,
- MM_STREAM_EVT_REG_BUF,
- MM_STREAM_EVT_UNREG_BUF,
- MM_STREAM_EVT_START,
- MM_STREAM_EVT_STOP,
- MM_STREAM_EVT_QBUF,
- MM_STREAM_EVT_SET_PARM,
- MM_STREAM_EVT_GET_PARM,
- MM_STREAM_EVT_MAX
-} mm_stream_evt_type_t;
-
-typedef struct {
- mm_camera_buf_notify_t cb;
- void *user_data;
- /* cb_count = -1: infinite
- * cb_count > 0: register only for required times */
- int8_t cb_count;
-} mm_stream_data_cb_t;
-
-typedef struct {
- /* buf reference count */
- uint8_t buf_refcnt;
-
- /* This flag is to indicate if after allocation,
- * the corresponding buf needs to qbuf into kernel
- * (e.g. for preview usecase, display needs to hold two bufs,
- * so no need to qbuf these two bufs initially) */
- uint8_t initial_reg_flag;
-
- /* indicate if buf is in kernel(1) or client(0) */
- uint8_t in_kernel;
-} mm_stream_buf_status_t;
-
-typedef struct mm_stream {
- uint32_t my_hdl;
- uint32_t inst_hdl;
- int32_t fd;
- mm_stream_state_type_t state;
-
- /* ext_image_mode used as id for stream obj */
- uint32_t ext_image_mode;
-
- /* sensor index used */
- uint32_t sensor_idx;
-
- mm_camera_image_fmt_t fmt;
-
- mm_camera_cmd_thread_t cmd_thread;
-
- /* dataCB registered on this stream obj */
- pthread_mutex_t cb_lock; /* cb lock to protect buf_cb */
- mm_stream_data_cb_t buf_cb[MM_CAMERA_STREAM_BUF_CB_MAX];
-
- /* stream buffer management */
- pthread_mutex_t buf_lock;
- uint8_t buf_num; /* num of buffers allocated */
- mm_camera_buf_def_t* buf; /* ptr to buf array */
- mm_stream_buf_status_t* buf_status; /* ptr to buf status array */
-
- /* reference to parent channel_obj */
- struct mm_channel* ch_obj;
-
- uint8_t is_bundled; /* flag if stream is bundled */
- uint8_t is_local_buf; /* flag if buf is local copy, no need to qbuf to kernel */
- uint8_t hal_requested_num_bufs;
- uint8_t need_stream_on; /* flag if stream need streamon when start */
- uint8_t num_stream_cb_times; /* how many times to register for other stream data CB */
- uint8_t local_buf_idx; /* idx to local buf that can be used for non-stream-on cb */
-
- mm_camera_frame_len_offset frame_offset; /*Stream buffer offset information*/
-} mm_stream_t;
-
-/* mm_channel */
-typedef enum {
- MM_CHANNEL_STATE_NOTUSED = 0, /* not used */
- MM_CHANNEL_STATE_STOPPED, /* stopped */
- MM_CHANNEL_STATE_ACTIVE, /* active, at least one stream active */
- MM_CHANNEL_STATE_PAUSED, /* paused */
- MM_CHANNEL_STATE_MAX
-} mm_channel_state_type_t;
-
-typedef enum {
- MM_CHANNEL_EVT_ADD_STREAM,
- MM_CHANNEL_EVT_DEL_STREAM,
- MM_CHANNEL_EVT_START_STREAM,
- MM_CHANNEL_EVT_STOP_STREAM,
- MM_CHANNEL_EVT_TEARDOWN_STREAM,
- MM_CHANNEL_EVT_CONFIG_STREAM,
- MM_CHANNEL_EVT_PAUSE,
- MM_CHANNEL_EVT_RESUME,
- MM_CHANNEL_EVT_INIT_BUNDLE,
- MM_CHANNEL_EVT_DESTROY_BUNDLE,
- MM_CHANNEL_EVT_REQUEST_SUPER_BUF,
- MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF,
- MM_CHANNEL_EVT_START_FOCUS,
- MM_CHANNEL_EVT_ABORT_FOCUS,
- MM_CHANNEL_EVT_PREPARE_SNAPSHOT,
- MM_CHANNEL_EVT_SET_STREAM_PARM,
- MM_CHANNEL_EVT_GET_STREAM_PARM,
- MM_CHANNEL_EVT_DELETE,
- MM_CHANNEL_EVT_OPEN_REPRO_ISP,
- MM_CHANNEL_EVT_CONFIG_REPRO_ISP,
- MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP,
- MM_CHANNEL_EVT_START_REPRO_ISP,
- MM_CHANNEL_EVT_REPROCESS,
- MM_CHANNEL_EVT_STOP_REPRO_ISP,
- MM_CHANNEL_EVT_DETACH_STREAM_FROM_REPRO_ISP,
- MM_CHANNEL_EVT_CLOSE_REPRO_ISP,
- MM_CHANNEL_EVT_MAX
-} mm_channel_evt_type_t;
-
-typedef struct {
- mm_camera_buf_notify_t buf_cb;
- void *user_data;
- uint32_t ext_image_mode;
- uint32_t sensor_idx;
-} mm_evt_paylod_add_stream_t;
-
-typedef struct {
- uint32_t stream_id;
- mm_camera_stream_config_t *config;
-} mm_evt_paylod_config_stream_t;
-
-typedef struct {
- mm_camera_stream_parm_t parm_type;
- void *value;
-} mm_evt_paylod_stream_parm_t;
-
-typedef struct {
- mm_camera_buf_notify_t super_frame_notify_cb;
- void *user_data;
- mm_camera_bundle_attr_t *attr;
- uint8_t num_streams;
- uint32_t *stream_ids;
-} mm_evt_payload_bundle_stream_t;
-
-typedef struct {
- uint8_t num_streams;
- uint32_t *stream_ids;
-} mm_evt_payload_start_stream_t;
-
-typedef struct {
- uint8_t num_streams;
- uint32_t *stream_ids;
-} mm_evt_payload_stop_stream_t;
-
-typedef struct {
- uint32_t sensor_idx;
- uint32_t focus_mode;
-} mm_evt_payload_start_focus_t;
-
-typedef struct {
- uint32_t repro_isp_handle;
- mm_camera_repro_isp_config_t *config;
-} mm_evt_paylod_config_repro_isp_t;
-
-typedef struct {
- uint32_t repro_isp_handle;
- uint32_t stream_id;
-} mm_evt_paylod_stream_to_repro_isp_t;
-
-typedef struct {
- uint32_t repro_isp_handle;
- mm_camera_repro_data_t *repro_data;
-} mm_evt_paylod_reprocess_t;
-
-typedef struct {
- uint32_t repro_isp_handle;
- uint32_t stream_id;
-} mm_evt_paylod_repro_start_stop_t;
-
-typedef struct {
- uint8_t num_of_bufs;
- mm_camera_buf_info_t super_buf[MM_CAMEAR_MAX_STRAEM_BUNDLE];
- uint8_t matched;
-} mm_channel_queue_node_t;
-
-typedef struct {
- mm_camera_queue_t que;
- uint8_t num_streams;
- /* container for bundled stream handlers */
- uint32_t bundled_streams[MM_CAMEAR_MAX_STRAEM_BUNDLE];
- mm_camera_bundle_attr_t attr;
- uint32_t expected_frame_id;
- uint32_t match_cnt;
-} mm_channel_queue_t;
-
-typedef struct {
- uint8_t is_active; /* flag to indicate if bundle is valid */
- /* queue to store bundled super buffers */
- mm_channel_queue_t superbuf_queue;
- mm_camera_buf_notify_t super_buf_notify_cb;
- void *user_data;
-} mm_channel_bundle_t;
-
-typedef struct mm_channel {
- uint32_t my_hdl;
- mm_channel_state_type_t state;
- pthread_mutex_t ch_lock; /* channel lock */
-
- /* stream bundle info in the channel */
- mm_channel_bundle_t bundle;
-
- /* num of pending suferbuffers */
- uint32_t pending_cnt;
-
- /* cmd thread for superbuffer dataCB and async stop*/
- mm_camera_cmd_thread_t cmd_thread;
-
- /* cb thread for sending data cb */
- mm_camera_cmd_thread_t cb_thread;
-
- /* data poll thread
- * currently one data poll thread per channel
- * could extended to support one data poll thread per stream in the channel */
- mm_camera_poll_thread_t poll_thread[MM_CAMERA_CHANNEL_POLL_THREAD_MAX];
-
- /* container for all streams in channel
- * stream is indexed by ext_image_mode */
- mm_stream_t streams[MM_CAMEAR_STRAEM_NUM_MAX];
-
- /* reference to parent cam_obj */
- struct mm_camera_obj* cam_obj;
-} mm_channel_t;
-
-/* struct to store information about pp cookie*/
-typedef struct {
- uint32_t cam_hdl;
- uint32_t ch_hdl;
- uint32_t stream_hdl;
- mm_channel_queue_node_t* super_buf;
-} mm_channel_pp_info_t;
-
-/* mm_camera */
-typedef struct {
- mm_camera_event_notify_t evt_cb;
- void *user_data;
-} mm_camera_evt_entry_t;
-
-typedef struct {
- mm_camera_evt_entry_t evt[MM_CAMERA_EVT_ENTRY_MAX];
- /* reg_count <=0: infinite
- * reg_count > 0: register only for required times */
- int reg_count;
-} mm_camera_evt_obj_t;
-
-typedef struct mm_camera_obj {
- uint32_t my_hdl;
- int ref_count;
- int32_t ctrl_fd;
- int32_t ds_fd; /* domain socket fd */
- cam_prop_t properties;
- mm_camera_2nd_sensor_t second_sensor; /*second sensor info */
- pthread_mutex_t cam_lock;
- pthread_mutex_t cb_lock; /* lock for evt cb */
- mm_channel_t ch[MM_CAMERA_CHANNEL_MAX];
- mm_camera_evt_obj_t evt[MM_CAMERA_EVT_TYPE_MAX];
- uint32_t evt_type_mask;
- mm_camear_mem_vtbl_t *mem_vtbl; /* vtable for memory management */
- mm_camera_poll_thread_t evt_poll_thread; /* evt poll thread */
- mm_camera_cmd_thread_t evt_thread; /* thread for evt CB */
- mm_camera_cmd_thread_t async_cmd_thread; /* thread for async cmd */
- mm_camera_vtbl_t vtbl;
-
- /* some local variables */
- uint32_t snap_burst_num_by_user;
- camera_mode_t current_mode;
- uint32_t op_mode;
- cam_ctrl_dimension_t dim;
-} mm_camera_obj_t;
-
-typedef struct {
- mm_camera_info_t camera[MSM_MAX_CAMERA_SENSORS];
- int8_t num_cam;
- char video_dev_name[MSM_MAX_CAMERA_SENSORS][MM_CAMERA_DEV_NAME_LEN];
- mm_camera_obj_t *cam_obj[MSM_MAX_CAMERA_SENSORS];
-} mm_camera_ctrl_t;
-
-/**********************************************************************************
-* external function declare
-***********************************************************************************/
-/* utility functions */
-/* set int32_t value */
-extern int32_t mm_camera_util_s_ctrl(int32_t fd,
- uint32_t id,
- int32_t value);
-
-extern int32_t mm_camera_util_private_s_ctrl( int32_t fd,
- uint32_t id, void* value);
-
-/* get int32_t value */
-extern int32_t mm_camera_util_g_ctrl(int32_t fd,
- uint32_t id,int32_t *value);
-
-/* send msg throught domain socket for fd mapping */
-extern int32_t mm_camera_util_sendmsg(mm_camera_obj_t *my_obj,
- void *msg,
- uint32_t buf_size,
- int sendfd);
-
-/* mm-camera */
-extern int32_t mm_camera_open(mm_camera_obj_t *my_obj);
-extern int32_t mm_camera_close(mm_camera_obj_t *my_obj);
-extern uint8_t mm_camera_is_event_supported(mm_camera_obj_t *my_obj,
- mm_camera_event_type_t evt_type);
-extern int32_t mm_camera_register_event_notify(mm_camera_obj_t *my_obj,
- mm_camera_event_notify_t evt_cb,
- void * user_data,
- mm_camera_event_type_t evt_type);
-extern int32_t mm_camera_qbuf(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- mm_camera_buf_def_t *buf);
-extern mm_camera_2nd_sensor_t * mm_camera_query_2nd_sensor_info(mm_camera_obj_t *my_obj);
-extern int32_t mm_camera_sync(mm_camera_obj_t *my_obj);
-extern int32_t mm_camera_is_op_supported(mm_camera_obj_t *my_obj,
- mm_camera_ops_type_t opcode);
-extern int32_t mm_camera_is_parm_supported(mm_camera_obj_t *my_obj,
- mm_camera_parm_type_t parm_type,
- uint8_t *support_set_parm,
- uint8_t *support_get_parm);
-extern int32_t mm_camera_set_parm(mm_camera_obj_t *my_obj,
- mm_camera_parm_type_t parm_type,
- void* p_value);
-extern int32_t mm_camera_get_parm(mm_camera_obj_t *my_obj,
- mm_camera_parm_type_t parm_type,
- void* p_value);
-extern uint32_t mm_camera_add_channel(mm_camera_obj_t *my_obj);
-extern void mm_camera_del_channel(mm_camera_obj_t *my_obj,
- uint32_t ch_id);
-extern uint32_t mm_camera_add_stream(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- mm_camera_buf_notify_t buf_cb, void *user_data,
- uint32_t ext_image_mode, uint32_t sensor_idx);
-extern int32_t mm_camera_del_stream(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t stream_id);
-extern int32_t mm_camera_config_stream(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t stream_id,
- mm_camera_stream_config_t *config);
-extern int32_t mm_camera_bundle_streams(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- mm_camera_buf_notify_t super_frame_notify_cb,
- void *user_data,
- mm_camera_bundle_attr_t *attr,
- uint8_t num_streams,
- uint32_t *stream_ids);
-extern int32_t mm_camera_destroy_bundle(mm_camera_obj_t *my_obj,
- uint32_t ch_id);
-extern int32_t mm_camera_start_streams(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids);
-extern int32_t mm_camera_stop_streams(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids);
-extern int32_t mm_camera_async_teardown_streams(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids);
-extern int32_t mm_camera_request_super_buf(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t num_buf_requested);
-extern int32_t mm_camera_cancel_super_buf_request(mm_camera_obj_t *my_obj,
- uint32_t ch_id);
-extern int32_t mm_camera_start_focus(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t sensor_idx,
- uint32_t focus_mode);
-extern int32_t mm_camera_abort_focus(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t sensor_idx);
-extern int32_t mm_camera_prepare_snapshot(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t sensor_idx);
-extern int32_t mm_camera_set_stream_parm(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t s_id,
- mm_camera_stream_parm_t parm_type,
- void* p_value);
-
-extern int32_t mm_camera_get_stream_parm(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t s_id,
- mm_camera_stream_parm_t parm_type,
- void* p_value);
-
-extern int32_t mm_camera_register_event_notify_internal(
- mm_camera_obj_t *my_obj,
- mm_camera_event_notify_t evt_cb,
- void * user_data,
- mm_camera_event_type_t evt_type);
-extern int32_t mm_camera_map_buf(mm_camera_obj_t *my_obj,
- int ext_mode,
- int idx,
- int fd,
- uint32_t size);
-extern int32_t mm_camera_unmap_buf(mm_camera_obj_t *my_obj,
- int ext_mode,
- int idx);
-extern int32_t mm_camera_send_ch_event(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t stream_id,
- mm_camera_ch_event_type_t evt);
-extern int32_t mm_camera_send_private_ioctl(mm_camera_obj_t *my_obj,
- uint32_t cmd_id,
- uint32_t cmd_length,
- void *cmd);
-extern int32_t mm_camera_open_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- mm_camera_repro_isp_type_t repro_isp_type,
- uint32_t *repro_isp_handle);
-extern int32_t mm_camera_config_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- mm_camera_repro_isp_config_t *config);
-extern int32_t mm_camera_attach_stream_to_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id);
-extern int32_t mm_camera_start_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id);
-extern int32_t mm_camera_reprocess(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- mm_camera_repro_data_t *repo_data);
-extern int32_t mm_camera_stop_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id);
-extern int32_t mm_camera_detach_stream_from_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id);
-extern int32_t mm_camera_close_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle);
-
-extern uint8_t mm_camera_util_get_pp_mask(mm_camera_obj_t *my_obj);
-
-/* mm_channel */
-extern int32_t mm_channel_fsm_fn(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val);
-
-/* qbuf is a special case that not going through state machine.
- * This is to avoid deadlock when trying to aquire ch_lock,
- * from the context of dataCB, but async stop is holding ch_lock */
-extern int32_t mm_channel_qbuf(mm_channel_t *my_obj,
- mm_camera_buf_def_t *buf);
-
-/* Allow other stream to register dataCB at certain stream.
- * This is for use case of video sized live snapshot,
- * because snapshot stream need register one time CB at video stream.
- * ext_image_mode and sensor_idx are used to identify the destinate stream
- * to be register with dataCB. */
-extern int32_t mm_channel_reg_stream_cb(mm_channel_t *my_obj,
- mm_stream_data_cb_t *cb,
- uint32_t ext_image_mode,
- uint32_t sensor_idx);
-
-/* mm_stream */
-extern int32_t mm_stream_fsm_fn(mm_stream_t *my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val);
-/* Allow other stream to register dataCB at certain stream.
- * This is for use case of video sized live snapshot,
- * because snapshot stream need register one time CB at video stream.
- * ext_image_mode and sensor_idx are used to identify the destinate stream
- * to be register with dataCB. */
-extern int32_t mm_stream_reg_buf_cb(mm_stream_t *my_obj,
- mm_stream_data_cb_t *val);
-
-/* utiltity fucntion declared in mm-camera-inteface2.c
- * and need be used by mm-camera and below*/
-uint32_t mm_camera_util_generate_handler(uint8_t index);
-const char * mm_camera_util_get_dev_name(uint32_t cam_handler);
-uint8_t mm_camera_util_get_index_by_handler(uint32_t handler);
-
-/* queue functions */
-extern int32_t mm_camera_queue_init(mm_camera_queue_t* queue);
-extern int32_t mm_camera_queue_enq(mm_camera_queue_t* queue, void* node);
-extern void* mm_camera_queue_deq(mm_camera_queue_t* queue);
-extern int32_t mm_camera_queue_deinit(mm_camera_queue_t* queue);
-extern int32_t mm_camera_queue_flush(mm_camera_queue_t* queue);
-
-/* poll/cmd thread functions */
-extern int32_t mm_camera_poll_thread_launch(
- mm_camera_poll_thread_t * poll_cb,
- mm_camera_poll_thread_type_t poll_type);
-extern int32_t mm_camera_poll_thread_release(mm_camera_poll_thread_t *poll_cb);
-extern int32_t mm_camera_poll_thread_add_poll_fd(
- mm_camera_poll_thread_t * poll_cb,
- uint32_t handler,
- int32_t fd,
- mm_camera_poll_notify_t nofity_cb,
- void *userdata);
-extern int32_t mm_camera_poll_thread_del_poll_fd(
- mm_camera_poll_thread_t * poll_cb,
- uint32_t handler);
-extern int32_t mm_camera_cmd_thread_launch(
- mm_camera_cmd_thread_t * cmd_thread,
- mm_camera_cmd_cb_t cb,
- void* user_data);
-extern int32_t mm_camera_cmd_thread_release(mm_camera_cmd_thread_t * cmd_thread);
-
-#endif /* __MM_CAMERA_H__ */
diff --git a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_dbg.h b/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_dbg.h
deleted file mode 100755
index fcb7028..0000000
--- a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_dbg.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#ifndef __MM_CAMERA_DBG_H__
-#define __MM_CAMERA_DBG_H__
-
-//#define LOG_DEBUG 1
-
-#ifndef LOG_DEBUG
- #ifdef _ANDROID_
- #undef LOG_NIDEBUG
- #undef LOG_TAG
- #define LOG_NIDEBUG 0
- #define LOG_TAG "mm-camera-intf"
- #include <utils/Log.h>
- #else
- #include <stdio.h>
- #define ALOGE CDBG
- #endif
- #undef CDBG
- #define CDBG(fmt, args...) do{}while(0)
- #define CDBG_ERROR(fmt, args...) ALOGE(fmt, ##args)
-#else
- #ifdef _ANDROID_
- #undef LOG_NIDEBUG
- #undef LOG_TAG
- #define LOG_NIDEBUG 0
- #define LOG_TAG "mm-camera-intf"
- #include <utils/Log.h>
- #define CDBG(fmt, args...) ALOGE(fmt, ##args)
- #else
- #include <stdio.h>
- #define CDBG(fmt, args...) fprintf(stderr, fmt, ##args)
- #define ALOGE(fmt, args...) fprintf(stderr, fmt, ##args)
- #endif
-#endif
-
-#ifdef _ANDROID_
- #define CDBG_HIGH(fmt, args...) ALOGE(fmt, ##args)
- #define CDBG_ERROR(fmt, args...) ALOGE(fmt, ##args)
-#else
- #define CDBG_HIGH(fmt, args...) fprintf(stderr, fmt, ##args)
- #define CDBG_ERROR(fmt, args...) fprintf(stderr, fmt, ##args)
-#endif
-#endif /* __MM_CAMERA_DBG_H__ */
diff --git a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_interface.h b/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_interface.h
deleted file mode 100755
index efaba9e..0000000
--- a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_interface.h
+++ /dev/null
@@ -1,451 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#ifndef __MM_CAMERA_INTERFACE_H__
-#define __MM_CAMERA_INTERFACE_H__
-#include <linux/msm_ion.h>
-#include <camera.h>
-#include "QCamera_Intf.h"
-#include "cam_list.h"
-
-#define MM_CAMERA_MAX_NUM_FRAMES 16
-#define MM_CAMERA_MAX_2ND_SENSORS 4
-
-typedef enum {
- MM_CAMERA_OPS_LOCAL = -1, /*no need to query mm-camera*/
- MM_CAMERA_OPS_STREAMING_PREVIEW = 0,
- MM_CAMERA_OPS_STREAMING_ZSL,
- MM_CAMERA_OPS_STREAMING_VIDEO,
- MM_CAMERA_OPS_CAPTURE, /*not supported*/
- MM_CAMERA_OPS_FOCUS,
- MM_CAMERA_OPS_GET_PICTURE, /*5*/
- MM_CAMERA_OPS_PREPARE_SNAPSHOT,
- MM_CAMERA_OPS_SNAPSHOT,
- MM_CAMERA_OPS_LIVESHOT,
- MM_CAMERA_OPS_RAW_SNAPSHOT,
- MM_CAMERA_OPS_VIDEO_RECORDING, /*10*/
- MM_CAMERA_OPS_REGISTER_BUFFER,
- MM_CAMERA_OPS_UNREGISTER_BUFFER,
- MM_CAMERA_OPS_CAPTURE_AND_ENCODE,
- MM_CAMERA_OPS_RAW_CAPTURE,
- MM_CAMERA_OPS_ENCODE, /*15*/
- MM_CAMERA_OPS_ZSL_STREAMING_CB,
- /* add new above*/
- MM_CAMERA_OPS_MAX
-}mm_camera_ops_type_t;
-
-typedef enum {
- MM_CAMERA_STREAM_OFFSET,
- MM_CAMERA_STREAM_CID,
- MM_CAMERA_STREAM_CROP
-}mm_camera_stream_parm_t;
-
-typedef struct {
- int32_t width;
- int32_t height;
-} mm_camera_dimension_t;
-
-typedef struct{
- uint32_t tbl_size;
- struct camera_size_type *sizes_tbl;
-}default_sizes_tbl_t;
-
-typedef struct {
- int32_t left;
- int32_t top;
- int32_t width;
- int32_t height;
-} mm_camera_rect_t;
-
-/* TBD: meta header needs to move to msm_camear.h */
-typedef enum {
- /* no meta data header used */
- MM_CAMEAR_META_DATA_TYPE_DEF,
- /* has focus flag, exposure idx,
- * flash flag, etc. TBD */
- MM_CAMEAR_META_DATA_TYPE_BRACKETING,
- MM_CAMEAR_META_DATA_TYPE_MAX,
-} mm_camera_meta_header_t;
-
-typedef struct {
- cam_format_t fmt;
- mm_camera_meta_header_t meta_header;
- uint32_t width;
- uint32_t height;
- uint8_t rotation;
-} mm_camera_image_fmt_t;
-
-typedef struct {
- /* image format */
- mm_camera_image_fmt_t fmt;
-
- /* num of buffers needed */
- uint8_t num_of_bufs;
-
- /* flag to indicate if this stream need stream on */
- uint8_t need_stream_on;
-
- /* num of CB needs to be registered on other stream,
- * this field is valid only when need_stream_on is 0.
- * When need_stream_on = 1, num_stream_cb_times will be ignored. */
- uint8_t num_stream_cb_times;
-} mm_camera_stream_config_t;
-
-typedef struct {
- uint8_t name[32];
- int32_t min_value;
- int32_t max_value;
- int32_t step;
- int32_t default_value;
-} mm_camera_ctrl_cap_sharpness_t;
-
-typedef struct {
- int16_t *zoom_ratio_tbl;
- int32_t size;
-} mm_camera_zoom_tbl_t;
-
-typedef enum {
- /* ZSL use case: get burst of frames */
- MM_CAMERA_SUPER_BUF_NOTIFY_BURST = 0,
- /* get continuous frames: when the super buf is
- * ready dispatch it to HAL */
- MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS,
- MM_CAMERA_SUPER_BUF_NOTIFY_MAX
-} mm_camera_super_buf_notify_mode_t;
-
-typedef enum {
- /* save the frame. No matter focused or not */
- MM_CAMERA_SUPER_BUF_PRIORITY_NORMAL = 0,
- /* only queue the frame that is focused. Will enable
- * meta data header to carry focus info*/
- MM_CAMERA_SUPER_BUF_PRIORITY_FOCUS,
- /* after shutter, only queue matched exposure index */
- MM_CAMERA_SUPER_BUF_PRIORITY_EXPOSURE_BRACKETING,
- MM_CAMERA_SUPER_BUF_PRIORITY_MAX
-} mm_camera_super_buf_priority_t;
-
-typedef struct {
- mm_camera_super_buf_notify_mode_t notify_mode;
- /* queue depth. Only for burst mode */
- uint8_t water_mark;
- /* look back how many frames from last buf */
- uint8_t look_back;
- /* after send first frame to HAL, how many frames
- * needing to be skipped for next delivery? */
- uint8_t post_frame_skip;
- /* save matched priority frames only */
- mm_camera_super_buf_priority_t priority;
- /* in burst mode, how many super
- * bufs for each shutter press? */
- uint8_t burst_num;
-} mm_camera_bundle_attr_t;
-
-typedef struct {
- uint8_t camera_id; /* camera id */
- camera_info_t camera_info; /* postion, mount_angle, etc. */
- enum sensor_type_t main_sensor_type; /* BAYER, YUV, JPEG_SOC, etc. */
- char *video_dev_name; /* device node name, e.g. /dev/video1 */
-} mm_camera_info_t;
-
-typedef struct {
- uint8_t cid;
- uint8_t dt;
-}stream_cid_t;
-
-/* the stats struct will need rework after
- * defining the stats buf sharing logic */
-typedef struct {
- int type;
- uint32_t length;
- void *value;
-} mm_camera_stats_t;
-
-typedef struct {
- uint32_t stream_id; /* stream handler */
- int8_t buf_idx; /* buf idx within the stream bufs */
-
- struct timespec ts; /* time stamp, to be filled when DQBUF*/
- uint32_t frame_idx; /* frame sequence num, to be filled when DQBUF */
-
- int8_t num_planes; /* num of planes, to be filled during mem allocation */
- struct v4l2_plane planes[VIDEO_MAX_PLANES]; /* plane info, to be filled during mem allocation*/
- int fd; /* fd of the frame, to be filled during mem allocation */
- void *buffer; /* ptr to real frame buffer, to be filled during mem allocation */
- uint32_t frame_len; /* len of the whole frame, to be filled during mem allocation */
- void *mem_info; /* reserved for pointing to mem info */
- cam_exif_tags_t *p_mobicat_info; /*for mobicat info*/
-} mm_camera_buf_def_t;
-
-typedef struct {
- uint32_t camera_handle;
- uint32_t ch_id;
- uint8_t num_bufs;
- mm_camera_buf_def_t* bufs[MM_CAMEAR_MAX_STRAEM_BUNDLE];
-} mm_camera_super_buf_t;
-
-typedef void (*mm_camera_event_notify_t)(uint32_t camera_handle,
- mm_camera_event_t *evt,
- void *user_data);
-
-typedef void (*mm_camera_buf_notify_t) (mm_camera_super_buf_t *bufs,
- void *user_data);
-typedef cam_frame_len_offset_t mm_camera_frame_len_offset;
-
-typedef struct {
- void *user_data;
- int32_t (*get_buf) (uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
- int32_t (*put_buf) (uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
-} mm_camear_mem_vtbl_t;
-
-typedef struct {
- uint8_t num_2nd_sensors;
- uint8_t sensor_idxs[MM_CAMERA_MAX_2ND_SENSORS];
-} mm_camera_2nd_sensor_t;
-
-typedef enum {
- NATIVE_CMD_ID_SOCKET_MAP,
- NATIVE_CMD_ID_SOCKET_UNMAP,
- NATIVE_CMD_ID_IOCTL_CTRL,
- NATIVE_CMD_ID_MAX
-} mm_camera_native_cmd_id_t;
-
-typedef enum {
- MM_CAMERA_CMD_TYPE_PRIVATE, /* OEM private ioctl */
- MM_CAMERA_CMD_TYPE_NATIVE /* native ctrl cmd through ioctl */
-} mm_camera_cmd_type_t;
-
-typedef struct {
- mm_camera_buf_def_t *src_frame; /* src frame */
-} mm_camera_repro_data_t;
-
-typedef mm_camera_repro_cmd_config_t mm_camera_repro_isp_config_t;
-
-typedef struct {
- /* to sync the internal camera settings */
- int32_t (*sync) (uint32_t camera_handle);
- uint8_t (*is_event_supported) (uint32_t camera_handle,
- mm_camera_event_type_t evt_type);
- int32_t (*register_event_notify) (uint32_t camera_handle,
- mm_camera_event_notify_t evt_cb,
- void * user_data,
- mm_camera_event_type_t evt_type);
- int32_t (*qbuf) (uint32_t camera_handle, uint32_t ch_id,
- mm_camera_buf_def_t *buf);
- void (*camera_close) (uint32_t camera_handle);
- /* Only fo supporting advanced 2nd sensors. If no secondary sensor needed
- * HAL can ignore this function */
- mm_camera_2nd_sensor_t * (*query_2nd_sensor_info) (uint32_t camera_handle);
-
- /* if the operation is supported: TRUE - support, FALSE - not support */
- uint8_t (*is_op_supported)(uint32_t camera_handle, mm_camera_ops_type_t opcode);
-
- /* if the parm is supported: TRUE - support, FALSE - not support */
- int32_t (*is_parm_supported) (uint32_t camera_handle,
- mm_camera_parm_type_t parm_type,
- uint8_t *support_set_parm,
- uint8_t *support_get_parm);
- /* set a parm current value */
- int32_t (*set_parm) (uint32_t camera_handle,
- mm_camera_parm_type_t parm_type,
- void* p_value);
- /* get a parm current value */
- int32_t (*get_parm) (uint32_t camera_handle,
- mm_camera_parm_type_t parm_type,
- void* p_value);
- /* ch_id returned, zero is invalid ch_id */
- uint32_t (*ch_acquire) (uint32_t camera_handle);
- /* relaese channel */
- void (*ch_release) (uint32_t camera_handle, uint32_t ch_id);
- /* return stream_id. zero is invalid stream_id
- * default set to preview: ext_image_mode = 0
- * default set to primary sensor: sensor_idx = 0
- * value of ext_image_mode is defined in msm_camera.h
- */
- uint32_t (*add_stream) (uint32_t camera_handle, uint32_t ch_id,
- mm_camera_buf_notify_t buf_cb, void *user_data,
- uint32_t ext_image_mode, uint32_t sensor_idx);
- /* delete stream */
- int32_t (*del_stream) (uint32_t camera_handle, uint32_t ch_id,
- uint32_t stream_id);
- /* set straem format This will trigger getting bufs from HAL */
- int32_t (*config_stream) (uint32_t camera_handle, uint32_t ch_id,
- uint32_t stream_id,
- mm_camera_stream_config_t *config);
- /* setup super buf bundle for ZSL(with burst mode) or other use cases */
- int32_t (*init_stream_bundle) (uint32_t camera_handle, uint32_t ch_id,
- mm_camera_buf_notify_t super_frame_notify_cb,
- void *user_data, mm_camera_bundle_attr_t *attr,
- uint8_t num_streams, uint32_t *stream_ids);
- /* remove the super buf bundle */
- int32_t (*destroy_stream_bundle) (uint32_t camera_handle, uint32_t ch_id);
- /* start streaming */
- int32_t (*start_streams) (uint32_t camera_handle, uint32_t ch_id,
- uint8_t num_streams, uint32_t *stream_ids);
- /* stop streaming */
- int32_t (*stop_streams) (uint32_t camera_handle, uint32_t ch_id,
- uint8_t num_streams, uint32_t *stream_ids);
- /* tear down streams asyncly */
- int32_t (*async_teardown_streams) (uint32_t camera_handle, uint32_t ch_id,
- uint8_t num_streams, uint32_t *stream_ids);
- /* get super bufs. for burst mode only */
- int32_t (*request_super_buf) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t num_buf_requested);
- /* abort the super buf dispatching. for burst mode only */
- int32_t (*cancel_super_buf_request) (uint32_t camera_handle,
- uint32_t ch_id);
- /* start focus: by default sensor_idx=0 */
- int32_t (*start_focus) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t sensor_idx,
- uint32_t focus_mode);
- /* abort focus: by default sensor_idx=0 */
- int32_t (*abort_focus) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t sensor_idx);
- /* prepare hardware will settle aec and flash.
- * by default sensor_idx=0 */
- int32_t (*prepare_snapshot) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t sensor_idx);
- /* set a parm current value of a stream */
- int32_t (*set_stream_parm) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t s_id,
- mm_camera_stream_parm_t parm_type,
- void *p_value);
- /* get a parm current value of a stream */
- int32_t (*get_stream_parm) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t s_id,
- mm_camera_stream_parm_t parm_type,
- void *p_value);
- /* private communication tunnel */
- int32_t (*send_command) (uint32_t camera_handle,
- mm_camera_cmd_type_t cmd_type,
- uint32_t cmd_id,
- uint32_t cmd_length,
- void *cmd);
- /* open a re-process isp, return handler for repro isp (>0).
- * if failed, reutrn 0 */
- uint32_t (*open_repro_isp) (uint32_t camera_handle,
- uint32_t ch_id,
- mm_camera_repro_isp_type_t repro_isp_type);
- /* config the re-process isp */
- int32_t (*config_repro_isp) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- mm_camera_repro_isp_config_t *config);
- /* attach output stream to the re-process isp */
- int32_t (*attach_stream_to_repro_isp) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id);
- /* start a re-process isp. */
- int32_t (*start_repro_isp) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id);
- /* start a reprocess job for a src frame.
- * Only after repo_isp is started, reprocess API can be called */
- int32_t (*reprocess) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- mm_camera_repro_data_t *repo_data);
- /* stop a re-process isp */
- int32_t (*stop_repro_isp) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id);
- /* detach an output stream from the re-process isp.
- * Can only be called after the re-process isp is stopped */
- int32_t (*detach_stream_from_repro_isp) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id);
- /* close a re-process isp.
- * Can only close after all dest streams are detached from it */
- int32_t (*close_repro_isp) (uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle);
-} mm_camera_ops_t;
-
-typedef struct {
- uint32_t camera_handle; /* camera object handle */
- mm_camera_info_t *camera_info; /* reference pointer of camear info */
- mm_camera_ops_t *ops; /* API call table */
-} mm_camera_vtbl_t;
-
-mm_camera_info_t * camera_query(uint8_t *num_cameras);
-mm_camera_vtbl_t * camera_open(uint8_t camera_idx,
- mm_camear_mem_vtbl_t *mem_vtbl);
-
-//extern void mm_camera_util_profile(const char *str);
-
-typedef enum {
- MM_CAMERA_PREVIEW,
- MM_CAMERA_VIDEO,
- MM_CAMERA_SNAPSHOT_MAIN,
- MM_CAMERA_SNAPSHOT_THUMBNAIL,
- MM_CAMERA_SNAPSHOT_RAW,
- MM_CAMERA_RDI,
- MM_CAMERA_RDI1,
- MM_CAMERA_RDI2,
- MM_CAMERA_SAEC,
- MM_CAMERA_SAWB,
- MM_CAMERA_SAFC,
- MM_CAMERA_IHST,
- MM_CAMERA_CS,
- MM_CAMERA_RS,
- MM_CAMERA_CSTA,
- MM_CAMERA_ISP_PIX_OUTPUT1,
- MM_CAMERA_ISP_PIX_OUTPUT2,
- MM_CAMERA_IMG_MODE_MAX
-} mm_camera_img_mode;
-
-/* may remove later */
-typedef enum {
- MM_CAMERA_OP_MODE_NOTUSED,
- MM_CAMERA_OP_MODE_CAPTURE,
- MM_CAMERA_OP_MODE_VIDEO,
- MM_CAMERA_OP_MODE_ZSL,
- MM_CAMERA_OP_MODE_RAW,
- MM_CAMERA_OP_MODE_MAX
-} mm_camera_op_mode_type_t;
-
-#endif /*__MM_CAMERA_INTERFACE_H__*/
diff --git a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_sock.h b/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_sock.h
deleted file mode 100755
index 0846c05..0000000
--- a/camera/QCamera/stack/mm-camera-interface/inc/mm_camera_sock.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#ifndef __MM_CAMERA_SOCKET_H__
-#define __MM_CAMERA_SOCKET_H__
-
-#include <inttypes.h>
-
-typedef enum {
- MM_CAMERA_SOCK_TYPE_UDP,
- MM_CAMERA_SOCK_TYPE_TCP,
-} mm_camera_sock_type_t;
-
-int mm_camera_socket_create(int cam_id, mm_camera_sock_type_t sock_type);
-
-int mm_camera_socket_sendmsg(
- int fd,
- void *msg,
- uint32_t buf_size,
- int sendfd);
-
-int mm_camera_socket_recvmsg(
- int fd,
- void *msg,
- uint32_t buf_size,
- int *rcvdfd);
-
-void mm_camera_socket_close(int fd);
-
-#endif /*__MM_CAMERA_SOCKET_H__*/
-
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera.c
deleted file mode 100755
index 42b9215..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera.c
+++ /dev/null
@@ -1,2168 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_sock.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-#define SET_PARM_BIT32(parm, parm_arr) \
- (parm_arr[parm/32] |= (1<<(parm%32)))
-
-#define GET_PARM_BIT32(parm, parm_arr) \
- ((parm_arr[parm/32]>>(parm%32))& 0x1)
-
-/* internal function declare */
-int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
- cam_ctrl_type type,
- uint32_t length,
- void *value);
-int32_t mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,
- cam_ctrl_type type,
- uint32_t length,
- void *value,
- int timeout);
-int mm_camera_evt_sub(mm_camera_obj_t * my_obj,
- mm_camera_event_type_t evt_type,
- int reg_count);
-int32_t mm_camera_set_general_parm(mm_camera_obj_t * my_obj,
- mm_camera_parm_type_t parm_type,
- void* p_value);
-int32_t mm_camera_enqueue_evt(mm_camera_obj_t *my_obj,
- mm_camera_event_t *event);
-extern int32_t mm_channel_init(mm_channel_t *my_obj);
-
-mm_channel_t * mm_camera_util_get_channel_by_handler(
- mm_camera_obj_t * cam_obj,
- uint32_t handler)
-{
- int i;
- mm_channel_t *ch_obj = NULL;
- uint8_t ch_idx = mm_camera_util_get_index_by_handler(handler);
-
- for(i = 0; i < MM_CAMERA_CHANNEL_MAX; i++) {
- if (handler == cam_obj->ch[i].my_hdl) {
- ch_obj = &cam_obj->ch[i];
- break;
- }
- }
- return ch_obj;
-}
-
-static void mm_camera_dispatch_app_event(mm_camera_cmdcb_t *cmd_cb,
- void* user_data)
-{
- int i;
- mm_camera_event_type_t evt_type = cmd_cb->u.evt.event_type;
- mm_camera_event_t *event = &cmd_cb->u.evt;
- mm_camera_obj_t * my_obj = (mm_camera_obj_t *)user_data;
- if (NULL != my_obj) {
- if (evt_type < MM_CAMERA_EVT_TYPE_MAX) {
- pthread_mutex_lock(&my_obj->cb_lock);
- for(i = 0; i < MM_CAMERA_EVT_ENTRY_MAX; i++) {
- if(my_obj->evt[evt_type].evt[i].evt_cb) {
- my_obj->evt[evt_type].evt[i].evt_cb(
- my_obj->my_hdl,
- event,
- my_obj->evt[evt_type].evt[i].user_data);
- }
- }
- pthread_mutex_unlock(&my_obj->cb_lock);
- }
- }
-}
-
-static void mm_camera_handle_async_cmd(mm_camera_cmdcb_t *cmd_cb,
- void* user_data)
-{
- int i;
- mm_camera_async_cmd_t *async_cmd = &cmd_cb->u.async;
- mm_camera_obj_t * my_obj = NULL;
- mm_evt_payload_stop_stream_t payload;
-
- my_obj = (mm_camera_obj_t *)user_data;
- if (NULL != my_obj) {
- if (MM_CAMERA_ASYNC_CMD_TYPE_STOP == async_cmd->cmd_type) {
- memset(&payload, 0, sizeof(mm_evt_payload_stop_stream_t));
- payload.num_streams = async_cmd->u.stop_cmd.num_streams;
- payload.stream_ids = async_cmd->u.stop_cmd.stream_ids;
- mm_channel_fsm_fn(async_cmd->u.stop_cmd.ch_obj,
- MM_CHANNEL_EVT_TEARDOWN_STREAM,
- (void*)&payload,
- NULL);
- }
- }
-}
-
-static void mm_camera_event_notify(void* user_data)
-{
- struct v4l2_event ev;
- int rc;
- mm_camera_event_t *evt = NULL;
- mm_camera_cmdcb_t *node = NULL;
-
- mm_camera_obj_t *my_obj = (mm_camera_obj_t*)user_data;
- if (NULL != my_obj) {
- /* read evt */
- memset(&ev, 0, sizeof(ev));
- rc = ioctl(my_obj->ctrl_fd, VIDIOC_DQEVENT, &ev);
- evt = (mm_camera_event_t *)ev.u.data;
-
- if (rc >= 0) {
- if(ev.type == V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_ERROR_EVENT) {
- evt->event_type = MM_CAMERA_EVT_TYPE_CTRL;
- evt->e.ctrl.evt = MM_CAMERA_CTRL_EVT_ERROR;
- node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL != node) {
- memset(node, 0, sizeof(mm_camera_cmdcb_t));
- node->cmd_type = MM_CAMERA_CMD_TYPE_EVT_CB;
- memcpy(&node->u.evt, evt, sizeof(mm_camera_event_t));
- }
- } else {
- switch (evt->event_type) {
- case MM_CAMERA_EVT_TYPE_CH:
- case MM_CAMERA_EVT_TYPE_CTRL:
- case MM_CAMERA_EVT_TYPE_STATS:
- case MM_CAMERA_EVT_TYPE_INFO:
- {
- node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL != node) {
- memset(node, 0, sizeof(mm_camera_cmdcb_t));
- node->cmd_type = MM_CAMERA_CMD_TYPE_EVT_CB;
- memcpy(&node->u.evt, evt, sizeof(mm_camera_event_t));
- }
- }
- break;
- case MM_CAMERA_EVT_TYPE_PRIVATE_EVT:
- {
- CDBG("%s: MM_CAMERA_EVT_TYPE_PRIVATE_EVT", __func__);
- struct msm_camera_v4l2_ioctl_t v4l2_ioctl;
- int32_t length =
- sizeof(mm_camera_cmdcb_t) + evt->e.pri_evt.data_length;
- node = (mm_camera_cmdcb_t *)malloc(length);
- if (NULL != node) {
- memset(node, 0, length);
- node->cmd_type = MM_CAMERA_CMD_TYPE_EVT_CB;
- memcpy(&node->u.evt, evt, sizeof(mm_camera_event_t));
-
- if (evt->e.pri_evt.data_length > 0) {
- CDBG("%s: data_length =%d (trans_id=%d), dequeue payload",
- __func__, evt->e.pri_evt.data_length,
- node->u.evt.e.pri_evt.trans_id);
- /* dequeue event payload if length > 0 */
- memset(&v4l2_ioctl, 0, sizeof(v4l2_ioctl));
- v4l2_ioctl.trans_code = node->u.evt.e.pri_evt.trans_id;
- v4l2_ioctl.len = node->u.evt.e.pri_evt.data_length;
- v4l2_ioctl.ioctl_ptr = &(node->u.evt.e.pri_evt.evt_data[0]);
- rc = ioctl(my_obj->ctrl_fd, MSM_CAM_V4L2_IOCTL_GET_EVENT_PAYLOAD,
- &v4l2_ioctl);
- if (rc < 0) {
- CDBG_ERROR("%s: get event payload returns error = %d",
- __func__, rc);
- free(node);
- node = NULL;
- } else {
- CDBG("%s: data_length =%d (trans_id=%d) (payload=%s)",
- __func__, evt->e.pri_evt.data_length,
- node->u.evt.e.pri_evt.trans_id,
- (char*)&node->u.evt.e.pri_evt.evt_data[0]);
- }
- }
- }
- }
- break;
- default:
- break;
- }
- }
- if (NULL != node) {
- /* enqueue to evt cmd thread */
- mm_camera_queue_enq(&(my_obj->evt_thread.cmd_queue), node);
- /* wake up evt cmd thread */
- sem_post(&(my_obj->evt_thread.cmd_sem));
- }
- }
- }
-}
-
-int32_t mm_camera_enqueue_evt(mm_camera_obj_t *my_obj,
- mm_camera_event_t *event)
-{
- int32_t rc = 0;
- mm_camera_cmdcb_t *node = NULL;
-
- node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL != node) {
- memset(node, 0, sizeof(mm_camera_cmdcb_t));
- node->cmd_type = MM_CAMERA_CMD_TYPE_EVT_CB;
- memcpy(&node->u.evt, event, sizeof(mm_camera_event_t));
-
- /* enqueue to evt cmd thread */
- mm_camera_queue_enq(&(my_obj->evt_thread.cmd_queue), node);
- /* wake up evt cmd thread */
- sem_post(&(my_obj->evt_thread.cmd_sem));
- } else {
- CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
- rc = -1;
- }
-
- return rc;
-}
-
-/* send local CH evt to HAL
- * may not needed since we have return val for each channel/stream operation */
-int32_t mm_camera_send_ch_event(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t stream_id,
- mm_camera_ch_event_type_t evt)
-{
- int rc = 0;
- mm_camera_event_t event;
- event.event_type = MM_CAMERA_EVT_TYPE_CH;
- event.e.ch.evt = evt;
- /* TODO: need to change the ch evt struct to include ch_id and stream_id. */
- event.e.ch.ch = stream_id;
- CDBG("%s: stream on event, type=0x%x, ch=%d, evt=%d",
- __func__, event.event_type, event.e.ch.ch, event.e.ch.evt);
- rc = mm_camera_enqueue_evt(my_obj, &event);
- return rc;
-}
-
-int32_t mm_camera_open(mm_camera_obj_t *my_obj)
-{
- char dev_name[MM_CAMERA_DEV_NAME_LEN];
- int32_t rc = 0;
- int8_t n_try=MM_CAMERA_DEV_OPEN_TRIES;
- uint8_t sleep_msec=MM_CAMERA_DEV_OPEN_RETRY_SLEEP;
- uint8_t i;
- uint8_t cam_idx = mm_camera_util_get_index_by_handler(my_obj->my_hdl);
-
- CDBG("%s: begin\n", __func__);
-
- snprintf(dev_name, sizeof(dev_name), "/dev/%s",
- mm_camera_util_get_dev_name(my_obj->my_hdl));
-
- do{
- n_try--;
- my_obj->ctrl_fd = open(dev_name, O_RDWR | O_NONBLOCK);
- CDBG("%s: ctrl_fd = %d, errno == %d", __func__, my_obj->ctrl_fd, errno);
- if((my_obj->ctrl_fd > 0) || (errno != EIO) || (n_try <= 0 )) {
- CDBG_ERROR("%s: opened, break out while loop", __func__);
- break;
- }
- CDBG("%s:failed with I/O error retrying after %d milli-seconds",
- __func__,sleep_msec);
- usleep(sleep_msec*1000);
- }while(n_try>0);
-
- if (my_obj->ctrl_fd <= 0) {
- CDBG_ERROR("%s: cannot open control fd of '%s' (%s)\n",
- __func__, dev_name, strerror(errno));
- rc = -1;
- goto on_error;
- }
-
- /* open domain socket*/
- n_try=MM_CAMERA_DEV_OPEN_TRIES;
- do{
- n_try--;
- my_obj->ds_fd = mm_camera_socket_create(cam_idx, MM_CAMERA_SOCK_TYPE_UDP);
- CDBG("%s: ds_fd = %d, errno = %d", __func__, my_obj->ds_fd, errno);
- if((my_obj->ds_fd > 0) || (n_try <= 0 )) {
- CDBG("%s: opened, break out while loop", __func__);
- break;
- }
- CDBG("%s:failed with I/O error retrying after %d milli-seconds",
- __func__,sleep_msec);
- usleep(sleep_msec*1000);
- }while(n_try>0);
-
- if (my_obj->ds_fd <= 0) {
- CDBG_ERROR("%s: cannot open domain socket fd of '%s'(%s)\n",
- __func__, dev_name, strerror(errno));
- rc = -1;
- goto on_error;
- }
-
- /* set ctrl_fd to be the mem_mapping fd */
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- MSM_V4L2_PID_MMAP_INST, 0);
- if (rc < 0) {
- CDBG_ERROR("error: ioctl VIDIOC_S_CTRL MSM_V4L2_PID_MMAP_INST failed: %s\n",
- strerror(errno));
- goto on_error;
- }
-
- /* set geo mode to 2D by default */
- my_obj->current_mode = CAMERA_MODE_2D;
-
- pthread_mutex_init(&my_obj->cb_lock, NULL);
-
- CDBG("%s : Launch async cmd Thread in Cam Open",__func__);
- mm_camera_cmd_thread_launch(&my_obj->async_cmd_thread,
- mm_camera_handle_async_cmd,
- (void *)my_obj);
-
- CDBG("%s : Launch evt Thread in Cam Open",__func__);
- mm_camera_cmd_thread_launch(&my_obj->evt_thread,
- mm_camera_dispatch_app_event,
- (void *)my_obj);
-
- /* launch event poll thread
- * we will add evt fd into event poll thread upon user first register for evt */
- CDBG("%s : Launch evt Poll Thread in Cam Open",__func__);
- mm_camera_poll_thread_launch(&my_obj->evt_poll_thread,
- MM_CAMERA_POLL_TYPE_EVT);
-
- CDBG("%s: end (rc = %d)\n", __func__, rc);
- /* we do not need to unlock cam_lock here before return
- * because for open, it's done within intf_lock */
- return rc;
-
-on_error:
- if (my_obj->ctrl_fd > 0) {
- close(my_obj->ctrl_fd);
- my_obj->ctrl_fd = -1;
- }
- if (my_obj->ds_fd > 0) {
- mm_camera_socket_close(my_obj->ds_fd);
- my_obj->ds_fd = -1;
- }
-
- /* we do not need to unlock cam_lock here before return
- * because for open, it's done within intf_lock */
- return rc;
-}
-
-int32_t mm_camera_close(mm_camera_obj_t *my_obj)
-{
- CDBG("%s : Close evt Poll Thread in Cam Close",__func__);
- mm_camera_poll_thread_release(&my_obj->evt_poll_thread);
-
- CDBG("%s : Close evt cmd Thread in Cam Close",__func__);
- mm_camera_cmd_thread_release(&my_obj->evt_thread);
-
- CDBG("%s : Close asyn cmd Thread in Cam Close",__func__);
- mm_camera_cmd_thread_release(&my_obj->async_cmd_thread);
-
- if(my_obj->ctrl_fd > 0) {
- close(my_obj->ctrl_fd);
- my_obj->ctrl_fd = -1;
- }
- if(my_obj->ds_fd > 0) {
- mm_camera_socket_close(my_obj->ds_fd);
- my_obj->ds_fd = -1;
- }
-
- pthread_mutex_destroy(&my_obj->cb_lock);
-
- pthread_mutex_unlock(&my_obj->cam_lock);
- return 0;
-}
-
-uint8_t mm_camera_is_event_supported(mm_camera_obj_t *my_obj, mm_camera_event_type_t evt_type)
-{
- switch(evt_type) {
- case MM_CAMERA_EVT_TYPE_CH:
- case MM_CAMERA_EVT_TYPE_CTRL:
- case MM_CAMERA_EVT_TYPE_STATS:
- case MM_CAMERA_EVT_TYPE_INFO:
- return 1;
- default:
- return 0;
- }
- return 0;
-}
-
-int32_t mm_camera_register_event_notify_internal(
- mm_camera_obj_t *my_obj,
- mm_camera_event_notify_t evt_cb,
- void * user_data,
- mm_camera_event_type_t evt_type)
-{
- int i;
- int rc = -1;
- mm_camera_evt_obj_t *evt_array = NULL;
-
- pthread_mutex_lock(&my_obj->cb_lock);
- evt_array = &my_obj->evt[evt_type];
- if(evt_cb) {
- /* this is reg case */
- for(i = 0; i < MM_CAMERA_EVT_ENTRY_MAX; i++) {
- if(evt_array->evt[i].user_data == NULL) {
- evt_array->evt[i].evt_cb = evt_cb;
- evt_array->evt[i].user_data = user_data;
- evt_array->reg_count++;
- rc = 0;
- break;
- }
- }
- } else {
- /* this is unreg case */
- for(i = 0; i < MM_CAMERA_EVT_ENTRY_MAX; i++) {
- if(evt_array->evt[i].user_data == user_data) {
- evt_array->evt[i].evt_cb = NULL;
- evt_array->evt[i].user_data = NULL;
- evt_array->reg_count--;
- rc = 0;
- break;
- }
- }
- }
-
- if(rc == 0 && evt_array->reg_count <= 1) {
- /* subscribe/unsubscribe event to kernel */
- rc = mm_camera_evt_sub(my_obj, evt_type, evt_array->reg_count);
- }
-
- pthread_mutex_unlock(&my_obj->cb_lock);
- return rc;
-}
-
-int32_t mm_camera_register_event_notify(mm_camera_obj_t *my_obj,
- mm_camera_event_notify_t evt_cb,
- void * user_data,
- mm_camera_event_type_t evt_type)
-{
- int i;
- int rc = -1;
- mm_camera_evt_obj_t *evt_array = &my_obj->evt[evt_type];
-
- rc = mm_camera_register_event_notify_internal(my_obj, evt_cb,
- user_data, evt_type);
-
- pthread_mutex_unlock(&my_obj->cam_lock);
- return rc;
-}
-
-int32_t mm_camera_qbuf(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- mm_camera_buf_def_t *buf)
-{
- int rc = -1;
- mm_channel_t * ch_obj = NULL;
- ch_obj = mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- /* we always assume qbuf will be done before channel/stream is fully stopped
- * because qbuf is done within dataCB context
- * in order to avoid deadlock, we are not locking ch_lock for qbuf */
- if (NULL != ch_obj) {
- rc = mm_channel_qbuf(ch_obj, buf);
- }
-
- return rc;
-}
-
-mm_camera_2nd_sensor_t * mm_camera_query_2nd_sensor_info(mm_camera_obj_t *my_obj)
-{
- /* TODO: need to sync with backend how to get 2nd sensor info */
- return NULL;
-}
-
-int32_t mm_camera_sync(mm_camera_obj_t *my_obj)
-{
- int32_t rc = 0;
-
- /* get camera capabilities */
- memset(&my_obj->properties, 0, sizeof(cam_prop_t));
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_CAPABILITIES,
- sizeof(cam_prop_t),
- (void *)&my_obj->properties);
- if (rc != 0) {
- CDBG_ERROR("%s: cannot get camera capabilities\n", __func__);
- goto on_error;
- }
-
-on_error:
- pthread_mutex_unlock(&my_obj->cam_lock);
- return rc;
-
-}
-
-int32_t mm_camera_is_op_supported(mm_camera_obj_t *my_obj,
- mm_camera_ops_type_t op_code)
-{
- int32_t rc = 0;
- int32_t is_ops_supported = false;
- int index = 0;
-
- if (op_code != MM_CAMERA_OPS_LOCAL) {
- index = op_code/32;
- is_ops_supported = ((my_obj->properties.ops[index] &
- (1<<op_code)) != 0);
-
- }
- pthread_mutex_unlock(&my_obj->cam_lock);
- return is_ops_supported;
-}
-
-int32_t mm_camera_is_parm_supported(mm_camera_obj_t *my_obj,
- mm_camera_parm_type_t parm_type,
- uint8_t *support_set_parm,
- uint8_t *support_get_parm)
-{
- /* TODO: need to sync with backend if it can support set/get */
- int32_t rc = 0;
- *support_set_parm = GET_PARM_BIT32(parm_type,
- my_obj->properties.parm);
- *support_get_parm = GET_PARM_BIT32(parm_type,
- my_obj->properties.parm);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- return rc;
-}
-
-int32_t mm_camera_util_set_op_mode(mm_camera_obj_t * my_obj,
- mm_camera_op_mode_type_t *op_mode)
-{
- int32_t rc = 0;
- int32_t v4l2_op_mode = MSM_V4L2_CAM_OP_DEFAULT;
-
- if (my_obj->op_mode == *op_mode)
- goto end;
- switch(*op_mode) {
- case MM_CAMERA_OP_MODE_ZSL:
- v4l2_op_mode = MSM_V4L2_CAM_OP_ZSL;
- break;
- case MM_CAMERA_OP_MODE_CAPTURE:
- v4l2_op_mode = MSM_V4L2_CAM_OP_CAPTURE;
- break;
- case MM_CAMERA_OP_MODE_VIDEO:
- v4l2_op_mode = MSM_V4L2_CAM_OP_VIDEO;
- break;
- case MM_CAMERA_OP_MODE_RAW:
- v4l2_op_mode = MSM_V4L2_CAM_OP_RAW;
- break;
- default:
- rc = - 1;
- goto end;
- break;
- }
- if(0 != (rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- MSM_V4L2_PID_CAM_MODE, v4l2_op_mode))){
- CDBG_ERROR("%s: input op_mode=%d, s_ctrl rc=%d\n", __func__, *op_mode, rc);
- goto end;
- }
- /* if success update mode field */
- my_obj->op_mode = *op_mode;
-end:
- CDBG("%s: op_mode=%d,rc=%d\n", __func__, *op_mode, rc);
- return rc;
-}
-
-int32_t mm_camera_set_parm(mm_camera_obj_t *my_obj,
- mm_camera_parm_type_t parm_type,
- void* p_value)
-{
- int32_t rc = 0;
- CDBG("%s type =%d", __func__, parm_type);
- switch(parm_type) {
- case MM_CAMERA_PARM_OP_MODE:
- rc = mm_camera_util_set_op_mode(my_obj,
- (mm_camera_op_mode_type_t *)p_value);
- break;
- case MM_CAMERA_PARM_DIMENSION:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_DIMENSION, sizeof(cam_ctrl_dimension_t), p_value);
- if(rc != 0) {
- CDBG("%s: mm_camera_send_native_ctrl_cmd err=%d\n", __func__, rc);
- break;
- }
- memcpy(&my_obj->dim, (cam_ctrl_dimension_t *)p_value,
- sizeof(cam_ctrl_dimension_t));
- CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,raw_w=%d,raw_h=%d\n",
- __func__,
- my_obj->dim.display_width,my_obj->dim.display_height,
- my_obj->dim.video_width, my_obj->dim.video_height,
- my_obj->dim.picture_width,my_obj->dim.picture_height,
- my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
- my_obj->dim.raw_picture_width,my_obj->dim.raw_picture_height);
- break;
- case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
- my_obj->snap_burst_num_by_user = *((uint32_t *)p_value);
- break;
- default:
- rc = mm_camera_set_general_parm(my_obj, parm_type, p_value);
- break;
- }
- pthread_mutex_unlock(&my_obj->cam_lock);
- return rc;
-}
-
-int32_t mm_camera_get_parm(mm_camera_obj_t *my_obj,
- mm_camera_parm_type_t parm_type,
- void* p_value)
-{
- int32_t rc = 0;
-
- switch(parm_type) {
- case MM_CAMERA_PARM_FRAME_RESOLUTION:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_FRAME_RESOLUTION,
- sizeof(cam_frame_resolution_t),
- p_value);
- if (rc < 0)
- CDBG_ERROR("%s: ERROR in CAMERA_GET_PARM_FRAME_RESOLUTION, rc = %d",
- __func__, rc);
- break;
- case MM_CAMERA_PARM_MAX_PICTURE_SIZE:
- {
- mm_camera_dimension_t *dim =
- (mm_camera_dimension_t *)p_value;
- dim->height = my_obj->properties.max_pict_height;
- dim->width = my_obj->properties.max_pict_width;
- CDBG("%s: Max Picture Size: %d X %d\n", __func__,
- dim->width, dim->height);
- }
- break;
- case MM_CAMERA_PARM_PREVIEW_FORMAT:
- *((int *)p_value) = my_obj->properties.preview_format;
- break;
- case MM_CAMERA_PARM_PREVIEW_SIZES_CNT:
- *((int *)p_value) = my_obj->properties.preview_sizes_cnt;
- break;
- case MM_CAMERA_PARM_VIDEO_SIZES_CNT:
- *((int *)p_value) = my_obj->properties.video_sizes_cnt;
- break;
- case MM_CAMERA_PARM_THUMB_SIZES_CNT:
- *((int *)p_value) = my_obj->properties.thumb_sizes_cnt;
- break;
- case MM_CAMERA_PARM_HFR_SIZES_CNT:
- *((int *)p_value) = my_obj->properties.hfr_sizes_cnt;
- break;
- case MM_CAMERA_PARM_HFR_FRAME_SKIP:
- *((int *)p_value) = my_obj->properties.hfr_frame_skip;
- break;
- case MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH:
- *((int *)p_value) = my_obj->properties.default_preview_width;
- break;
- case MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT:
- *((int *)p_value) = my_obj->properties.default_preview_height;
- break;
- case MM_CAMERA_PARM_MAX_PREVIEW_SIZE:
- {
- mm_camera_dimension_t *dim =
- (mm_camera_dimension_t *)p_value;
- dim->height = my_obj->properties.max_preview_height;
- dim->width = my_obj->properties.max_preview_width;
- CDBG("%s: Max Preview Size: %d X %d\n", __func__,
- dim->width, dim->height);
- }
- break;
- case MM_CAMERA_PARM_MAX_VIDEO_SIZE:
- {
- mm_camera_dimension_t *dim =
- (mm_camera_dimension_t *)p_value;
- dim->height = my_obj->properties.max_video_height;
- dim->width = my_obj->properties.max_video_width;
- CDBG("%s: Max Video Size: %d X %d\n", __func__,
- dim->width, dim->height);
- }
- break;
- case MM_CAMERA_PARM_MAX_HFR_MODE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_MAX_HFR_MODE,
- sizeof(camera_hfr_mode_t),
- p_value);
- break;
- case MM_CAMERA_PARM_FOCAL_LENGTH:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_FOCAL_LENGTH,
- sizeof(float),
- p_value);
- break;
- case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
- sizeof(float),
- p_value);
- break;
- case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
- sizeof(float),
- p_value);
- break;
- case MM_CAMERA_PARM_FOCUS_DISTANCES:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_FOCUS_DISTANCES,
- sizeof(focus_distances_info_t),
- p_value);
- break;
- case MM_CAMERA_PARM_QUERY_FALSH4SNAP:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_QUERY_FLASH_FOR_SNAPSHOT,
- sizeof(int),
- p_value);
- break;
- case MM_CAMERA_PARM_3D_FRAME_FORMAT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_3D_FRAME_FORMAT,
- sizeof(camera_3d_frame_t),
- p_value);
- break;
- case MM_CAMERA_PARM_MAXZOOM:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_MAXZOOM,
- sizeof(int),
- p_value);
- break;
- case MM_CAMERA_PARM_ZOOM_RATIO:
- {
- mm_camera_zoom_tbl_t *tbl = (mm_camera_zoom_tbl_t *)p_value;
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_ZOOMRATIOS,
- sizeof(int16_t)*tbl->size,
- (void *)(tbl->zoom_ratio_tbl));
- }
- break;
- case MM_CAMERA_PARM_DEF_PREVIEW_SIZES:
- {
- default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)p_value;
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_DEF_PREVIEW_SIZES,
- sizeof(struct camera_size_type)*tbl->tbl_size,
- (void* )(tbl->sizes_tbl));
- }
- break;
- case MM_CAMERA_PARM_DEF_VIDEO_SIZES:
- {
- default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)p_value;
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_DEF_VIDEO_SIZES,
- sizeof(struct camera_size_type)*tbl->tbl_size,
- (void *)(tbl->sizes_tbl));
- }
- break;
- case MM_CAMERA_PARM_DEF_THUMB_SIZES:
- {
- default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)p_value;
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_DEF_THUMB_SIZES,
- sizeof(struct camera_size_type)*tbl->tbl_size,
- (void *)(tbl->sizes_tbl));
- }
- break;
- case MM_CAMERA_PARM_DEF_HFR_SIZES:
- {
- default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)p_value;
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_DEF_HFR_SIZES,
- sizeof(struct camera_size_type)*tbl->tbl_size,
- (void *)(tbl->sizes_tbl));
- }
- break;
- case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
- *((int *)p_value) = my_obj->snap_burst_num_by_user;
- break;
- case MM_CAMERA_PARM_VFE_OUTPUT_ENABLE:
- *((int *)p_value) = my_obj->properties.vfe_output_enable;
- break;
- case MM_CAMERA_PARM_DIMENSION:
- memcpy(p_value, &my_obj->dim, sizeof(my_obj->dim));
- CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,ovx=%x,ovy=%d,opx=%d,opy=%d, m_fmt=%d, t_ftm=%d\n",
- __func__,
- my_obj->dim.display_width,my_obj->dim.display_height,
- my_obj->dim.video_width,my_obj->dim.video_height,
- my_obj->dim.picture_width,my_obj->dim.picture_height,
- my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
- my_obj->dim.orig_video_width,my_obj->dim.orig_video_height,
- my_obj->dim.orig_picture_width,my_obj->dim.orig_picture_height,
- my_obj->dim.main_img_format, my_obj->dim.thumb_format);
- break;
- case MM_CAMERA_PARM_OP_MODE:
- *((mm_camera_op_mode_type_t *)p_value) = my_obj->op_mode;
- break;
- case MM_CAMERA_PARM_MAX_NUM_FACES_DECT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_MAX_NUM_FACES_DECT,
- sizeof(int),
- p_value);
- break;
- case MM_CAMERA_PARM_HDR:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_HDR,
- sizeof(exp_bracketing_t),
- p_value);
- break;
- case MM_CAMERA_PARM_FPS_RANGE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_FPS_RANGE,
- sizeof(cam_sensor_fps_range_t),
- p_value);
- break;
-
- case MM_CAMERA_PARM_BESTSHOT_RECONFIGURE:
- *((int *)p_value) = my_obj->properties.bestshot_reconfigure;
- break;
-
- case MM_CAMERA_PARM_MOBICAT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_MOBICAT,
- sizeof(cam_exif_tags_t),
- p_value);
- break;
- default:
- /* needs to add more implementation */
- rc = -1;
- break;
- }
-
- pthread_mutex_unlock(&my_obj->cam_lock);
- return rc;
-}
-
-uint32_t mm_camera_add_channel(mm_camera_obj_t *my_obj)
-{
- mm_channel_t *ch_obj = NULL;
- uint8_t ch_idx = 0;
- uint32_t ch_hdl = 0;
-
- for(ch_idx = 0; ch_idx < MM_CAMERA_CHANNEL_MAX; ch_idx++) {
- if (MM_CHANNEL_STATE_NOTUSED == my_obj->ch[ch_idx].state) {
- ch_obj = &my_obj->ch[ch_idx];
- break;
- }
- }
-
- if (NULL != ch_obj) {
- /* initialize channel obj */
- memset(ch_obj, 0, sizeof(mm_channel_t));
- ch_hdl = mm_camera_util_generate_handler(ch_idx);
- ch_obj->my_hdl = ch_hdl;
- ch_obj->state = MM_CHANNEL_STATE_STOPPED;
- ch_obj->cam_obj = my_obj;
- pthread_mutex_init(&ch_obj->ch_lock, NULL);
- }
-
- mm_channel_init(ch_obj);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- return ch_hdl;
-}
-
-void mm_camera_del_channel(mm_camera_obj_t *my_obj,
- uint32_t ch_id)
-{
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_DELETE,
- NULL,
- NULL);
-
- pthread_mutex_destroy(&ch_obj->ch_lock);
- memset(ch_obj, 0, sizeof(mm_channel_t));
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-}
-
-uint32_t mm_camera_add_stream(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- mm_camera_buf_notify_t buf_cb, void *user_data,
- uint32_t ext_image_mode, uint32_t sensor_idx)
-{
- uint32_t s_hdl = 0;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
- mm_evt_paylod_add_stream_t payload;
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_paylod_add_stream_t));
- payload.buf_cb = buf_cb;
- payload.user_data = user_data;
- payload.ext_image_mode = ext_image_mode;
- payload.sensor_idx = sensor_idx;
- mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_ADD_STREAM,
- (void*)&payload,
- (void*)&s_hdl);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return s_hdl;
-}
-
-int32_t mm_camera_del_stream(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_DEL_STREAM,
- (void*)&stream_id,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_config_stream(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t stream_id,
- mm_camera_stream_config_t *config)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
- mm_evt_paylod_config_stream_t payload;
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_paylod_config_stream_t));
- payload.stream_id = stream_id;
- payload.config = config;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_CONFIG_STREAM,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_bundle_streams(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- mm_camera_buf_notify_t super_frame_notify_cb,
- void *user_data,
- mm_camera_bundle_attr_t *attr,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
- mm_evt_payload_bundle_stream_t payload;
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_payload_bundle_stream_t));
- payload.super_frame_notify_cb = super_frame_notify_cb;
- payload.user_data = user_data;
- payload.attr = attr;
- payload.num_streams = num_streams;
- payload.stream_ids = stream_ids;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_INIT_BUNDLE,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_destroy_bundle(mm_camera_obj_t *my_obj, uint32_t ch_id)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_DESTROY_BUNDLE,
- NULL,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_start_streams(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
- mm_evt_payload_start_stream_t payload;
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_payload_start_stream_t));
- payload.num_streams = num_streams;
- payload.stream_ids = stream_ids;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_START_STREAM,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_stop_streams(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = 0;
- mm_evt_payload_stop_stream_t payload;
- mm_camera_cmdcb_t * node = NULL;
-
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_payload_stop_stream_t));
- payload.num_streams = num_streams;
- payload.stream_ids = stream_ids;
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_STOP_STREAM,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
- return rc;
-}
-
-int32_t mm_camera_async_teardown_streams(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = 0;
- mm_evt_payload_stop_stream_t payload;
- mm_camera_cmdcb_t * node = NULL;
-
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- /* enqueu asyn stop cmd to async_cmd_thread */
- node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL != node) {
- memset(node, 0, sizeof(mm_camera_cmdcb_t));
- node->cmd_type = MM_CAMERA_CMD_TYPE_ASYNC_CB;
- node->u.async.cmd_type = MM_CAMERA_ASYNC_CMD_TYPE_STOP;
- node->u.async.u.stop_cmd.ch_obj = ch_obj;
- node->u.async.u.stop_cmd.num_streams = num_streams;
- memcpy(node->u.async.u.stop_cmd.stream_ids, stream_ids, sizeof(uint32_t)*num_streams);
-
- /* enqueue to async cmd thread */
- mm_camera_queue_enq(&(my_obj->async_cmd_thread.cmd_queue), node);
- /* wake up async cmd thread */
- sem_post(&(my_obj->async_cmd_thread.cmd_sem));
- } else {
- CDBG_ERROR("%s: No memory for mm_camera_cmdcb_t", __func__);
- pthread_mutex_unlock(&ch_obj->ch_lock);
- rc = -1;
- return rc;
- }
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
- return rc;
-}
-
-int32_t mm_camera_request_super_buf(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t num_buf_requested)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_REQUEST_SUPER_BUF,
- (void*)num_buf_requested,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_cancel_super_buf_request(mm_camera_obj_t *my_obj, uint32_t ch_id)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF,
- NULL,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_start_focus(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t sensor_idx,
- uint32_t focus_mode)
-{
- int32_t rc = -1;
- mm_evt_payload_start_focus_t payload;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_payload_start_focus_t));
- payload.sensor_idx = sensor_idx;
- payload.focus_mode = focus_mode;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_START_FOCUS,
- (void *)&payload,
- NULL);
- if (0 != rc) {
- mm_camera_event_t event;
- event.event_type = MM_CAMERA_EVT_TYPE_CTRL;
- event.e.ctrl.evt = MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE;
- event.e.ctrl.status = CAM_CTRL_FAILED;
- rc = mm_camera_enqueue_evt(my_obj, &event);
- }
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_abort_focus(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t sensor_idx)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_ABORT_FOCUS,
- (void*)sensor_idx,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_prepare_snapshot(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t sensor_idx)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_PREPARE_SNAPSHOT,
- (void *)sensor_idx,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_set_stream_parm(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t s_id,
- mm_camera_stream_parm_t parm_type,
- void* p_value)
-{
- int32_t rc = -1;
- mm_evt_paylod_stream_parm_t payload;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload,0,sizeof(mm_evt_paylod_stream_parm_t));
- payload.parm_type = parm_type;
- payload.value = p_value;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_SET_STREAM_PARM,
- (void *)s_id,
- &payload);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_get_stream_parm(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t s_id,
- mm_camera_stream_parm_t parm_type,
- void* p_value)
-{
- int32_t rc = -1;
- mm_evt_paylod_stream_parm_t payload;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload,0,sizeof(mm_evt_paylod_stream_parm_t));
- payload.parm_type = parm_type;
- payload.value = p_value;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_GET_STREAM_PARM,
- (void *)s_id,
- &payload);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- }
-
- return rc;
-}
-
-int32_t mm_camera_send_private_ioctl(mm_camera_obj_t *my_obj,
- uint32_t cmd_id,
- uint32_t cmd_length,
- void *cmd)
-{
- int32_t rc = -1;
-
- struct msm_camera_v4l2_ioctl_t v4l2_ioctl;
-
- CDBG("%s: cmd = %p, length = %d",
- __func__, cmd, cmd_length);
- memset(&v4l2_ioctl, 0, sizeof(v4l2_ioctl));
- v4l2_ioctl.id = cmd_id;
- v4l2_ioctl.len = cmd_length;
- v4l2_ioctl.ioctl_ptr = cmd;
- rc = ioctl (my_obj->ctrl_fd, MSM_CAM_V4L2_IOCTL_PRIVATE_GENERAL, &v4l2_ioctl);
-
- if(rc < 0) {
- CDBG_ERROR("%s: cmd = %p, id = %d, length = %d, rc = %d\n",
- __func__, cmd, cmd_id, cmd_length, rc);
- } else {
- rc = 0;
- }
-
- return rc;
-}
-
-int32_t mm_camera_ctrl_set_specialEffect (mm_camera_obj_t *my_obj, int32_t effect) {
- struct v4l2_control ctrl;
- if (effect == CAMERA_EFFECT_MAX)
- effect = CAMERA_EFFECT_OFF;
- int rc = 0;
-
- ctrl.id = MSM_V4L2_PID_EFFECT;
- ctrl.value = effect;
- rc = ioctl(my_obj->ctrl_fd, VIDIOC_S_CTRL, &ctrl);
- return (rc >= 0)? 0: -1;;
-}
-
-int32_t mm_camera_ctrl_set_auto_focus (mm_camera_obj_t *my_obj, int32_t value)
-{
- int32_t rc = 0;
- struct v4l2_queryctrl queryctrl;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_FOCUS_AUTO;
-
- if(value != 0 && value != 1) {
- CDBG("%s:boolean required, invalid value = %d\n",__func__, value);
- return -1;
- }
- if (-1 == ioctl (my_obj->ctrl_fd, VIDIOC_QUERYCTRL, &queryctrl)) {
- CDBG ("V4L2_CID_FOCUS_AUTO is not supported\n");
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- CDBG ("%s:V4L2_CID_FOCUS_AUTO is not supported\n", __func__);
- } else {
- if(0 != (rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- V4L2_CID_FOCUS_AUTO, value))){
- CDBG("%s: error, id=0x%x, value=%d, rc = %d\n",
- __func__, V4L2_CID_FOCUS_AUTO, value, rc);
- rc = -1;
- }
- }
- return rc;
-}
-
-int32_t mm_camera_ctrl_set_whitebalance (mm_camera_obj_t *my_obj, int32_t mode) {
-
- int32_t rc = 0, auto_wb, temperature;
- uint32_t id_auto_wb, id_temperature;
-
- id_auto_wb = V4L2_CID_AUTO_WHITE_BALANCE;
- id_temperature = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
-
- switch(mode) {
- case CAMERA_WB_DAYLIGHT:
- auto_wb = 0;
- temperature = 6500;
- break;
- case CAMERA_WB_INCANDESCENT:
- auto_wb = 0;
- temperature = 2800;
- break;
- case CAMERA_WB_FLUORESCENT:
- auto_wb = 0;
- temperature = 4200;
- break;
- case CAMERA_WB_CLOUDY_DAYLIGHT:
- auto_wb = 0;
- temperature = 7500;
- break;
- case CAMERA_WB_AUTO:
- default:
- auto_wb = 1; /* TRUE */
- temperature = 0;
- break;
- }
-
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd, id_auto_wb, auto_wb);
- if(0 != rc){
- CDBG_ERROR("%s: error, V4L2_CID_AUTO_WHITE_BALANCE value = %d, rc = %d\n",
- __func__, auto_wb, rc);
- return rc;
- }
- if (!auto_wb) {
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd, id_temperature, temperature);
- if (0 != rc) {
- CDBG_ERROR("%s: error, V4L2_CID_WHITE_BALANCE_TEMPERATURE value = %d, rc = %d\n",
- __func__, temperature, rc);
- return rc;
- }
- }
- return rc;
-}
-
-int32_t mm_camera_set_general_parm(mm_camera_obj_t * my_obj,
- mm_camera_parm_type_t parm_type,
- void* p_value)
-{
- int rc = -1;
- int isZSL =0;
-
- switch(parm_type) {
- case MM_CAMERA_PARM_EXPOSURE:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- MSM_V4L2_PID_EXP_METERING,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_SHARPNESS:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- V4L2_CID_SHARPNESS,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_CONTRAST:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- V4L2_CID_CONTRAST,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_SATURATION:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- V4L2_CID_SATURATION,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_BRIGHTNESS:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- V4L2_CID_BRIGHTNESS,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_WHITE_BALANCE:
- rc = mm_camera_ctrl_set_whitebalance (my_obj, *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_ISO:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- MSM_V4L2_PID_ISO,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_ZOOM:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- V4L2_CID_ZOOM_ABSOLUTE,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_LUMA_ADAPTATION:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- MSM_V4L2_PID_LUMA_ADAPTATION,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_ANTIBANDING:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- V4L2_CID_POWER_LINE_FREQUENCY,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_CONTINUOUS_AF:
- rc = mm_camera_ctrl_set_auto_focus(my_obj,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_HJR:
- rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
- MSM_V4L2_PID_HJR,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_EFFECT:
- rc = mm_camera_ctrl_set_specialEffect (my_obj,
- *((int32_t *)p_value));
- break;
- case MM_CAMERA_PARM_FPS:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_FPS,
- sizeof(uint32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_FPS_MODE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_FPS_MODE,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_EXPOSURE_COMPENSATION:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_EXPOSURE_COMPENSATION,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_LED_MODE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_LED_MODE,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_ROLLOFF:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_ROLLOFF,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_MODE:
- my_obj->current_mode = *((camera_mode_t *)p_value);
- break;
- case MM_CAMERA_PARM_FOCUS_RECT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_FOCUS_RECT,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_AEC_ROI:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_AEC_ROI,
- sizeof(cam_set_aec_roi_t),
- p_value);
- break;
- case MM_CAMERA_PARM_AF_ROI:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_AF_ROI,
- sizeof(roi_info_t),
- p_value);
- break;
- case MM_CAMERA_PARM_FOCUS_MODE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_AF_MODE,
- sizeof(int32_t),
- p_value);
- break;
-#if 0 /* to be enabled later: @punits */
- case MM_CAMERA_PARM_AF_MTR_AREA:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_AF_MTR_AREA,
- sizeof(af_mtr_area_t),
- p_value);
- break;
- case MM_CAMERA_PARM_AEC_MTR_AREA:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_AEC_MTR_AREA,
- sizeof(aec_mtr_area_t),
- p_value);
- break;
-#endif
- case MM_CAMERA_PARM_CAF_ENABLE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_CAF,
- sizeof(uint32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_BESTSHOT_MODE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_BESTSHOT_MODE,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_VIDEO_DIS:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_VIDEO_DIS_PARAMS,
- sizeof(video_dis_param_ctrl_t),
- p_value);
- break;
- case MM_CAMERA_PARM_VIDEO_ROT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_VIDEO_ROT_PARAMS,
- sizeof(video_rotation_param_ctrl_t),
- p_value);
- break;
- case MM_CAMERA_PARM_SCE_FACTOR:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_SCE_FACTOR,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_FD:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_FD,
- sizeof(fd_set_parm_t),
- p_value);
- break;
- case MM_CAMERA_PARM_AEC_LOCK:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_AEC_LOCK,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_AWB_LOCK:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_AWB_LOCK,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_MCE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_MCE,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
- sizeof(focus_distances_info_t),
- p_value);
- break;
- case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
- sizeof(focus_distances_info_t),
- p_value);
- break;
- case MM_CAMERA_PARM_RESET_LENS_TO_INFINITY:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_RESET_LENS_TO_INFINITY,
- 0, NULL);
- break;
- case MM_CAMERA_PARM_SNAPSHOTDATA:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PARM_SNAPSHOTDATA,
- sizeof(snapshotData_info_t),
- p_value);
- break;
- case MM_CAMERA_PARM_HFR:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_HFR,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_REDEYE_REDUCTION:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_REDEYE_REDUCTION,
- sizeof(int32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_WAVELET_DENOISE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_WAVELET_DENOISE,
- sizeof(denoise_param_t),
- p_value);
- break;
- case MM_CAMERA_PARM_3D_DISPLAY_DISTANCE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_3D_DISPLAY_DISTANCE,
- sizeof(float),
- p_value);
- break;
- case MM_CAMERA_PARM_3D_VIEW_ANGLE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_3D_VIEW_ANGLE,
- sizeof(uint32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_ZOOM_RATIO:
- break;
- case MM_CAMERA_PARM_HISTOGRAM:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_HISTOGRAM,
- sizeof(int8_t),
- p_value);
- break;
- case MM_CAMERA_PARM_ASD_ENABLE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_ASD_ENABLE,
- sizeof(uint32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_RECORDING_HINT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_RECORDING_HINT,
- sizeof(uint32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_PREVIEW_FORMAT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_PREVIEW_FORMAT,
- sizeof(uint32_t),
- p_value);
- break;
- /* TODO: need code review to determine any of the three is redundent
- * MM_CAMERA_PARM_DIS_ENABLE,
- * MM_CAMERA_PARM_FULL_LIVESHOT,
- * MM_CAMERA_PARM_LOW_POWER_MODE*/
- case MM_CAMERA_PARM_DIS_ENABLE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_DIS_ENABLE,
- sizeof(uint32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_FULL_LIVESHOT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_FULL_LIVESHOT,
- sizeof(uint32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_LOW_POWER_MODE:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_LOW_POWER_MODE,
- sizeof(uint32_t),
- p_value);
- break;
- case MM_CAMERA_PARM_HDR:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_SET_PARM_HDR,
- sizeof(exp_bracketing_t),
- p_value);
- break;
- case MM_CAMERA_PARM_MOBICAT:
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_ENABLE_MOBICAT,
- sizeof(mm_cam_mobicat_info_t),
- p_value);
- default:
- CDBG("%s: default: parm %d not supported\n", __func__, parm_type);
- break;
- }
- return rc;
-}
-
-int32_t mm_camera_util_private_s_ctrl(int32_t fd, uint32_t id, void* value)
-{
- int rc = -1;
- struct msm_camera_v4l2_ioctl_t v4l2_ioctl;
-
- memset(&v4l2_ioctl, 0, sizeof(v4l2_ioctl));
- v4l2_ioctl.id = id;
- v4l2_ioctl.ioctl_ptr = value;
- rc = ioctl (fd, MSM_CAM_V4L2_IOCTL_PRIVATE_S_CTRL, &v4l2_ioctl);
-
- if(rc < 0) {
- CDBG_ERROR("%s: fd=%d, S_CTRL, id=0x%x, value = 0x%x, rc = %d\n",
- __func__, fd, id, (uint32_t)value, rc);
- rc = -1;
- } else {
- rc = 0;
- }
- return rc;
-}
-
-int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
- cam_ctrl_type type,
- uint32_t length,
- void *value)
-{
- return mm_camera_send_native_ctrl_timeout_cmd(my_obj, type,
- length, value,
- 1000);
-}
-
-int32_t mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,
- cam_ctrl_type type,
- uint32_t length,
- void *value,
- int timeout)
-{
- int rc = -1;
- struct msm_ctrl_cmd ctrl_cmd;
-
- memset(&ctrl_cmd, 0, sizeof(ctrl_cmd));
- ctrl_cmd.type = type;
- ctrl_cmd.length = (uint16_t)length;
- ctrl_cmd.timeout_ms = timeout;
- ctrl_cmd.value = value;
- ctrl_cmd.status = (uint16_t)CAM_CTRL_SUCCESS;
- rc = mm_camera_util_private_s_ctrl(my_obj->ctrl_fd,
- MSM_V4L2_PID_CTRL_CMD,
- (void*)&ctrl_cmd);
- CDBG("%s: type=%d, rc = %d, status = %d\n",
- __func__, type, rc, ctrl_cmd.status);
- if(rc != 0 || ((ctrl_cmd.status != CAM_CTRL_ACCEPTED) &&
- (ctrl_cmd.status != CAM_CTRL_SUCCESS) &&
- (ctrl_cmd.status != CAM_CTRL_INVALID_PARM)))
- rc = -1;
- return rc;
-}
-
-int mm_camera_evt_sub(mm_camera_obj_t * my_obj,
- mm_camera_event_type_t evt_type,
- int reg_count)
-{
- int rc = 0;
- struct v4l2_event_subscription sub;
-
- memset(&sub, 0, sizeof(sub));
- sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_EVENT;
- if(reg_count == 0) {
- /* unsubscribe */
- if(my_obj->evt_type_mask == (uint32_t)(1 << evt_type)) {
- rc = ioctl(my_obj->ctrl_fd, VIDIOC_UNSUBSCRIBE_EVENT, &sub);
- CDBG("%s: unsubscribe event 0x%x, rc = %d", __func__, sub.type, rc);
- sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_ERROR_EVENT;
- rc = ioctl(my_obj->ctrl_fd, VIDIOC_UNSUBSCRIBE_EVENT, &sub);
- CDBG("%s: unsubscribe event 0x%x, rc = %d", __func__, sub.type, rc);
- }
- my_obj->evt_type_mask &= ~(1 << evt_type);
- if(my_obj->evt_type_mask == 0) {
- /* remove evt fd from the polling thraed when unreg the last event */
- mm_camera_poll_thread_del_poll_fd(&my_obj->evt_poll_thread, my_obj->my_hdl);
- }
- } else {
- if(!my_obj->evt_type_mask) {
- /* this is the first reg event */
- rc = ioctl(my_obj->ctrl_fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
- CDBG("%s: subscribe event 0x%x, rc = %d", __func__, sub.type, rc);
- if (rc < 0)
- goto end;
- sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_ERROR_EVENT;
- rc = ioctl(my_obj->ctrl_fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
- CDBG("%s: subscribe event 0x%x, rc = %d", __func__, sub.type, rc);
- if (rc < 0)
- goto end;
- }
- my_obj->evt_type_mask |= (1 << evt_type);
- if(my_obj->evt_type_mask == (uint32_t)(1 << evt_type)) {
- /* add evt fd to polling thread when subscribe the first event */
- rc = mm_camera_poll_thread_add_poll_fd(&my_obj->evt_poll_thread,
- my_obj->my_hdl,
- my_obj->ctrl_fd,
- mm_camera_event_notify,
- (void*)my_obj);
- }
- }
-end:
- return rc;
-}
-
-int32_t mm_camera_util_sendmsg(mm_camera_obj_t *my_obj, void *msg, uint32_t buf_size, int sendfd)
-{
- return mm_camera_socket_sendmsg(my_obj->ds_fd, msg, buf_size, sendfd);
-}
-
-int32_t mm_camera_map_buf(mm_camera_obj_t *my_obj,
- int ext_mode,
- int idx,
- int fd,
- uint32_t size)
-{
- cam_sock_packet_t packet;
- memset(&packet, 0, sizeof(cam_sock_packet_t));
- packet.msg_type = CAM_SOCK_MSG_TYPE_FD_MAPPING;
- packet.payload.frame_fd_map.ext_mode = ext_mode;
- packet.payload.frame_fd_map.frame_idx = idx;
- packet.payload.frame_fd_map.fd = fd;
- packet.payload.frame_fd_map.size = size;
-
- return mm_camera_util_sendmsg(my_obj, &packet,
- sizeof(cam_sock_packet_t),
- packet.payload.frame_fd_map.fd);
-}
-
-int32_t mm_camera_unmap_buf(mm_camera_obj_t *my_obj,
- int ext_mode,
- int idx)
-{
- cam_sock_packet_t packet;
- memset(&packet, 0, sizeof(cam_sock_packet_t));
- packet.msg_type = CAM_SOCK_MSG_TYPE_FD_UNMAPPING;
- packet.payload.frame_fd_unmap.ext_mode = ext_mode;
- packet.payload.frame_fd_unmap.frame_idx = idx;
- return mm_camera_util_sendmsg(my_obj, &packet,
- sizeof(cam_sock_packet_t),
- packet.payload.frame_fd_map.fd);
-}
-
-int32_t mm_camera_util_s_ctrl(int32_t fd, uint32_t id, int32_t value)
-{
- int rc = 0;
- struct v4l2_control control;
-
- memset(&control, 0, sizeof(control));
- control.id = id;
- control.value = value;
- rc = ioctl (fd, VIDIOC_S_CTRL, &control);
-
- CDBG("%s: fd=%d, S_CTRL, id=0x%x, value = 0x%x, rc = %d\n",
- __func__, fd, id, (uint32_t)value, rc);
- return (rc >= 0)? 0 : -1;
-}
-
-int32_t mm_camera_util_g_ctrl( int32_t fd, uint32_t id, int32_t *value)
-{
- int rc = 0;
- struct v4l2_control control;
-
- memset(&control, 0, sizeof(control));
- control.id = id;
- control.value = (int32_t)value;
- rc = ioctl (fd, VIDIOC_G_CTRL, &control);
- *value = control.value;
- CDBG("%s: fd=%d, G_CTRL, id=0x%x, rc = %d\n", __func__, fd, id, rc);
- return (rc >= 0)? 0 : -1;
-}
-
-uint8_t mm_camera_util_get_pp_mask(mm_camera_obj_t *my_obj)
-{
- uint8_t pp_mask = 0;
- int32_t rc = 0;
-
- /* query pp mask from mctl */
- rc = mm_camera_send_native_ctrl_cmd(my_obj,
- CAMERA_GET_PP_MASK,
- sizeof(uint8_t),
- (void *)&pp_mask);
- if (0 != rc) {
- CDBG_ERROR("%s: error getting post processing mask (rc=%d)",
- __func__, rc);
- }
-
- return pp_mask;
-}
-
-int32_t mm_camera_open_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- mm_camera_repro_isp_type_t repro_isp_type,
- uint32_t *repro_isp_handle)
-{
- int32_t rc = -1;
- uint32_t repro_hdl = 0;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_OPEN_REPRO_ISP,
- (void*)repro_isp_type,
- (void*)&repro_hdl);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- CDBG_ERROR("%s: no channel obj exist", __func__);
- }
-
- if (NULL != repro_isp_handle) {
- *repro_isp_handle = repro_hdl;
- }
- return rc;
-}
-
-int32_t mm_camera_config_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- mm_camera_repro_isp_config_t *config)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
- mm_evt_paylod_config_repro_isp_t payload;
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_paylod_config_repro_isp_t));
- payload.repro_isp_handle = repro_isp_handle;
- payload.config = config;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_CONFIG_REPRO_ISP,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- CDBG_ERROR("%s: no channel obj exist", __func__);
- }
-
- return rc;
-}
-
-int32_t mm_camera_attach_stream_to_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
- mm_evt_paylod_stream_to_repro_isp_t payload;
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_paylod_stream_to_repro_isp_t));
- payload.repro_isp_handle = repro_isp_handle;
- payload.stream_id = stream_id;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- CDBG_ERROR("%s: no channel obj exist", __func__);
- }
-
- return rc;
-}
-
-int32_t mm_camera_start_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_evt_paylod_repro_start_stop_t payload;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_paylod_repro_start_stop_t));
- payload.repro_isp_handle = repro_isp_handle;
- payload.stream_id = stream_id;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_START_REPRO_ISP,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- CDBG_ERROR("%s: no channel obj exist", __func__);
- }
-
- return rc;
-}
-
-int32_t mm_camera_reprocess(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- mm_camera_repro_data_t *repro_data)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
- mm_evt_paylod_reprocess_t payload;
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_paylod_reprocess_t));
- payload.repro_isp_handle = repro_isp_handle;
- payload.repro_data = repro_data;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- CDBG_ERROR("%s: no channel obj exist", __func__);
- }
-
- return rc;
-}
-
-int32_t mm_camera_stop_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_evt_paylod_repro_start_stop_t payload;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_paylod_repro_start_stop_t));
- payload.repro_isp_handle = repro_isp_handle;
- payload.stream_id = stream_id;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_STOP_REPRO_ISP,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- CDBG_ERROR("%s: no channel obj exist", __func__);
- }
-
- return rc;
-}
-
-int32_t mm_camera_detach_stream_from_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
- mm_evt_paylod_stream_to_repro_isp_t payload;
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- memset(&payload, 0, sizeof(mm_evt_paylod_stream_to_repro_isp_t));
- payload.repro_isp_handle = repro_isp_handle;
- payload.stream_id = stream_id;
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_DETACH_STREAM_FROM_REPRO_ISP,
- (void*)&payload,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- CDBG_ERROR("%s: no channel obj exist", __func__);
- }
-
- return rc;
-}
-
-int32_t mm_camera_close_repro_isp(mm_camera_obj_t *my_obj,
- uint32_t ch_id,
- uint32_t repro_isp_handle)
-{
- int32_t rc = -1;
- mm_channel_t * ch_obj =
- mm_camera_util_get_channel_by_handler(my_obj, ch_id);
-
- if (NULL != ch_obj) {
- pthread_mutex_lock(&ch_obj->ch_lock);
- pthread_mutex_unlock(&my_obj->cam_lock);
-
- rc = mm_channel_fsm_fn(ch_obj,
- MM_CHANNEL_EVT_CLOSE_REPRO_ISP,
- (void*)repro_isp_handle,
- NULL);
- } else {
- pthread_mutex_unlock(&my_obj->cam_lock);
- CDBG_ERROR("%s: no channel obj exist", __func__);
- }
-
- return rc;
-}
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_channel.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_channel.c
deleted file mode 100755
index 351c4d6..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_channel.c
+++ /dev/null
@@ -1,1871 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-extern mm_camera_obj_t* mm_camera_util_get_camera_by_handler(uint32_t cam_handler);
-extern mm_channel_t * mm_camera_util_get_channel_by_handler(
- mm_camera_obj_t * cam_obj,
- uint32_t handler);
-extern int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
- cam_ctrl_type type,
- uint32_t length,
- void *value);
-extern int32_t mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,
- cam_ctrl_type type,
- uint32_t length,
- void *value,
- int timeout);
-
-/* internal function declare goes here */
-int32_t mm_channel_qbuf(mm_channel_t *my_obj,
- mm_camera_buf_def_t *buf);
-int32_t mm_channel_init(mm_channel_t *my_obj);
-void mm_channel_release(mm_channel_t *my_obj);
-uint32_t mm_channel_add_stream(mm_channel_t *my_obj,
- mm_camera_buf_notify_t buf_cb, void *user_data,
- uint32_t ext_image_mode, uint32_t sensor_idx);
-int32_t mm_channel_del_stream(mm_channel_t *my_obj,
- uint32_t stream_id);
-int32_t mm_channel_config_stream(mm_channel_t *my_obj,
- uint32_t stream_id,
- mm_camera_stream_config_t *config);
-int32_t mm_channel_bundle_stream(mm_channel_t *my_obj,
- mm_camera_buf_notify_t super_frame_notify_cb,
- void *user_data,
- mm_camera_bundle_attr_t *attr,
- uint8_t num_streams,
- uint32_t *stream_ids);
-int32_t mm_channel_destroy_bundle(mm_channel_t *my_obj);
-int32_t mm_channel_start_streams(mm_channel_t *my_obj,
- uint8_t num_streams,
- uint32_t *stream_ids);
-int32_t mm_channel_stop_streams(mm_channel_t *my_obj,
- uint8_t num_streams,
- uint32_t *stream_ids,
- uint8_t tear_down_flag);
-int32_t mm_channel_request_super_buf(mm_channel_t *my_obj, uint32_t num_buf_requested);
-int32_t mm_channel_cancel_super_buf_request(mm_channel_t *my_obj);
-int32_t mm_channel_start_focus(mm_channel_t *my_obj,
- uint32_t sensor_idx,
- uint32_t focus_mode);
-int32_t mm_channel_abort_focus(mm_channel_t *my_obj,
- uint32_t sensor_idx);
-int32_t mm_channel_prepare_snapshot(mm_channel_t *my_obj,
- uint32_t sensor_idx);
-int32_t mm_channel_set_stream_parm(mm_channel_t *my_obj,
- uint32_t s_id,
- void *value);
-int32_t mm_channel_get_stream_parm(mm_channel_t *my_obj,
- uint32_t s_id,
- void *value);
-int32_t mm_channel_do_post_processing(mm_channel_t *my_obj,
- mm_channel_queue_node_t *super_buf);
-int32_t mm_channel_superbuf_bufdone_overflow(mm_channel_t *my_obj,
- mm_channel_queue_t *queue);
-int32_t mm_channel_superbuf_skip(mm_channel_t *my_obj,
- mm_channel_queue_t *queue);
-uint32_t mm_channel_open_repro_isp(mm_channel_t *my_obj,
- mm_camera_repro_isp_type_t isp_type);
-int32_t mm_channel_close_repro_isp(mm_channel_t *my_obj,
- uint32_t repro_handle);
-int32_t mm_channel_config_repro_isp(mm_channel_t *my_obj,
- uint32_t repro_handle,
- mm_camera_repro_isp_config_t *config);
-int32_t mm_channel_repro_isp_dest_stream_ops(mm_channel_t *my_obj,
- uint32_t repro_handle,
- uint32_t stream_handle,
- uint8_t attach_flag);
-int32_t mm_channel_repro_isp_ops(mm_channel_t *my_obj,
- uint32_t repro_handle,
- uint32_t stream_id,
- uint8_t start_flag);
-int32_t mm_channel_reprocess(mm_channel_t *my_obj,
- uint32_t repro_handle,
- mm_camera_repro_data_t *repro_data);
-
-/* state machine function declare */
-int32_t mm_channel_fsm_fn_notused(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_channel_fsm_fn_stopped(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_channel_fsm_fn_active(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_channel_fsm_fn_paused(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val);
-
-/* channel super queue functions */
-int32_t mm_channel_superbuf_queue_init(mm_channel_queue_t * queue);
-int32_t mm_channel_superbuf_queue_deinit(mm_channel_t *my_obj,
- mm_channel_queue_t * queue);
-int32_t mm_channel_superbuf_comp_and_enqueue(mm_channel_t *ch_obj,
- mm_channel_queue_t * queue,
- mm_camera_buf_info_t *buf);
-mm_channel_queue_node_t* mm_channel_superbuf_dequeue(mm_channel_queue_t * queue);
-
-/* channel utility function */
-mm_stream_t * mm_channel_util_get_stream_by_handler(
- mm_channel_t * ch_obj,
- uint32_t handler)
-{
- int i;
- mm_stream_t *s_obj = NULL;
- uint8_t ch_idx = mm_camera_util_get_index_by_handler(handler);
-
- for(i = 0; i < MM_CAMEAR_STRAEM_NUM_MAX; i++) {
- if (handler == ch_obj->streams[i].my_hdl) {
- s_obj = &ch_obj->streams[i];
- break;
- }
- }
- return s_obj;
-}
-
-static void mm_channel_dispatch_super_buf(mm_camera_cmdcb_t *cmd_cb,
- void* user_data)
-{
- int i;
- mm_channel_t * my_obj = (mm_channel_t *)user_data;
-
- if (NULL == my_obj) {
- return;
- }
-
- if (MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB != cmd_cb->cmd_type) {
- CDBG_ERROR("%s: Wrong cmd_type (%d) for super buf dataCB",
- __func__, cmd_cb->cmd_type);
- return;
- }
-
- if (my_obj->bundle.super_buf_notify_cb) {
- my_obj->bundle.super_buf_notify_cb(&cmd_cb->u.superbuf, my_obj->bundle.user_data);
- }
-}
-
-/* CB for processing stream buffer */
-static void mm_channel_process_stream_buf(mm_camera_cmdcb_t * cmd_cb,
- void *user_data)
-{
- mm_camera_super_buf_notify_mode_t notify_mode;
- mm_channel_queue_node_t *node = NULL;
- mm_channel_t *ch_obj = (mm_channel_t *)user_data;
- if (NULL == ch_obj) {
- return;
- }
-
- if (MM_CAMERA_CMD_TYPE_DATA_CB == cmd_cb->cmd_type) {
- /* comp_and_enqueue */
- mm_channel_superbuf_comp_and_enqueue(
- ch_obj,
- &ch_obj->bundle.superbuf_queue,
- &cmd_cb->u.buf);
- } else if (MM_CAMERA_CMD_TYPE_REQ_DATA_CB == cmd_cb->cmd_type) {
- /* skip frames if needed */
- ch_obj->pending_cnt = cmd_cb->u.req_buf.num_buf_requested;
- mm_channel_superbuf_skip(ch_obj, &ch_obj->bundle.superbuf_queue);
- }
-
- notify_mode = ch_obj->bundle.superbuf_queue.attr.notify_mode;
-
- /* bufdone for overflowed bufs */
- mm_channel_superbuf_bufdone_overflow(ch_obj, &ch_obj->bundle.superbuf_queue);
-
- /* dispatch frame if pending_cnt>0 or is in continuous streaming mode */
- while ( (ch_obj->pending_cnt > 0) ||
- (MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS == notify_mode) ) {
-
- /* dequeue */
- node = mm_channel_superbuf_dequeue(&ch_obj->bundle.superbuf_queue);
- if (NULL != node) {
- /* decrease pending_cnt */
- CDBG("%s: Super Buffer received, Call client callback, pending_cnt=%d",
- __func__, ch_obj->pending_cnt);
- if (MM_CAMERA_SUPER_BUF_NOTIFY_BURST == notify_mode) {
- ch_obj->pending_cnt--;
- }
-
- /* do post processing if needed */
- /* this is a blocking call */
- mm_channel_do_post_processing(ch_obj, node);
-
- /* dispatch superbuf */
- if (NULL != ch_obj->bundle.super_buf_notify_cb) {
- uint8_t i;
- mm_camera_cmdcb_t* cb_node = NULL;
-
- CDBG("%s: Send superbuf to HAL, pending_cnt=%d",
- __func__, ch_obj->pending_cnt);
-
- /* send sem_post to wake up cb thread to dispatch super buffer */
- cb_node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL != cb_node) {
- memset(cb_node, 0, sizeof(mm_camera_cmdcb_t));
- cb_node->cmd_type = MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB;
- cb_node->u.superbuf.num_bufs = node->num_of_bufs;
- for (i=0; i<node->num_of_bufs; i++) {
- cb_node->u.superbuf.bufs[i] = node->super_buf[i].buf;
- }
- cb_node->u.superbuf.camera_handle = ch_obj->cam_obj->my_hdl;
- cb_node->u.superbuf.ch_id = ch_obj->my_hdl;
-
- /* enqueue to cb thread */
- mm_camera_queue_enq(&(ch_obj->cb_thread.cmd_queue), cb_node);
-
- /* wake up cb thread */
- sem_post(&(ch_obj->cb_thread.cmd_sem));
- } else {
- CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
- /* buf done with the nonuse super buf */
- for (i=0; i<node->num_of_bufs; i++) {
- mm_channel_qbuf(ch_obj, node->super_buf[i].buf);
- }
- }
- } else {
- /* buf done with the nonuse super buf */
- uint8_t i;
- for (i=0; i<node->num_of_bufs; i++) {
- mm_channel_qbuf(ch_obj, node->super_buf[i].buf);
- }
- }
- free(node);
- } else {
- /* no superbuf avail, break the loop */
- break;
- }
- }
-}
-
-/* state machine entry */
-int32_t mm_channel_fsm_fn(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = -1;
-
- CDBG("%s : E state = %d",__func__,my_obj->state);
- switch (my_obj->state) {
- case MM_CHANNEL_STATE_NOTUSED:
- rc = mm_channel_fsm_fn_notused(my_obj, evt, in_val, out_val);
- break;
- case MM_CHANNEL_STATE_STOPPED:
- rc = mm_channel_fsm_fn_stopped(my_obj, evt, in_val, out_val);
- break;
- case MM_CHANNEL_STATE_ACTIVE:
- rc = mm_channel_fsm_fn_active(my_obj, evt, in_val, out_val);
- break;
- case MM_CHANNEL_STATE_PAUSED:
- rc = mm_channel_fsm_fn_paused(my_obj, evt, in_val, out_val);
- break;
- default:
- CDBG("%s: Not a valid state (%d)", __func__, my_obj->state);
- break;
- }
-
- /* unlock ch_lock */
- pthread_mutex_unlock(&my_obj->ch_lock);
- CDBG("%s : X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_channel_fsm_fn_notused(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = -1;
-
- switch (evt) {
- default:
- CDBG_ERROR("%s: invalid state (%d) for evt (%d)",
- __func__, my_obj->state, evt);
- break;
- }
-
- return rc;
-}
-
-int32_t mm_channel_fsm_fn_stopped(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
- CDBG("%s : E evt = %d",__func__,evt);
- switch (evt) {
- case MM_CHANNEL_EVT_ADD_STREAM:
- {
- uint32_t s_hdl = 0;
- mm_evt_paylod_add_stream_t *payload =
- (mm_evt_paylod_add_stream_t *)in_val;
- s_hdl = mm_channel_add_stream(my_obj,
- payload->buf_cb,
- payload->user_data,
- payload->ext_image_mode,
- payload->sensor_idx);
- *((uint32_t*)out_val) = s_hdl;
- rc = 0;
- }
- break;
- case MM_CHANNEL_EVT_DEL_STREAM:
- {
- uint32_t s_id = *((uint32_t *)in_val);
- rc = mm_channel_del_stream(my_obj, s_id);
- }
- break;
- case MM_CHANNEL_EVT_START_STREAM:
- {
- mm_evt_payload_start_stream_t *payload =
- (mm_evt_payload_start_stream_t *)in_val;
- rc = mm_channel_start_streams(my_obj,
- payload->num_streams,
- payload->stream_ids);
- /* first stream started in stopped state
- * move to active state */
- if (0 == rc) {
- my_obj->state = MM_CHANNEL_STATE_ACTIVE;
- }
- }
- break;
- case MM_CHANNEL_EVT_CONFIG_STREAM:
- {
- mm_evt_paylod_config_stream_t *payload =
- (mm_evt_paylod_config_stream_t *)in_val;
- rc = mm_channel_config_stream(my_obj,
- payload->stream_id,
- payload->config);
- }
- break;
- case MM_CHANNEL_EVT_INIT_BUNDLE:
- {
- mm_evt_payload_bundle_stream_t *payload =
- (mm_evt_payload_bundle_stream_t *)in_val;
- rc = mm_channel_bundle_stream(my_obj,
- payload->super_frame_notify_cb,
- payload->user_data,
- payload->attr,
- payload->num_streams,
- payload->stream_ids);
- }
- break;
- case MM_CHANNEL_EVT_DESTROY_BUNDLE:
- rc = mm_channel_destroy_bundle(my_obj);
- break;
- case MM_CHANNEL_EVT_PREPARE_SNAPSHOT:
- {
- uint32_t sensor_idx = (uint32_t)in_val;
- rc = mm_channel_prepare_snapshot(my_obj, sensor_idx);
- }
- break;
- case MM_CHANNEL_EVT_DELETE:
- mm_channel_release(my_obj);
- rc = 0;
- break;
- case MM_CHANNEL_EVT_SET_STREAM_PARM:
- {
- uint32_t s_id = (uint32_t)in_val;
- rc = mm_channel_set_stream_parm(my_obj, s_id, out_val);
- }
- break;
- case MM_CHANNEL_EVT_GET_STREAM_PARM:
- {
- uint32_t s_id = (uint32_t)in_val;
- rc = mm_channel_get_stream_parm(my_obj, s_id, out_val);
- }
- break;
- case MM_CHANNEL_EVT_OPEN_REPRO_ISP:
- {
- uint32_t repro_hdl = 0;
- mm_camera_repro_isp_type_t isp_type =
- (mm_camera_repro_isp_type_t)in_val;
- repro_hdl = mm_channel_open_repro_isp(my_obj, isp_type);
- *((uint32_t*)out_val) = repro_hdl;
- rc = 0;
- }
- break;
- case MM_CHANNEL_EVT_CONFIG_REPRO_ISP:
- {
- mm_evt_paylod_config_repro_isp_t *payload =
- (mm_evt_paylod_config_repro_isp_t *)in_val;
- rc = mm_channel_config_repro_isp(my_obj,
- payload->repro_isp_handle,
- payload->config);
- }
- break;
- case MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP:
- {
- mm_evt_paylod_stream_to_repro_isp_t *payload =
- (mm_evt_paylod_stream_to_repro_isp_t *)in_val;
- rc = mm_channel_repro_isp_dest_stream_ops(my_obj,
- payload->repro_isp_handle,
- payload->stream_id,
- TRUE);
- }
- break;
- case MM_CHANNEL_EVT_START_REPRO_ISP:
- {
- mm_evt_paylod_repro_start_stop_t *payload =
- (mm_evt_paylod_repro_start_stop_t*)in_val;
- rc = mm_channel_repro_isp_ops(my_obj,
- payload->repro_isp_handle,
- payload->stream_id,
- TRUE);
- }
- break;
- case MM_CHANNEL_EVT_REPROCESS:
- {
- mm_evt_paylod_reprocess_t *payload =
- (mm_evt_paylod_reprocess_t *)in_val;
- rc = mm_channel_reprocess(my_obj,
- payload->repro_isp_handle,
- payload->repro_data);
- }
- break;
- case MM_CHANNEL_EVT_STOP_REPRO_ISP:
- {
- mm_evt_paylod_repro_start_stop_t *payload =
- (mm_evt_paylod_repro_start_stop_t*)in_val;
- rc = mm_channel_repro_isp_ops(my_obj,
- payload->repro_isp_handle,
- payload->stream_id,
- FALSE);
- }
- break;
- case MM_CHANNEL_EVT_DETACH_STREAM_FROM_REPRO_ISP:
- {
- mm_evt_paylod_stream_to_repro_isp_t *payload =
- (mm_evt_paylod_stream_to_repro_isp_t *)in_val;
- rc = mm_channel_repro_isp_dest_stream_ops(my_obj,
- payload->repro_isp_handle,
- payload->stream_id,
- FALSE);
- }
- break;
- case MM_CHANNEL_EVT_CLOSE_REPRO_ISP:
- {
- uint32_t repro_handle = (uint32_t)in_val;
- rc = mm_channel_close_repro_isp(my_obj, repro_handle);
- }
- break;
- default:
- CDBG_ERROR("%s: invalid state (%d) for evt (%d)",
- __func__, my_obj->state, evt);
- break;
- }
- CDBG("%s : E rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_channel_fsm_fn_active(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
-
- CDBG("%s : E evt = %d",__func__,evt);
- switch (evt) {
- case MM_CHANNEL_EVT_CONFIG_STREAM:
- {
- mm_evt_paylod_config_stream_t *payload =
- (mm_evt_paylod_config_stream_t *)in_val;
- rc = mm_channel_config_stream(my_obj,
- payload->stream_id,
- payload->config);
- }
- break;
- case MM_CHANNEL_EVT_START_STREAM:
- {
- mm_evt_payload_start_stream_t *payload =
- (mm_evt_payload_start_stream_t *)in_val;
- rc = mm_channel_start_streams(my_obj,
- payload->num_streams,
- payload->stream_ids);
- }
- break;
- case MM_CHANNEL_EVT_STOP_STREAM:
- case MM_CHANNEL_EVT_TEARDOWN_STREAM:
- {
- int i;
- uint8_t tear_down_flag = (MM_CHANNEL_EVT_TEARDOWN_STREAM == evt)? 1:0;
- uint8_t all_stopped = 1;
- mm_evt_payload_stop_stream_t *payload =
- (mm_evt_payload_stop_stream_t *)in_val;
-
- rc = mm_channel_stop_streams(my_obj,
- payload->num_streams,
- payload->stream_ids,
- tear_down_flag);
-
- /* check if all streams are stopped
- * then we move to stopped state */
-
- for (i=0; i<MM_CAMEAR_STRAEM_NUM_MAX; i++) {
- if (MM_STREAM_STATE_ACTIVE_STREAM_ON == my_obj->streams[i].state ||
- MM_STREAM_STATE_ACTIVE_STREAM_OFF == my_obj->streams[i].state) {
- all_stopped = 0;
- break;
- }
- }
- if (all_stopped) {
- my_obj->state = MM_CHANNEL_STATE_STOPPED;
- }
-
- }
- break;
- case MM_CHANNEL_EVT_INIT_BUNDLE:
- {
- mm_evt_payload_bundle_stream_t *payload =
- (mm_evt_payload_bundle_stream_t *)in_val;
- rc = mm_channel_bundle_stream(my_obj,
- payload->super_frame_notify_cb,
- payload->user_data,
- payload->attr,
- payload->num_streams,
- payload->stream_ids);
- }
- break;
- case MM_CHANNEL_EVT_DESTROY_BUNDLE:
- rc = mm_channel_destroy_bundle(my_obj);
- break;
- case MM_CHANNEL_EVT_REQUEST_SUPER_BUF:
- {
- uint32_t num_buf_requested = (uint32_t)in_val;
- rc = mm_channel_request_super_buf(my_obj, num_buf_requested);
- }
- break;
- case MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF:
- rc = mm_channel_cancel_super_buf_request(my_obj);
- break;
- case MM_CHANNEL_EVT_START_FOCUS:
- {
- mm_evt_payload_start_focus_t* payload =
- (mm_evt_payload_start_focus_t *)in_val;
- rc = mm_channel_start_focus(my_obj,
- payload->sensor_idx,
- payload->focus_mode);
- }
- break;
- case MM_CHANNEL_EVT_ABORT_FOCUS:
- {
- uint32_t sensor_idx = (uint32_t)in_val;
- rc = mm_channel_abort_focus(my_obj, sensor_idx);
- }
- break;
- case MM_CHANNEL_EVT_PREPARE_SNAPSHOT:
- {
- uint32_t sensor_idx = (uint32_t)in_val;
- rc = mm_channel_prepare_snapshot(my_obj, sensor_idx);
- }
- break;
- case MM_CHANNEL_EVT_SET_STREAM_PARM:
- {
- uint32_t s_id = (uint32_t)in_val;
- rc = mm_channel_set_stream_parm(my_obj, s_id, out_val);
- }
- break;
- case MM_CHANNEL_EVT_GET_STREAM_PARM:
- {
- uint32_t s_id = (uint32_t)in_val;
- rc = mm_channel_get_stream_parm(my_obj, s_id, out_val);
- }
- break;
-
- case MM_CHANNEL_EVT_DEL_STREAM:
- {
- uint32_t s_id = *((uint32_t *)in_val);
- rc = mm_channel_del_stream(my_obj, s_id);
- }
- break;
- case MM_CHANNEL_EVT_ATTACH_STREAM_TO_REPRO_ISP:
- {
- mm_evt_paylod_stream_to_repro_isp_t *payload =
- (mm_evt_paylod_stream_to_repro_isp_t *)in_val;
- rc = mm_channel_repro_isp_dest_stream_ops(my_obj,
- payload->repro_isp_handle,
- payload->stream_id,
- TRUE);
- }
- break;
- case MM_CHANNEL_EVT_START_REPRO_ISP:
- {
- mm_evt_paylod_repro_start_stop_t *payload =
- (mm_evt_paylod_repro_start_stop_t*)in_val;
- rc = mm_channel_repro_isp_ops(my_obj,
- payload->repro_isp_handle,
- payload->stream_id,
- TRUE);
- }
- break;
- case MM_CHANNEL_EVT_REPROCESS:
- {
- mm_evt_paylod_reprocess_t *payload =
- (mm_evt_paylod_reprocess_t *)in_val;
- rc = mm_channel_reprocess(my_obj,
- payload->repro_isp_handle,
- payload->repro_data);
- }
- break;
- case MM_CHANNEL_EVT_STOP_REPRO_ISP:
- {
- mm_evt_paylod_repro_start_stop_t *payload =
- (mm_evt_paylod_repro_start_stop_t*)in_val;
- rc = mm_channel_repro_isp_ops(my_obj,
- payload->repro_isp_handle,
- payload->stream_id,
- FALSE);
- }
- break;
- case MM_CHANNEL_EVT_DETACH_STREAM_FROM_REPRO_ISP:
- {
- mm_evt_paylod_stream_to_repro_isp_t *payload =
- (mm_evt_paylod_stream_to_repro_isp_t *)in_val;
- rc = mm_channel_repro_isp_dest_stream_ops(my_obj,
- payload->repro_isp_handle,
- payload->stream_id,
- FALSE);
- }
- break;
- default:
- CDBG_ERROR("%s: invalid state (%d) for evt (%d)",
- __func__, my_obj->state, evt);
- break;
- }
- CDBG("%s : X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_channel_fsm_fn_paused(mm_channel_t *my_obj,
- mm_channel_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
-
- /* currently we are not supporting pause/resume channel */
- CDBG_ERROR("%s: evt (%d) not supported in state (%d)",
- __func__, evt, my_obj->state);
-
- return rc;
-}
-
-int32_t mm_channel_init(mm_channel_t *my_obj)
-{
- int32_t rc = 0;
- CDBG("%s : Launch data poll thread in channel open",__func__);
- mm_camera_poll_thread_launch(&my_obj->poll_thread[0],
- MM_CAMERA_POLL_TYPE_CH);
-
- /* change state to stopped state */
- my_obj->state = MM_CHANNEL_STATE_STOPPED;
- return rc;
-}
-
-void mm_channel_release(mm_channel_t *my_obj)
-{
- /* stop data poll thread */
- mm_camera_poll_thread_release(&my_obj->poll_thread[0]);
-
- /* change state to notused state */
- my_obj->state = MM_CHANNEL_STATE_NOTUSED;
-}
-
-uint32_t mm_channel_get_ext_mode_from_img_mode(uint32_t img_mode)
-{
- switch (img_mode) {
- case MM_CAMERA_PREVIEW:
- return MSM_V4L2_EXT_CAPTURE_MODE_PREVIEW;
- case MM_CAMERA_VIDEO:
- return MSM_V4L2_EXT_CAPTURE_MODE_VIDEO;
- case MM_CAMERA_SNAPSHOT_MAIN:
- return MSM_V4L2_EXT_CAPTURE_MODE_MAIN;
- case MM_CAMERA_SNAPSHOT_THUMBNAIL:
- return MSM_V4L2_EXT_CAPTURE_MODE_THUMBNAIL;
- case MM_CAMERA_SNAPSHOT_RAW:
- return MSM_V4L2_EXT_CAPTURE_MODE_RAW;
- case MM_CAMERA_RDI:
- return MSM_V4L2_EXT_CAPTURE_MODE_RDI;
- case MM_CAMERA_RDI1:
- return MSM_V4L2_EXT_CAPTURE_MODE_RDI1;
- case MM_CAMERA_RDI2:
- return MSM_V4L2_EXT_CAPTURE_MODE_RDI2;
- case MM_CAMERA_SAEC:
- return MSM_V4L2_EXT_CAPTURE_MODE_AEC;
- case MM_CAMERA_SAWB:
- return MSM_V4L2_EXT_CAPTURE_MODE_AWB;
- case MM_CAMERA_SAFC:
- return MSM_V4L2_EXT_CAPTURE_MODE_AF;
- case MM_CAMERA_IHST:
- return MSM_V4L2_EXT_CAPTURE_MODE_IHIST;
- case MM_CAMERA_CS:
- return MSM_V4L2_EXT_CAPTURE_MODE_CS;
- case MM_CAMERA_RS:
- return MSM_V4L2_EXT_CAPTURE_MODE_RS;
- case MM_CAMERA_CSTA:
- return MSM_V4L2_EXT_CAPTURE_MODE_CSTA;
- case MM_CAMERA_ISP_PIX_OUTPUT1:
- return MSM_V4L2_EXT_CAPTURE_MODE_ISP_PIX_OUTPUT1;
- case MM_CAMERA_ISP_PIX_OUTPUT2:
- return MSM_V4L2_EXT_CAPTURE_MODE_ISP_PIX_OUTPUT2;
- default:
- return MSM_V4L2_EXT_CAPTURE_MODE_DEFAULT;
- }
-}
-
-uint32_t mm_channel_add_stream(mm_channel_t *my_obj,
- mm_camera_buf_notify_t buf_cb, void *user_data,
- uint32_t ext_image_mode, uint32_t sensor_idx)
-{
- int32_t rc = 0;
- uint8_t idx = 0;
- uint32_t s_hdl = 0;
- mm_stream_t *stream_obj = NULL;
-
- CDBG("%s : image mode = %d",__func__,ext_image_mode);
- /* check available stream */
- for (idx = 0; idx < MM_CAMEAR_STRAEM_NUM_MAX; idx++) {
- if (MM_STREAM_STATE_NOTUSED == my_obj->streams[idx].state) {
- stream_obj = &my_obj->streams[idx];
- break;
- }
- }
- if (NULL == stream_obj) {
- CDBG_ERROR("%s: streams reach max, no more stream allowed to add", __func__);
- return s_hdl;
- }
-
- /* initialize stream object */
- memset(stream_obj, 0, sizeof(mm_stream_t));
- stream_obj->my_hdl = mm_camera_util_generate_handler(idx);
- stream_obj->ch_obj = my_obj;
- /* cd through intf always palced at idx 0 of buf_cb */
- stream_obj->buf_cb[0].cb = buf_cb;
- stream_obj->buf_cb[0].user_data = user_data;
- stream_obj->buf_cb[0].cb_count = -1; /* infinite by default */
- stream_obj->ext_image_mode =
- mm_channel_get_ext_mode_from_img_mode(ext_image_mode);
- stream_obj->sensor_idx = sensor_idx;
- stream_obj->fd = -1;
- pthread_mutex_init(&stream_obj->buf_lock, NULL);
- pthread_mutex_init(&stream_obj->cb_lock, NULL);
- stream_obj->state = MM_STREAM_STATE_INITED;
-
- /* acquire stream */
- rc = mm_stream_fsm_fn(stream_obj, MM_STREAM_EVT_ACQUIRE, NULL, NULL);
- if (0 == rc) {
- s_hdl = stream_obj->my_hdl;
- } else {
- /* error during acquire, de-init */
- pthread_mutex_destroy(&stream_obj->buf_lock);
- pthread_mutex_destroy(&stream_obj->cb_lock);
- memset(stream_obj, 0, sizeof(mm_stream_t));
- }
- CDBG("%s : stream handle = %d",__func__,s_hdl);
- return s_hdl;
-}
-
-int32_t mm_channel_del_stream(mm_channel_t *my_obj,
- uint32_t stream_id)
-{
- int rc = -1;
- mm_stream_t * stream_obj = NULL;
- stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_id);
-
- if (NULL == stream_obj) {
- CDBG_ERROR("%s :Invalid Stream Object for stream_id = %d",__func__, stream_id);
- return rc;
- }
-
- rc = mm_stream_fsm_fn(stream_obj,
- MM_STREAM_EVT_RELEASE,
- NULL,
- NULL);
-
- return rc;
-}
-
-int32_t mm_channel_config_stream(mm_channel_t *my_obj,
- uint32_t stream_id,
- mm_camera_stream_config_t *config)
-{
- int rc = -1;
- mm_stream_t * stream_obj = NULL;
- CDBG("%s : E stream ID = %d",__func__,stream_id);
- stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_id);
-
- if (NULL == stream_obj) {
- CDBG_ERROR("%s :Invalid Stream Object for stream_id = %d",__func__, stream_id);
- return rc;
- }
-
- /* set stream fmt */
- rc = mm_stream_fsm_fn(stream_obj,
- MM_STREAM_EVT_SET_FMT,
- (void *)config,
- NULL);
- CDBG("%s : X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_channel_bundle_stream(mm_channel_t *my_obj,
- mm_camera_buf_notify_t super_frame_notify_cb,
- void *user_data,
- mm_camera_bundle_attr_t *attr,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = 0;
- int i;
- cam_stream_bundle_t bundle;
- mm_stream_t* s_objs[MM_CAMEAR_MAX_STRAEM_BUNDLE] = {NULL};
-
- /* first check if all streams to be bundled are valid */
- for (i=0; i < num_streams; i++) {
- s_objs[i] = mm_channel_util_get_stream_by_handler(my_obj, stream_ids[i]);
- if (NULL == s_objs[i]) {
- CDBG_ERROR("%s: invalid stream handler %d (idx=%d) to be bundled",
- __func__, stream_ids[i], i);
- return -1;
- }
- }
-
- /* init superbuf queue */
- mm_channel_superbuf_queue_init(&my_obj->bundle.superbuf_queue);
-
- memset(&bundle, 0, sizeof(bundle));
- /* save bundle config */
- memcpy(&my_obj->bundle.superbuf_queue.attr, attr, sizeof(mm_camera_bundle_attr_t));
- my_obj->bundle.super_buf_notify_cb = super_frame_notify_cb;
- my_obj->bundle.user_data = user_data;
- my_obj->bundle.superbuf_queue.num_streams = num_streams;
- my_obj->bundle.superbuf_queue.expected_frame_id = 0;
-
- for (i=0; i < num_streams; i++) {
- /* set bundled flag to streams */
- s_objs[i]->is_bundled = 1;
- /* init bundled streams to invalid value -1 */
- my_obj->bundle.superbuf_queue.bundled_streams[i] = stream_ids[i];
- bundle.stream_handles[bundle.num++] =
- s_objs[i]->inst_hdl;
- }
- /* in the case of 1 bundle , current implementation is nop */
- if (bundle.num > 1) {
- rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_SET_BUNDLE,
- sizeof(bundle),
- (void *)&bundle);
- if (0 != rc) {
- CDBG_ERROR("%s: set_bundle failed (rc=%d)", __func__, rc);
- return -1;
- }
- }
-
- /* launch cb thread for dispatching super buf through cb */
- mm_camera_cmd_thread_launch(&my_obj->cb_thread,
- mm_channel_dispatch_super_buf,
- (void*)my_obj);
-
- /* launch cmd thread for super buf dataCB */
- mm_camera_cmd_thread_launch(&my_obj->cmd_thread,
- mm_channel_process_stream_buf,
- (void*)my_obj);
-
- /* set flag to TRUE */
- my_obj->bundle.is_active = TRUE;
-
- return rc;
-}
-
-/* bundled streams must all be stopped before bundle can be destroyed */
-int32_t mm_channel_destroy_bundle(mm_channel_t *my_obj)
-{
- mm_stream_t* s_obj = NULL;
- uint8_t i;
-
- if (FALSE == my_obj->bundle.is_active) {
- CDBG("%s: bundle not active, no need to destroy", __func__);
- return 0;
- }
-
- /* first check all bundled streams should be stopped already */
- for (i=0; i < my_obj->bundle.superbuf_queue.num_streams; i++) {
- s_obj = mm_channel_util_get_stream_by_handler(my_obj,
- my_obj->bundle.superbuf_queue.bundled_streams[i]);
- if (NULL != s_obj) {
- if (MM_STREAM_STATE_ACTIVE_STREAM_ON == s_obj->state ||
- MM_STREAM_STATE_ACTIVE_STREAM_OFF == s_obj->state) {
- CDBG_ERROR("%s: at least one of the bundled streams (%d) is still active",
- __func__, my_obj->bundle.superbuf_queue.bundled_streams[i]);
- return -1;
- }
- }
- }
-
- /* deinit superbuf queue */
- mm_channel_superbuf_queue_deinit(my_obj, &my_obj->bundle.superbuf_queue);
-
- /* memset bundle info */
- memset(&my_obj->bundle, 0, sizeof(mm_channel_bundle_t));
- my_obj->bundle.is_active = FALSE;
- return 0;
-}
-
-int32_t mm_channel_start_streams(mm_channel_t *my_obj,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = 0;
- int i, j;
- mm_stream_t* s_objs[MM_CAMEAR_MAX_STRAEM_BUNDLE] = {NULL};
- uint8_t num_streams_to_start = num_streams;
- uint32_t streams_to_start[MM_CAMEAR_MAX_STRAEM_BUNDLE];
- uint8_t bundle_to_start = 0;
-
- /* check if any bundled stream to be start,
- * then all bundled stream should be started */
- memcpy(streams_to_start, stream_ids, sizeof(uint32_t) * num_streams);
- for (i=0; i < num_streams; i++) {
- for (j=0; j < my_obj->bundle.superbuf_queue.num_streams; j++) {
- if (stream_ids[i] == my_obj->bundle.superbuf_queue.bundled_streams[j]) {
- bundle_to_start = 1;
- break;
- }
- }
- }
-
- if (bundle_to_start) {
- uint8_t need_add;
- /* add bundled streams into the start list if not already added*/
- for (i=0; i<my_obj->bundle.superbuf_queue.num_streams; i++) {
- need_add = 1;
- for (j=0; j<num_streams; j++) {
- if (stream_ids[j] == my_obj->bundle.superbuf_queue.bundled_streams[i]) {
- need_add = 0;
- break;
- }
- }
- if (need_add) {
- streams_to_start[num_streams_to_start++] =
- my_obj->bundle.superbuf_queue.bundled_streams[i];
- }
- }
- }
-
- /* check if all streams to be started are valid */
- for (i=0; i<num_streams_to_start; i++) {
- s_objs[i] = mm_channel_util_get_stream_by_handler(my_obj, streams_to_start[i]);
-
- if (NULL == s_objs[i]) {
- CDBG_ERROR("%s: invalid stream handler %d (idx=%d) to be started",
- __func__, streams_to_start[i], i);
- return -1;
- }
- }
-
- for (i=0; i<num_streams_to_start; i++) {
- /* if stream is already started, there is no need to start it */
- if (s_objs[i]->state == MM_STREAM_STATE_ACTIVE_STREAM_ON ||
- s_objs[i]->state == MM_STREAM_STATE_ACTIVE_STREAM_OFF) {
- continue;
- }
-
- /* allocate buf */
- rc = mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_GET_BUF,
- NULL,
- NULL);
- if (0 != rc) {
- CDBG_ERROR("%s: get buf failed at idx(%d)", __func__, i);
- break;
- }
-
- /* reg buf */
- rc = mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_REG_BUF,
- NULL,
- NULL);
- if (0 != rc) {
- CDBG_ERROR("%s: reg buf failed at idx(%d)", __func__, i);
- break;
- }
-
- /* start stream */
- rc = mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_START,
- NULL,
- NULL);
- if (0 != rc) {
- CDBG_ERROR("%s: start stream failed at idx(%d)", __func__, i);
- break;
- }
- }
-
- /* error handling */
- if (0 != rc) {
- for (j=0; j<=i; j++) {
- /* stop streams*/
- mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_STOP,
- NULL,
- NULL);
-
- /* unreg buf */
- mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_UNREG_BUF,
- NULL,
- NULL);
-
- /* put buf back */
- mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_PUT_BUF,
- NULL,
- NULL);
- }
- }
-
- return rc;
-}
-
-/* Required: bundled streams need to be stopped together */
-int32_t mm_channel_stop_streams(mm_channel_t *my_obj,
- uint8_t num_streams,
- uint32_t *stream_ids,
- uint8_t tear_down_flag)
-{
- int32_t rc = 0;
- int i, j;
- mm_stream_t* s_objs[MM_CAMEAR_MAX_STRAEM_BUNDLE] = {NULL};
- uint8_t num_streams_to_stop = num_streams;
- uint32_t streams_to_stop[MM_CAMEAR_MAX_STRAEM_BUNDLE];
- uint8_t bundle_to_stop = 0;
-
- /* make sure bundled streams are stopped together */
- memcpy(streams_to_stop, stream_ids, sizeof(uint32_t) * num_streams);
- for (i=0; i<num_streams; i++) {
- for (j=0; j<my_obj->bundle.superbuf_queue.num_streams; j++) {
- if (stream_ids[i] == my_obj->bundle.superbuf_queue.bundled_streams[j]) {
- bundle_to_stop = 1;
- break;
- }
- }
- }
- if (bundle_to_stop) {
- /* first stop bundle thread */
- mm_camera_cmd_thread_stop(&my_obj->cmd_thread);
- mm_camera_cmd_thread_stop(&my_obj->cb_thread);
-
- uint8_t need_add;
- /* add bundled streams into the start list if not already added*/
- for (i=0; i<my_obj->bundle.superbuf_queue.num_streams; i++) {
- need_add = 1;
- for (j=0; j<num_streams; j++) {
- if (stream_ids[j] == my_obj->bundle.superbuf_queue.bundled_streams[i]) {
- need_add = 0;
- break;
- }
- }
- if (need_add) {
- streams_to_stop[num_streams_to_stop++] =
- my_obj->bundle.superbuf_queue.bundled_streams[i];
- }
- }
- }
-
- for (i=0; i<num_streams_to_stop; i++) {
- s_objs[i] = mm_channel_util_get_stream_by_handler(my_obj, streams_to_stop[i]);
-
- if (NULL != s_objs[i]) {
- /* stream off */
- mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_STOP,
- NULL,
- NULL);
-
- /* unreg buf at kernel */
- mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_UNREG_BUF,
- NULL,
- NULL);
- }
- }
-
- /* destroy super buf cmd thread */
- if (bundle_to_stop) {
- /* first stop bundle thread */
- mm_camera_cmd_thread_destroy(&my_obj->cmd_thread);
- mm_camera_cmd_thread_destroy(&my_obj->cb_thread);
- }
-
- /* since all streams are stopped, we are safe to
- * release all buffers allocated in stream */
- for (i=0; i<num_streams_to_stop; i++) {
- if (NULL != s_objs[i]) {
- /* put buf back */
- mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_PUT_BUF,
- NULL,
- NULL);
-
- if (tear_down_flag) {
- /* to tear down stream totally, stream needs to be released */
- mm_stream_fsm_fn(s_objs[i],
- MM_STREAM_EVT_RELEASE,
- NULL,
- NULL);
- }
- }
- }
-
- return rc;
-}
-
-int32_t mm_channel_request_super_buf(mm_channel_t *my_obj, uint32_t num_buf_requested)
-{
- int32_t rc = 0;
- mm_camera_cmdcb_t* node = NULL;
-
- /* set pending_cnt
- * will trigger dispatching super frames if pending_cnt > 0 */
- /* send sem_post to wake up cmd thread to dispatch super buffer */
- node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL != node) {
- memset(node, 0, sizeof(mm_camera_cmdcb_t));
- node->cmd_type = MM_CAMERA_CMD_TYPE_REQ_DATA_CB;
- node->u.req_buf.num_buf_requested = num_buf_requested;
-
- /* enqueue to cmd thread */
- mm_camera_queue_enq(&(my_obj->cmd_thread.cmd_queue), node);
-
- /* wake up cmd thread */
- sem_post(&(my_obj->cmd_thread.cmd_sem));
- } else {
- CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
- rc = -1;
- }
-
- return rc;
-}
-
-int32_t mm_channel_cancel_super_buf_request(mm_channel_t *my_obj)
-{
- int32_t rc = 0;
- /* reset pending_cnt */
- my_obj->pending_cnt = 0;
-
- return rc;
-}
-
-int32_t mm_channel_qbuf(mm_channel_t *my_obj,
- mm_camera_buf_def_t *buf)
-{
- int32_t rc = -1;
- mm_stream_t* s_obj = mm_channel_util_get_stream_by_handler(my_obj, buf->stream_id);
-
- if (NULL != s_obj) {
- rc = mm_stream_fsm_fn(s_obj,
- MM_STREAM_EVT_QBUF,
- (void *)buf,
- NULL);
- }
-
- return rc;
-}
-
-int32_t mm_channel_start_focus(mm_channel_t *my_obj,
- uint32_t sensor_idx,
- uint32_t focus_mode)
-{
- return mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_SET_PARM_AUTO_FOCUS,
- sizeof(uint32_t), (void*)focus_mode);
-}
-
-int32_t mm_channel_abort_focus(mm_channel_t *my_obj, uint32_t sensor_idx)
-{
- return mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_AUTO_FOCUS_CANCEL,
- 0, NULL);
-}
-
-int32_t mm_channel_prepare_snapshot(mm_channel_t *my_obj, uint32_t sensor_idx)
-{
- return mm_camera_send_native_ctrl_timeout_cmd(my_obj->cam_obj,
- CAMERA_PREPARE_SNAPSHOT,
- 0, NULL, 2000);
-}
-
-int32_t mm_channel_set_stream_parm(mm_channel_t *my_obj,
- uint32_t s_id,
- void *value)
-{
- int32_t rc = -1;
- mm_stream_t* s_obj = mm_channel_util_get_stream_by_handler(my_obj, s_id);
- if (NULL != s_obj) {
- rc = mm_stream_fsm_fn(s_obj,
- MM_STREAM_EVT_SET_PARM,
- value,
- NULL);
- }
-
- return rc;
-}
-
-int32_t mm_channel_get_stream_parm(mm_channel_t *my_obj,
- uint32_t s_id,
- void *value)
-{
- int32_t rc = -1;
- mm_stream_t* s_obj = mm_channel_util_get_stream_by_handler(my_obj, s_id);
- if (NULL != s_obj) {
- rc = mm_stream_fsm_fn(s_obj,
- MM_STREAM_EVT_GET_PARM,
- NULL,
- value);
- }
-
- return rc;
-}
-
-int32_t mm_channel_do_post_processing(mm_channel_t *my_obj,
- mm_channel_queue_node_t *super_buf)
-{
- int32_t rc = 0;
- uint8_t pp_mask = 0;
-
- pp_mask = mm_camera_util_get_pp_mask(my_obj->cam_obj);
-
- if (pp_mask & CAMERA_PP_MASK_TYPE_WNR) {
- mm_camera_wnr_info_t wnr_info;
- uint8_t i, j = 0;
- mm_stream_t* s_obj = NULL;
-
- memset(&wnr_info, 0, sizeof(mm_camera_wnr_info_t));
- for (i = 0; i < super_buf->num_of_bufs; i++) {
- s_obj = mm_channel_util_get_stream_by_handler(my_obj, super_buf->super_buf[i].stream_id);
- if (NULL != s_obj) {
- wnr_info.frames[j].instance_hdl = s_obj->inst_hdl;
- wnr_info.frames[j].frame_idx = super_buf->super_buf[i].buf->buf_idx;
- wnr_info.frames[j].frame_width = s_obj->fmt.width;
- wnr_info.frames[j].frame_height = s_obj->fmt.height;
- memcpy(&wnr_info.frames[j].frame_offset,
- &s_obj->frame_offset,
- sizeof(cam_frame_len_offset_t));
- j++;
- }
- }
- wnr_info.num_frames = j;
-
- rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_DO_PP_WNR,
- sizeof(mm_camera_wnr_info_t),
- (void *)&wnr_info);
- if (0 != rc) {
- CDBG_ERROR("%s: do_pp_wnr failed (rc=%d)", __func__, rc);
- }
- }
-
- return rc;
-}
-
-int32_t mm_channel_reg_stream_cb(mm_channel_t *my_obj,
- mm_stream_data_cb_t *cb,
- uint32_t ext_image_mode,
- uint32_t sensor_idx)
-{
- uint8_t idx;
- mm_stream_t *dest_stream = NULL;
- int32_t rc = -1;
-
- /* browse all streams in channel to find the destination */
- for (idx=0; idx < MM_CAMEAR_STRAEM_NUM_MAX; idx++) {
- if (my_obj->streams[idx].state != MM_STREAM_STATE_NOTUSED &&
- my_obj->streams[idx].ext_image_mode == ext_image_mode &&
- my_obj->streams[idx].sensor_idx == sensor_idx) {
- /* find matching stream as the destination */
- dest_stream = &my_obj->streams[idx];
- break;
- }
- }
-
- if (NULL != dest_stream) {
- rc = mm_stream_reg_buf_cb(dest_stream, cb);
- }
-
- return rc;
-}
-
-int32_t mm_channel_superbuf_queue_init(mm_channel_queue_t * queue)
-{
- return mm_camera_queue_init(&queue->que);
-}
-
-int32_t mm_channel_superbuf_queue_deinit(mm_channel_t *my_obj,
- mm_channel_queue_t * queue)
-{
- return mm_camera_queue_deinit(&queue->que);
-}
-
-int8_t mm_channel_util_seq_comp_w_rollover(uint32_t v1,
- uint32_t v2)
-{
- int8_t ret = 0;
-
- /* TODO: need to handle the case if v2 roll over to 0 */
- if (v1 > v2) {
- ret = 1;
- } else if (v1 < v2) {
- ret = -1;
- }
-
- return ret;
-}
-
-int32_t mm_channel_superbuf_comp_and_enqueue(
- mm_channel_t* ch_obj,
- mm_channel_queue_t * queue,
- mm_camera_buf_info_t *buf_info)
-{
- mm_camera_q_node_t* node = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
- mm_channel_queue_node_t* super_buf = NULL;
- uint8_t buf_s_idx, i;
-
- CDBG("%s: E", __func__);
- for (buf_s_idx=0; buf_s_idx < queue->num_streams; buf_s_idx++) {
- if (buf_info->stream_id == queue->bundled_streams[buf_s_idx]) {
- break;
- }
- }
- if (buf_s_idx == queue->num_streams) {
- CDBG_ERROR("%s: buf from stream (%d) not bundled", __func__, buf_info->stream_id);
- return -1;
- }
-
- if (mm_channel_util_seq_comp_w_rollover(buf_info->frame_idx,
- queue->expected_frame_id) < 0) {
- /* incoming buf is older than expected buf id, will discard it */
- mm_channel_qbuf(ch_obj, buf_info->buf);
- return 0;
- }
-
- if (MM_CAMERA_SUPER_BUF_PRIORITY_NORMAL != queue->attr.priority) {
- /* TODO */
- /* need to decide if we want to queue the frame based on focus or exposure
- * if frame not to be queued, we need to qbuf it back */
- }
-
- /* comp */
- pthread_mutex_lock(&queue->que.lock);
- head = &queue->que.head.list;
- /* get the last one in the queue which is possibly having no matching */
- pos = head->next;
- while (pos != head) {
- node = member_of(pos, mm_camera_q_node_t, list);
- super_buf = (mm_channel_queue_node_t*)node->data;
- if (NULL != super_buf) {
- if (super_buf->matched) {
- /* find a matched super buf, move to next one */
- pos = pos->next;
- continue;
- } else {
- /* have an unmatched super buf, break the loop */
- break;
- }
- }
- }
-
- if (pos == head) {
- CDBG("%s: all nodes in queue are mtached, or no node in queue, create a new node", __func__);
- /* all nodes in queue are mtached, or no node in queue
- * create a new node */
- mm_channel_queue_node_t *new_buf = NULL;
- mm_camera_q_node_t* new_node = NULL;
-
- new_buf = (mm_channel_queue_node_t*)malloc(sizeof(mm_channel_queue_node_t));
- new_node = (mm_camera_q_node_t*)malloc(sizeof(mm_camera_q_node_t));
- if (NULL != new_buf && NULL != new_node) {
- memset(new_buf, 0, sizeof(mm_channel_queue_node_t));
- memset(new_node, 0, sizeof(mm_camera_q_node_t));
- new_node->data = (void *)new_buf;
- new_buf->num_of_bufs = queue->num_streams;
- memcpy(&new_buf->super_buf[buf_s_idx], buf_info, sizeof(mm_camera_buf_info_t));
-
- /* enqueue */
- //cam_list_add_tail_node(&node->list, &queue->que.head.list);
- cam_list_add_tail_node(&new_node->list, &queue->que.head.list);
- queue->que.size++;
-
- if(queue->num_streams == 1) {
- //TODO : Check. Live snapshot will have one stream in bundle?
- new_buf->matched = 1;
-
- if (new_buf->matched) {
- queue->expected_frame_id = buf_info->frame_idx + queue->attr.post_frame_skip;
- queue->match_cnt++;
- }
- }
- } else {
- /* No memory */
- if (NULL != new_buf) {
- free(new_buf);
- }
- if (NULL != new_node) {
- free(new_node);
- }
- /* qbuf the new buf since we cannot enqueue */
- mm_channel_qbuf(ch_obj, buf_info->buf);
- }
- } else {
- CDBG("%s: find an unmatched super buf", __func__);
- /* find an unmatched super buf */
- if (super_buf->super_buf[buf_s_idx].frame_idx == 0) {
- /* new frame from the stream_id */
- uint8_t is_new = 1;
- uint32_t frame_idx;
-
- for (i=0; i < super_buf->num_of_bufs; i++) {
- //for (i=0; i < buf_s_idx; i++) {
- if(super_buf->super_buf[i].buf == NULL) {
- continue;
- }
- frame_idx = super_buf->super_buf[i].buf->frame_idx;
- if (frame_idx == 0) {
- continue;
- }
- if (frame_idx < buf_info->frame_idx) {
- /* existing frame is older than the new frame, qbuf it */
- mm_channel_qbuf(ch_obj, super_buf->super_buf[i].buf);
- memset(&super_buf->super_buf[i], 0, sizeof(mm_camera_buf_info_t));
- } else if (frame_idx > buf_info->frame_idx) {
- /* new frame is older */
- is_new = 0;
- break;
- }else{
- //TODO: reveiw again
- break;
- }
- }
- if (is_new) {
- CDBG("%s: add stream = %d frame id = %d ",
- __func__, buf_info->stream_id, buf_info->frame_idx);
- memcpy(&super_buf->super_buf[buf_s_idx], buf_info, sizeof(mm_camera_buf_info_t));
-
- /* check if superbuf is all matched */
- super_buf->matched = 1;
- for (i=0; i < super_buf->num_of_bufs; i++) {
- if (super_buf->super_buf[i].frame_idx == 0) {
- super_buf->matched = 0;
- break;
- }
- }
-
- if (super_buf->matched) {
- queue->expected_frame_id = buf_info->frame_idx + queue->attr.post_frame_skip;
- queue->match_cnt++;
- CDBG("%s, match_cnt = %d", __func__, queue->match_cnt);
- }
- } else {
- mm_channel_qbuf(ch_obj, buf_info->buf);
- }
- } else {
- if (super_buf->super_buf[buf_s_idx].frame_idx < buf_info->frame_idx) {
- CDBG("%s: new frame is newer, add into superbuf", __func__);
- /* current frames in superbuf are older than the new frame
- * qbuf all current frames */
- for (i=0; i<super_buf->num_of_bufs; i++) {
- if (super_buf->super_buf[i].frame_idx != 0) {
- mm_channel_qbuf(ch_obj, super_buf->super_buf[i].buf);
- memset(&super_buf->super_buf[i], 0, sizeof(mm_camera_buf_info_t));
- }
- }
- /* add the new frame into the superbuf */
- memcpy(&super_buf->super_buf[buf_s_idx], buf_info, sizeof(mm_camera_buf_info_t));
- } else {
- /* the new frame is older, just ignor */
- mm_channel_qbuf(ch_obj, buf_info->buf);
- }
- }
- }
- pthread_mutex_unlock(&queue->que.lock);
-
- CDBG("%s: X", __func__);
- return 0;
-}
-
-mm_channel_queue_node_t* mm_channel_superbuf_dequeue_internal(mm_channel_queue_t * queue)
-{
- mm_camera_q_node_t* node = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
- mm_channel_queue_node_t* super_buf = NULL;
-
- head = &queue->que.head.list;
- pos = head->next;
- if (pos != head) {
- /* get the first node */
- node = member_of(pos, mm_camera_q_node_t, list);
- super_buf = (mm_channel_queue_node_t*)node->data;
- if (NULL != super_buf) {
- if (super_buf->matched) {
- /* we found a mtaching super buf, dequeue it */
- cam_list_del_node(&node->list);
- queue->que.size--;
- queue->match_cnt--;
- free(node);
- } else {
- super_buf = NULL;
- }
- }
- }
-
- return super_buf;
-}
-
-mm_channel_queue_node_t* mm_channel_superbuf_dequeue(mm_channel_queue_t * queue)
-{
- mm_camera_q_node_t* node = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
- mm_channel_queue_node_t* super_buf = NULL;
-
- pthread_mutex_lock(&queue->que.lock);
- super_buf = mm_channel_superbuf_dequeue_internal(queue);
- pthread_mutex_unlock(&queue->que.lock);
-
- return super_buf;
-}
-
-int32_t mm_channel_superbuf_bufdone_overflow(mm_channel_t* my_obj,
- mm_channel_queue_t * queue)
-{
- int32_t rc = 0, i;
- mm_channel_queue_node_t* super_buf = NULL;
- if (MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS == queue->attr.notify_mode) {
- /* for continuous streaming mode, no overflow is needed */
- return 0;
- }
-
- CDBG("%s: before match_cnt=%d, water_mark=%d",
- __func__, queue->match_cnt, queue->attr.water_mark);
- /* bufdone overflowed bufs */
- pthread_mutex_lock(&queue->que.lock);
- while (queue->match_cnt > queue->attr.water_mark) {
- super_buf = mm_channel_superbuf_dequeue_internal(queue);
- if (NULL != super_buf) {
- for (i=0; i<super_buf->num_of_bufs; i++) {
- if (NULL != super_buf->super_buf[i].buf) {
- mm_channel_qbuf(my_obj, super_buf->super_buf[i].buf);
- }
- }
- free(super_buf);
- }
- }
- pthread_mutex_unlock(&queue->que.lock);
- CDBG("%s: after match_cnt=%d, water_mark=%d",
- __func__, queue->match_cnt, queue->attr.water_mark);
-
- return rc;
-}
-
-int32_t mm_channel_superbuf_skip(mm_channel_t* my_obj,
- mm_channel_queue_t * queue)
-{
- int32_t rc = 0, i, count;
- mm_channel_queue_node_t* super_buf = NULL;
- if (MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS == queue->attr.notify_mode) {
- /* for continuous streaming mode, no skip is needed */
- return 0;
- }
-
- /* bufdone overflowed bufs */
- pthread_mutex_lock(&queue->que.lock);
- while (queue->match_cnt > queue->attr.look_back) {
- super_buf = mm_channel_superbuf_dequeue_internal(queue);
- if (NULL != super_buf) {
- for (i=0; i<super_buf->num_of_bufs; i++) {
- if (NULL != super_buf->super_buf[i].buf) {
- mm_channel_qbuf(my_obj, super_buf->super_buf[i].buf);
- }
- }
- free(super_buf);
- }
- }
- pthread_mutex_unlock(&queue->que.lock);
-
- return rc;
-}
-
-uint32_t mm_channel_open_repro_isp(mm_channel_t *my_obj,
- mm_camera_repro_isp_type_t isp_type)
-{
- int32_t rc = -1;
- mm_camera_repro_cmd_t repro_cmd;
-
- memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
- repro_cmd.cmd = MM_CAMERA_REPRO_CMD_OPEN;
- repro_cmd.payload.open.isp_type = isp_type;
- rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_SEND_PP_PIPELINE_CMD,
- sizeof(mm_camera_repro_cmd_t),
- (void *)&repro_cmd);
- if (0 != rc) {
- CDBG_ERROR("%s: open repo isp failed (rc=%d)", __func__, rc);
- }
- return repro_cmd.payload.open.repro_handle;
-}
-
-int32_t mm_channel_close_repro_isp(mm_channel_t *my_obj,
- uint32_t repro_handle)
-{
- int32_t rc = -1;
- mm_camera_repro_cmd_t repro_cmd;
-
- memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
- repro_cmd.cmd = MM_CAMERA_REPRO_CMD_CLOSE;
- repro_cmd.payload.repro_handle = repro_handle;
- rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_SEND_PP_PIPELINE_CMD,
- sizeof(mm_camera_repro_cmd_t),
- (void *)&repro_cmd);
- if (0 != rc) {
- CDBG_ERROR("%s: close repo isp failed (rc=%d)", __func__, rc);
- }
- return rc;
-}
-
-int32_t mm_channel_config_repro_isp(mm_channel_t *my_obj,
- uint32_t repro_handle,
- mm_camera_repro_isp_config_t *config)
-{
- int32_t rc = -1;
- mm_camera_repro_cmd_t repro_cmd;
- mm_stream_t *src_stream = NULL;
- mm_stream_t *dest_streams[MM_CAMERA_MAX_NUM_REPROCESS_DEST];
- uint8_t i;
-
- /* first check if src and dest streams are valid */
- src_stream = mm_channel_util_get_stream_by_handler(my_obj, config->src.inst_handle);
- if (NULL == src_stream) {
- CDBG_ERROR("%s: src stream obj not found %d", __func__, config->src.inst_handle);
- return -1;
- }
- for (i = 0; i < config->num_dest; i++) {
- dest_streams[i] =
- mm_channel_util_get_stream_by_handler(my_obj, config->dest[i].inst_handle);
- if (NULL == dest_streams[i]) {
- CDBG_ERROR("%s: dest stream obj not found %d", __func__, config->dest[i].inst_handle);
- return -1;
- }
- }
-
- /* fill in config */
- memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
- repro_cmd.cmd = MM_CAMERA_REPRO_CMD_CONFIG;
- repro_cmd.payload.config.repro_handle = repro_handle;
- /* using instant handler which can be understandable by mctl */
- repro_cmd.payload.config.src.inst_handle = src_stream->inst_hdl;
- /* translate to V4L2 ext image mode */
- repro_cmd.payload.config.src.image_mode =
- mm_channel_get_ext_mode_from_img_mode(config->src.image_mode);
- repro_cmd.payload.config.src.format = config->src.format;
- repro_cmd.payload.config.src.width = config->src.width;
- repro_cmd.payload.config.src.height = config->src.height;
- CDBG("%s: src: inst_hdl=0x%x, image_mode=%d, format=%d, width x height=%dx%d",
- __func__,
- repro_cmd.payload.config.src.inst_handle,
- repro_cmd.payload.config.src.image_mode,
- repro_cmd.payload.config.src.format,
- repro_cmd.payload.config.src.width,
- repro_cmd.payload.config.src.height);
- repro_cmd.payload.config.num_dest = config->num_dest;
- for (i = 0; i < repro_cmd.payload.config.num_dest; i++) {
- /* using instant handler which can be understandable by mctl */
- repro_cmd.payload.config.dest[i].inst_handle = dest_streams[i]->inst_hdl;
- /* translate into V4L2 ext image mode */
- repro_cmd.payload.config.dest[i].image_mode =
- mm_channel_get_ext_mode_from_img_mode(config->dest[i].image_mode);
- repro_cmd.payload.config.dest[i].format = config->dest[i].format;
- repro_cmd.payload.config.dest[i].width = config->dest[i].width;
- repro_cmd.payload.config.dest[i].height = config->dest[i].height;
- CDBG("%s: dest %d: inst_hdl=0x%x, image_mode=%d, format=%d, width x height=%dx%d",
- __func__, i,
- repro_cmd.payload.config.dest[i].inst_handle,
- repro_cmd.payload.config.dest[i].image_mode,
- repro_cmd.payload.config.dest[i].format,
- repro_cmd.payload.config.dest[i].width,
- repro_cmd.payload.config.dest[i].height);
- }
- rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_SEND_PP_PIPELINE_CMD,
- sizeof(mm_camera_repro_cmd_t),
- (void *)&repro_cmd);
- if (0 != rc) {
- CDBG_ERROR("%s: config repo isp failed (rc=%d)", __func__, rc);
- }
- return rc;
-}
-
-int32_t mm_channel_repro_isp_dest_stream_ops(mm_channel_t *my_obj,
- uint32_t repro_handle,
- uint32_t stream_handle,
- uint8_t attach_flag)
-{
- int32_t rc = -1;
- mm_stream_t *stream_obj = NULL;
- mm_camera_repro_cmd_t repro_cmd;
-
- /* first check if streams are valid */
- stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_handle);
- if (NULL == stream_obj) {
- CDBG_ERROR("%s: stream obj not found %d", __func__, stream_handle);
- return -1;
- }
-
- memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
- repro_cmd.cmd = MM_CAMERA_REPRO_CMD_ATTACH_DETACH;
- repro_cmd.payload.attach_detach.repro_handle = repro_handle;
- repro_cmd.payload.attach_detach.attach_flag = attach_flag;
- repro_cmd.payload.attach_detach.inst_handle = stream_obj->inst_hdl;
- rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_SEND_PP_PIPELINE_CMD,
- sizeof(mm_camera_repro_cmd_t),
- (void *)&repro_cmd);
- if (0 != rc) {
- CDBG_ERROR("%s: repo isp stream operation failed (flag=%d, rc=%d)",
- __func__, attach_flag, rc);
- }
- return rc;
-}
-
-int32_t mm_channel_repro_isp_ops(mm_channel_t *my_obj,
- uint32_t repro_handle,
- uint32_t stream_id,
- uint8_t start_flag)
-{
- int32_t rc = -1;
- mm_camera_repro_cmd_t repro_cmd;
- mm_stream_t *stream_obj = NULL;
-
- /* first check if streams are valid */
- stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_id);
- if (NULL == stream_obj) {
- CDBG_ERROR("%s: stream obj not found %d", __func__, stream_id);
- return -1;
- }
-
- memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
- repro_cmd.cmd = MM_CAMERA_REPRO_CMD_START_STOP;
- repro_cmd.payload.start_stop.repro_handle = repro_handle;
- repro_cmd.payload.start_stop.dest_handle = stream_obj->inst_hdl;
- repro_cmd.payload.start_stop.start_flag = start_flag;
- rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_SEND_PP_PIPELINE_CMD,
- sizeof(mm_camera_repro_cmd_t),
- (void *)&repro_cmd);
- if (0 != rc) {
- CDBG_ERROR("%s: repo isp stream operation failed (flag=%d, rc=%d)",
- __func__, start_flag, rc);
- }
- return rc;
-}
-
-int32_t mm_channel_reprocess(mm_channel_t *my_obj,
- uint32_t repro_handle,
- mm_camera_repro_data_t *repro_data)
-{
- int32_t rc = -1;
- mm_camera_repro_cmd_t repro_cmd;
- mm_stream_t *stream_obj = NULL;
- uint8_t i;
-
- /* check if input param is valid */
- if (NULL == repro_data || NULL == repro_data->src_frame) {
- CDBG_ERROR("%s: invalid input param", __func__);
- return -1;
- }
-
- /* check if streams are valid */
- stream_obj = mm_channel_util_get_stream_by_handler(my_obj,
- repro_data->src_frame->stream_id);
- if (NULL == stream_obj) {
- CDBG_ERROR("%s: stream obj not found %d",
- __func__, repro_data->src_frame->stream_id);
- return -1;
- }
-
- memset(&repro_cmd, 0, sizeof(mm_camera_repro_cmd_t));
- repro_cmd.cmd = MM_CAMERA_REPRO_CMD_START_STOP;
- repro_cmd.payload.reprocess.repro_handle = repro_handle;
- repro_cmd.payload.reprocess.inst_handle = stream_obj->inst_hdl;
- repro_cmd.payload.reprocess.buf_idx = repro_data->src_frame->buf_idx;
- repro_cmd.payload.reprocess.frame_id = repro_data->src_frame->frame_idx;
- repro_cmd.payload.reprocess.frame_len = repro_data->src_frame->frame_len;
- repro_cmd.payload.reprocess.timestamp.tv_sec =
- repro_data->src_frame->ts.tv_sec;
- repro_cmd.payload.reprocess.timestamp.tv_usec =
- repro_data->src_frame->ts.tv_nsec/1000;
- repro_cmd.payload.reprocess.num_planes = repro_data->src_frame->num_planes;
- for (i = 0; i < repro_cmd.payload.reprocess.num_planes; i++) {
- repro_cmd.payload.reprocess.planes[i].addr_offset =
- repro_data->src_frame->planes[i].reserved[0];
- repro_cmd.payload.reprocess.planes[i].data_offset =
- repro_data->src_frame->planes[i].data_offset;
- repro_cmd.payload.reprocess.planes[i].length =
- repro_data->src_frame->planes[i].length;
- }
- rc = mm_camera_send_native_ctrl_cmd(my_obj->cam_obj,
- CAMERA_SEND_PP_PIPELINE_CMD,
- sizeof(mm_camera_repro_cmd_t),
- (void *)&repro_cmd);
- if (0 != rc) {
- CDBG_ERROR("%s: do reprocess failed (rc=%d)", __func__, rc);
- }
- return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_data.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_data.c
deleted file mode 100755
index b02567e..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_data.c
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <camera.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-#if 0
-#undef CDBG
-#undef LOG_TAG
-#define CDBG ALOGE
-#define LOG_TAG "NotifyLogs"
-#endif
-
-int32_t mm_camera_queue_init(mm_camera_queue_t* queue)
-{
- pthread_mutex_init(&queue->lock, NULL);
- cam_list_init(&queue->head.list);
- queue->size = 0;
- return 0;
-}
-
-int32_t mm_camera_queue_enq(mm_camera_queue_t* queue, void* data)
-{
- mm_camera_q_node_t* node =
- (mm_camera_q_node_t *)malloc(sizeof(mm_camera_q_node_t));
- if (NULL == node) {
- CDBG_ERROR("%s: No memory for mm_camera_q_node_t", __func__);
- return -1;
- }
-
- memset(node, 0, sizeof(mm_camera_q_node_t));
- node->data = data;
-
- pthread_mutex_lock(&queue->lock);
- cam_list_add_tail_node(&node->list, &queue->head.list);
- queue->size++;
- pthread_mutex_unlock(&queue->lock);
-
- return 0;
-
-}
-
-void* mm_camera_queue_deq(mm_camera_queue_t* queue)
-{
- mm_camera_q_node_t* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
- if (pos != head) {
- node = member_of(pos, mm_camera_q_node_t, list);
- cam_list_del_node(&node->list);
- queue->size--;
- }
- pthread_mutex_unlock(&queue->lock);
-
- if (NULL != node) {
- data = node->data;
- free(node);
- }
-
- return data;
-}
-
-int32_t mm_camera_queue_deinit(mm_camera_queue_t* queue)
-{
- mm_camera_queue_flush(queue);
- pthread_mutex_destroy(&queue->lock);
- return 0;
-}
-
-int32_t mm_camera_queue_flush(mm_camera_queue_t* queue)
-{
- mm_camera_q_node_t* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
-
- while(pos != head) {
- node = member_of(pos, mm_camera_q_node_t, list);
- pos = pos->next;
- cam_list_del_node(&node->list);
- queue->size--;
-
- /* TODO later to consider ptr inside data */
- /* for now we only assume there is no ptr inside data
- * so we free data directly */
- if (NULL != node->data) {
- free(node->data);
- }
- free(node);
-
- }
- queue->size = 0;
- pthread_mutex_unlock(&queue->lock);
- return 0;
-}
-
-static void *mm_camera_cmd_thread(void *data)
-{
- int rc = 0;
- int running = 1;
- int ret;
- mm_camera_cmd_thread_t *cmd_thread =
- (mm_camera_cmd_thread_t *)data;
- mm_camera_cmdcb_t* node = NULL;
-
- do {
- do {
- ret = sem_wait(&cmd_thread->cmd_sem);
- if (ret != 0 && errno != EINVAL) {
- CDBG_ERROR("%s: sem_wait error (%s)",
- __func__, strerror(errno));
- return NULL;
- }
- } while (ret != 0);
-
- /* we got notified about new cmd avail in cmd queue */
- node = (mm_camera_cmdcb_t*)mm_camera_queue_deq(&cmd_thread->cmd_queue);
- while (node != NULL) {
- switch (node->cmd_type) {
- case MM_CAMERA_CMD_TYPE_EVT_CB:
- case MM_CAMERA_CMD_TYPE_DATA_CB:
- case MM_CAMERA_CMD_TYPE_ASYNC_CB:
- case MM_CAMERA_CMD_TYPE_REQ_DATA_CB:
- case MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB:
- if (NULL != cmd_thread->cb) {
- cmd_thread->cb(node, cmd_thread->user_data);
- }
- break;
- case MM_CAMERA_CMD_TYPE_EXIT:
- default:
- running = 0;
- break;
- }
- free(node);
- node = (mm_camera_cmdcb_t*)mm_camera_queue_deq(&cmd_thread->cmd_queue);
- } /* (node != NULL) */
- } while (running);
- return NULL;
-}
-
-int32_t mm_camera_cmd_thread_launch(mm_camera_cmd_thread_t * cmd_thread,
- mm_camera_cmd_cb_t cb,
- void* user_data)
-{
- int32_t rc = 0;
-
- sem_init(&cmd_thread->cmd_sem, 0, 0);
- mm_camera_queue_init(&cmd_thread->cmd_queue);
- cmd_thread->cb = cb;
- cmd_thread->user_data = user_data;
-
- /* launch the thread */
- pthread_create(&cmd_thread->cmd_pid,
- NULL,
- mm_camera_cmd_thread,
- (void *)cmd_thread);
- return rc;
-}
-
-int32_t mm_camera_cmd_thread_stop(mm_camera_cmd_thread_t * cmd_thread)
-{
- int32_t rc = 0;
- mm_camera_buf_info_t buf_info;
- mm_camera_cmdcb_t* node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL == node) {
- CDBG_ERROR("%s: No memory for mm_camera_cmdcb_t", __func__);
- return -1;
- }
-
- memset(node, 0, sizeof(mm_camera_cmdcb_t));
- node->cmd_type = MM_CAMERA_CMD_TYPE_EXIT;
-
- mm_camera_queue_enq(&cmd_thread->cmd_queue, node);
- sem_post(&cmd_thread->cmd_sem);
-
- /* wait until cmd thread exits */
- if (pthread_join(cmd_thread->cmd_pid, NULL) != 0) {
- CDBG("%s: pthread dead already\n", __func__);
- }
- return rc;
-}
-
-int32_t mm_camera_cmd_thread_destroy(mm_camera_cmd_thread_t * cmd_thread)
-{
- int32_t rc = 0;
- mm_camera_queue_deinit(&cmd_thread->cmd_queue);
- sem_destroy(&cmd_thread->cmd_sem);
- memset(cmd_thread, 0, sizeof(mm_camera_cmd_thread_t));
- return rc;
-}
-
-int32_t mm_camera_cmd_thread_release(mm_camera_cmd_thread_t * cmd_thread)
-{
- int32_t rc = 0;
- rc = mm_camera_cmd_thread_stop(cmd_thread);
- if (0 == rc) {
- rc = mm_camera_cmd_thread_destroy(cmd_thread);
- }
- return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_helper.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_helper.c
deleted file mode 100755
index 5962149..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_helper.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <fcntl.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <errno.h>
-#include <string.h>
-#include "mm_camera_dbg.h"
-
-/*============================================================
- FUNCTION mm_camera_dump_image
- DESCRIPTION:
-==============================================================*/
-int mm_camera_dump_image(void *addr, uint32_t size, char *filename)
-{
- int file_fd = open(filename, O_RDWR | O_CREAT, 0777);
-
- if (file_fd < 0) {
- CDBG_HIGH("%s: cannot open file\n", __func__);
- return -1;
- } else
- write(file_fd, addr, size);
- close(file_fd);
- CDBG("%s: %s, size=%d\n", __func__, filename, size);
- return 0;
-}
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_interface.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_interface.c
deleted file mode 100755
index ae5462c..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_interface.c
+++ /dev/null
@@ -1,1319 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <linux/media.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera_sock.h"
-#include "mm_camera.h"
-
-static pthread_mutex_t g_intf_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t g_oem_lock = PTHREAD_MUTEX_INITIALIZER;
-
-static mm_camera_ctrl_t g_cam_ctrl = {{{0, {0, 0, 0, 0}, 0, 0}}, 0, {{0}}, {0}};
-
-static pthread_mutex_t g_handler_lock = PTHREAD_MUTEX_INITIALIZER;
-static uint16_t g_handler_history_count = 0; /* history count for handler */
-
-extern int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
- cam_ctrl_type type,
- uint32_t length,
- void *value);
-
-/* utility function to generate handler */
-uint32_t mm_camera_util_generate_handler(uint8_t index)
-{
- uint32_t handler = 0;
- pthread_mutex_lock(&g_handler_lock);
- g_handler_history_count++;
- if (0 == g_handler_history_count) {
- g_handler_history_count++;
- }
- handler = g_handler_history_count;
- handler = (handler<<8) | index;
- pthread_mutex_unlock(&g_handler_lock);
- return handler;
-}
-
-uint8_t mm_camera_util_get_index_by_handler(uint32_t handler)
-{
- return (handler&0x000000ff);
-}
-
-const char *mm_camera_util_get_dev_name(uint32_t cam_handler)
-{
- char *dev_name = NULL;
- uint8_t cam_idx = mm_camera_util_get_index_by_handler(cam_handler);
- dev_name = g_cam_ctrl.camera[cam_idx].video_dev_name;
- return dev_name;
-}
-
-mm_camera_obj_t* mm_camera_util_get_camera_by_handler(uint32_t cam_handler)
-{
- mm_camera_obj_t *cam_obj = NULL;
- uint8_t cam_idx = mm_camera_util_get_index_by_handler(cam_handler);
-
- if ((NULL != g_cam_ctrl.cam_obj[cam_idx]) &&
- (cam_handler == g_cam_ctrl.cam_obj[cam_idx]->my_hdl)) {
- cam_obj = g_cam_ctrl.cam_obj[cam_idx];
- }
- return cam_obj;
-}
-
-static int32_t mm_camera_intf_sync(uint32_t camera_handler)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s E: camera_handler = %d ",__func__,camera_handler);
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_sync(my_obj);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-/* check if the operation is supported */
-static int32_t mm_camera_intf_is_op_supported(uint32_t camera_handler,mm_camera_ops_type_t opcode)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_is_op_supported(my_obj, opcode);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- return rc;
-}
-
-/* check if the parm is supported */
-static int32_t mm_camera_intf_is_parm_supported(uint32_t camera_handler,
- mm_camera_parm_type_t parm_type,
- uint8_t *support_set_parm,
- uint8_t *support_get_parm)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
- *support_set_parm = 0;
- *support_get_parm = 0;
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_is_parm_supported(my_obj, parm_type, support_set_parm, support_get_parm);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- return rc;
-}
-
-/* set a parmÂ’s current value */
-static int32_t mm_camera_intf_set_parm(uint32_t camera_handler,
- mm_camera_parm_type_t parm_type,
- void* p_value)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_set_parm(my_obj, parm_type, p_value);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- return rc;
-}
-
-/* get a parmÂ’s current value */
-static int32_t mm_camera_intf_get_parm(uint32_t camera_handler,
- mm_camera_parm_type_t parm_type,
- void* p_value)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_get_parm(my_obj, parm_type, p_value);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- return rc;
-}
-
-static void mm_camera_intf_close(uint32_t camera_handler)
-{
- int32_t rc = -1;
- uint8_t cam_idx = camera_handler & 0x00ff;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s E: camera_handler = %d ",__func__,camera_handler);
-
- /* first we need to get oem_lock,
- * in case oem private ioctl is still processing,
- * we need to wait until it finishes */
- pthread_mutex_lock(&g_oem_lock);
-
- /* then we get intf_lock */
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if (my_obj){
- my_obj->ref_count--;
-
- if(my_obj->ref_count > 0) {
- /* still have reference to obj, return here */
- CDBG("%s: ref_count=%d\n", __func__, my_obj->ref_count);
- pthread_mutex_unlock(&g_intf_lock);
- } else {
- /* need close camera here as no other reference
- * first empty g_cam_ctrl's referent to cam_obj */
- g_cam_ctrl.cam_obj[cam_idx] = NULL;
-
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
-
- mm_camera_close(my_obj);
-
- pthread_mutex_destroy(&my_obj->cam_lock);
- free(my_obj);
- }
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- /* unlock oem_lock before we leave */
- pthread_mutex_unlock(&g_oem_lock);
-}
-
-static uint32_t mm_camera_intf_add_channel(uint32_t camera_handler)
-{
- uint32_t ch_id = 0;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E camera_handler = %d",__func__,camera_handler);
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- ch_id = mm_camera_add_channel(my_obj);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X ch_id = %d",__func__,ch_id);
- return ch_id;
-}
-
-static void mm_camera_intf_del_channel(uint32_t camera_handler, uint32_t ch_id)
-{
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E ch_id = %d",__func__,ch_id);
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- mm_camera_del_channel(my_obj, ch_id);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X",__func__);
-}
-
-static uint8_t mm_camera_intf_is_event_supported(uint32_t camera_handler,
- mm_camera_event_type_t evt_type)
-{
- switch(evt_type) {
- case MM_CAMERA_EVT_TYPE_CH:
- case MM_CAMERA_EVT_TYPE_CTRL:
- case MM_CAMERA_EVT_TYPE_STATS:
- case MM_CAMERA_EVT_TYPE_INFO:
- return 1;
- default:
- return 0;
- }
- return 0;
-}
-
-static int32_t mm_camera_intf_register_event_notify(
- uint32_t camera_handler,
- mm_camera_event_notify_t evt_cb,
- void * user_data,
- mm_camera_event_type_t evt_type)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E evt_type = %d",__func__,evt_type);
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_register_event_notify(my_obj, evt_cb, user_data, evt_type);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :E rc = %d",__func__,rc);
- return rc;
-}
-
-static mm_camera_2nd_sensor_t * mm_camera_intf_query_2nd_sensor_info(uint32_t camera_handler)
-{
- mm_camera_2nd_sensor_t *sensor_info = NULL;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E camera_handler = %d",__func__,camera_handler);
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- sensor_info = mm_camera_query_2nd_sensor_info(my_obj);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X",__func__);
- return sensor_info;
-}
-
-static int32_t mm_camera_intf_qbuf(uint32_t camera_handler,
- uint32_t ch_id,
- mm_camera_buf_def_t *buf)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_qbuf(my_obj, ch_id, buf);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X evt_type = %d",__func__,rc);
- return rc;
-}
-
-static uint32_t mm_camera_intf_add_stream(
- uint32_t camera_handler,
- uint32_t ch_id,
- mm_camera_buf_notify_t buf_cb, void *user_data,
- uint32_t ext_image_mode, uint32_t sensor_idx)
-{
- uint32_t stream_id = 0;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s : E handle = %d ch_id = %d",__func__,camera_handler,
- ch_id);
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- stream_id = mm_camera_add_stream(my_obj, ch_id, buf_cb,
- user_data, ext_image_mode, sensor_idx);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X stream_id = %d",__func__,stream_id);
- return stream_id;
-}
-
-static int32_t mm_camera_intf_del_stream(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s : E handle = %d ch_id = %d stream_id = %d",__func__,camera_handler,
- ch_id,stream_id);
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_del_stream(my_obj, ch_id, stream_id);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_config_stream(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint32_t stream_id,
- mm_camera_stream_config_t *config)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E handle = %d, ch_id = %d,stream_id = %d",__func__,
- camera_handler,ch_id,stream_id);
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- CDBG("%s :mm_camera_intf_config_stream stream_id = %d",__func__,stream_id);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_config_stream(my_obj, ch_id, stream_id, config);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_bundle_streams(
- uint32_t camera_handler,
- uint32_t ch_id,
- mm_camera_buf_notify_t super_frame_notify_cb,
- void *user_data,
- mm_camera_bundle_attr_t *attr,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E handle = %d, ch_id = %d",__func__,
- camera_handler,ch_id);
-
- if (MM_CAMEAR_MAX_STRAEM_BUNDLE < num_streams) {
- CDBG_ERROR("%s: number of streams (%d) exceeds max (%d)",
- __func__, num_streams, MM_CAMEAR_MAX_STRAEM_BUNDLE);
- return rc;
- }
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_bundle_streams(my_obj, ch_id,
- super_frame_notify_cb,
- user_data, attr,
- num_streams, stream_ids);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_destroy_bundle(uint32_t camera_handler,
- uint32_t ch_id)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E handle = %d, ch_id = %d",__func__,
- camera_handler,ch_id);
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_destroy_bundle(my_obj, ch_id);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_start_streams(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E camera_handler = %d,ch_id = %d, num_streams = %d",
- __func__,camera_handler,ch_id,num_streams);
- if (MM_CAMEAR_STRAEM_NUM_MAX < num_streams) {
- CDBG_ERROR("%s: num of streams (%d) exceeds MAX (%d)",
- __func__, num_streams, MM_CAMEAR_STRAEM_NUM_MAX);
- return rc;
- }
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_start_streams(my_obj, ch_id, num_streams, stream_ids);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_stop_streams(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E camera_handler = %d,ch_id = %d, num_streams = %d",
- __func__,camera_handler,ch_id,num_streams);
-
- if (MM_CAMEAR_STRAEM_NUM_MAX < num_streams) {
- CDBG_ERROR("%s: num of streams (%d) exceeds MAX (%d)",
- __func__, num_streams, MM_CAMEAR_STRAEM_NUM_MAX);
- return rc;
- }
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_stop_streams(my_obj, ch_id,
- num_streams, stream_ids);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_async_teardown_streams(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint8_t num_streams,
- uint32_t *stream_ids)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E camera_handler = %d,ch_id = %d, num_streams = %d",
- __func__,camera_handler,ch_id,num_streams);
-
- if (MM_CAMEAR_STRAEM_NUM_MAX < num_streams) {
- CDBG_ERROR("%s: num of streams (%d) exceeds MAX (%d)",
- __func__, num_streams, MM_CAMEAR_STRAEM_NUM_MAX);
- return rc;
- }
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_async_teardown_streams(my_obj, ch_id,
- num_streams, stream_ids);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_request_super_buf(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint32_t num_buf_requested)
-{
- int32_t rc = -1;
- CDBG("%s :E camera_handler = %d,ch_id = %d",
- __func__,camera_handler,ch_id);
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_request_super_buf(my_obj, ch_id, num_buf_requested);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_cancel_super_buf_request(
- uint32_t camera_handler,
- uint32_t ch_id)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E camera_handler = %d,ch_id = %d",
- __func__,camera_handler,ch_id);
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_cancel_super_buf_request(my_obj, ch_id);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_start_focus(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint32_t sensor_idx,
- uint32_t focus_mode)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- CDBG("%s :E camera_handler = %d,ch_id = %d, focus_mode = %d",
- __func__,camera_handler,ch_id,focus_mode);
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_start_focus(my_obj, ch_id, sensor_idx, focus_mode);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_abort_focus(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint32_t sensor_idx)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_abort_focus(my_obj, ch_id, sensor_idx);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_prepare_snapshot(
- uint32_t camera_handler,
- uint32_t ch_id,
- uint32_t sensor_idx)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handler);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_prepare_snapshot(my_obj, ch_id, sensor_idx);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_set_stream_parm(
- uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t s_id,
- mm_camera_stream_parm_t parm_type,
- void* p_value)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- CDBG("%s :E camera_handle = %d,ch_id = %d,s_id = %d,parm_type = %d",__func__,
- camera_handle,ch_id,s_id,parm_type);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_set_stream_parm(my_obj,ch_id,s_id,
- parm_type,
- p_value);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_get_stream_parm(
- uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t s_id,
- mm_camera_stream_parm_t parm_type,
- void* p_value)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- CDBG("%s :E camera_handle = %d,ch_id = %d,s_id = %d,parm_type = %d",__func__,
- camera_handle,ch_id,s_id,parm_type);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_get_stream_parm(my_obj,ch_id,s_id,
- parm_type,
- p_value);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_send_private_ioctl(uint32_t camera_handle,
- uint32_t cmd_id,
- uint32_t cmd_length,
- void *cmd)
-{
- int32_t rc = -1;
- mm_camera_obj_t *my_obj = NULL;
-
- pthread_mutex_lock(&g_oem_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if (my_obj) {
- rc = mm_camera_send_private_ioctl(my_obj, cmd_id, cmd_length, cmd);
- }
-
- pthread_mutex_unlock(&g_oem_lock);
- CDBG("%s :X rc = %d", __func__, rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_send_native_cmd(uint32_t camera_handle,
- uint32_t cmd_id,
- uint32_t cmd_length,
- void *cmd)
-{
- int32_t rc = -1;
- mm_camera_obj_t *my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if (!cmd) {
- CDBG_ERROR("%s Null cmd ", __func__);
- return -EINVAL;
- }
-
- if (my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- switch(cmd_id) {
- case NATIVE_CMD_ID_SOCKET_MAP: {
- cam_sock_packet_t packet;
- memset(&packet, 0, sizeof(cam_sock_packet_t));
- memcpy(&packet.payload.frame_fd_map, cmd, sizeof(mm_camera_frame_map_type));
- if(packet.payload.frame_fd_map.is_hist) {
- packet.msg_type = CAM_SOCK_MSG_TYPE_HIST_MAPPING;
- } else {
- packet.msg_type = CAM_SOCK_MSG_TYPE_FD_MAPPING;
- }
- rc = mm_camera_util_sendmsg(my_obj, &packet,
- sizeof(cam_sock_packet_t),
- packet.payload.frame_fd_map.fd);
- }
- break;
- case NATIVE_CMD_ID_SOCKET_UNMAP: {
- cam_sock_packet_t packet;
- memset(&packet, 0, sizeof(cam_sock_packet_t));
- memcpy(&packet.payload.frame_fd_unmap, cmd, sizeof(mm_camera_frame_unmap_type));
- if(packet.payload.frame_fd_unmap.is_hist) {
- packet.msg_type = CAM_SOCK_MSG_TYPE_HIST_UNMAPPING;
- } else {
- packet.msg_type = CAM_SOCK_MSG_TYPE_FD_UNMAPPING;
- }
- rc = mm_camera_util_sendmsg(my_obj, &packet,
- sizeof(cam_sock_packet_t), 0);
- }
- break;
- case NATIVE_CMD_ID_IOCTL_CTRL:
- /* may switch to send through native ctrl cmd ioctl */
- rc = mm_camera_util_sendmsg(my_obj, cmd,
- cmd_length, 0);
-#if 0
- rc = mm_camera_send_native_ctrl_cmd(my_obj, cmd_id,
- cmd_length, cmd);
-#endif
- break;
- default:
- CDBG_ERROR("%s Invalid native cmd id %d ", __func__, cmd_id);
- rc = -EINVAL;
- break;
- }
- pthread_mutex_unlock(&my_obj->cam_lock);
- } else {
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d", __func__, rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_send_cmd(uint32_t camera_handle,
- mm_camera_cmd_type_t cmd_type,
- uint32_t cmd_id,
- uint32_t cmd_length,
- void *cmd)
-{
- int32_t rc = -1;
-
- switch (cmd_type) {
- case MM_CAMERA_CMD_TYPE_PRIVATE:
- /* OEM private ioctl */
- rc = mm_camera_intf_send_private_ioctl(camera_handle, cmd_id, cmd_length, cmd);
- break;
- case MM_CAMERA_CMD_TYPE_NATIVE:
- rc = mm_camera_intf_send_native_cmd(camera_handle, cmd_id, cmd_length, cmd);
- break;
- }
-
- return rc;
-}
-
-static uint32_t mm_camera_intf_open_repro_isp(uint32_t camera_handle,
- uint32_t ch_id,
- mm_camera_repro_isp_type_t repro_isp_type)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
- uint32_t repro_isp_handle = 0;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_open_repro_isp(my_obj,
- ch_id,
- repro_isp_type,
- &repro_isp_handle);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return repro_isp_handle;
-}
-
-static int32_t mm_camera_intf_config_repro_isp(uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- mm_camera_repro_isp_config_t *config)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_config_repro_isp(my_obj,
- ch_id,
- repro_isp_handle,
- config);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_attach_stream_to_repro_isp(uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_attach_stream_to_repro_isp(my_obj,
- ch_id,
- repro_isp_handle,
- stream_id);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_start_repro_isp(uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_start_repro_isp(my_obj,
- ch_id,
- repro_isp_handle,
- stream_id);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_reprocess(uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- mm_camera_repro_data_t *repro_data)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_reprocess(my_obj,
- ch_id,
- repro_isp_handle,
- repro_data);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_stop_repro_isp(uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_stop_repro_isp(my_obj,
- ch_id,
- repro_isp_handle,
- stream_id);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_detach_stream_from_repro_isp(uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle,
- uint32_t stream_id)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_detach_stream_from_repro_isp(my_obj,
- ch_id,
- repro_isp_handle,
- stream_id);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static int32_t mm_camera_intf_close_repro_isp(uint32_t camera_handle,
- uint32_t ch_id,
- uint32_t repro_isp_handle)
-{
- int32_t rc = -1;
- mm_camera_obj_t * my_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
-
- if(my_obj) {
- pthread_mutex_lock(&my_obj->cam_lock);
- pthread_mutex_unlock(&g_intf_lock);
- rc = mm_camera_close_repro_isp(my_obj,
- ch_id,
- repro_isp_handle);
- }else{
- pthread_mutex_unlock(&g_intf_lock);
- }
-
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-mm_camera_info_t * camera_query(uint8_t *num_cameras)
-{
- int i = 0, rc = 0;
- int dev_fd = 0;
- struct media_device_info mdev_info;
- int num_media_devices = 0;
- if (!num_cameras) {
- CDBG_ERROR("%s: num_cameras is NULL\n", __func__);
- return NULL;
- }
-
- CDBG("%s : E",__func__);
- /* lock the mutex */
- pthread_mutex_lock(&g_intf_lock);
- *num_cameras = 0;
- while (1) {
- char dev_name[32];
- snprintf(dev_name, sizeof(dev_name), "/dev/media%d", num_media_devices);
- dev_fd = open(dev_name, O_RDWR | O_NONBLOCK);
- if (dev_fd < 0) {
- CDBG("Done discovering media devices\n");
- break;
- }
- num_media_devices++;
- rc = ioctl(dev_fd, MEDIA_IOC_DEVICE_INFO, &mdev_info);
- if (rc < 0) {
- CDBG_ERROR("Error: ioctl media_dev failed: %s\n", strerror(errno));
- close(dev_fd);
- break;
- }
-
- if(strncmp(mdev_info.model, QCAMERA_NAME, sizeof(mdev_info.model) != 0)) {
- close(dev_fd);
- continue;
- }
-
- char * mdev_cfg;
- int cam_type = 0, mount_angle = 0, info_index = 0;
- mdev_cfg = strtok(mdev_info.serial, "-");
- while(mdev_cfg != NULL) {
- if(info_index == 0) {
- if(strcmp(mdev_cfg, QCAMERA_NAME))
- break;
- } else if(info_index == 1) {
- mount_angle = atoi(mdev_cfg);
- } else if(info_index == 2) {
- cam_type = atoi(mdev_cfg);
- }
- mdev_cfg = strtok(NULL, "-");
- info_index++;
- }
-
- if(info_index == 0) {
- close(dev_fd);
- continue;
- }
-
- int num_entities = 1;
- while (1) {
- struct media_entity_desc entity;
- memset(&entity, 0, sizeof(entity));
- entity.id = num_entities++;
- rc = ioctl(dev_fd, MEDIA_IOC_ENUM_ENTITIES, &entity);
- if (rc < 0) {
- CDBG("Done enumerating media entities\n");
- rc = 0;
- break;
- }
- if(entity.type == MEDIA_ENT_T_DEVNODE_V4L && entity.group_id == QCAMERA_VNODE_GROUP_ID) {
- strncpy(g_cam_ctrl.video_dev_name[*num_cameras],
- entity.name, sizeof(entity.name));
- g_cam_ctrl.camera[*num_cameras].video_dev_name =
- &g_cam_ctrl.video_dev_name[*num_cameras][0];
- break;
- }
- }
-
- //g_cam_ctrl.camera[*num_cameras].camera_info.camera_id = *num_cameras;
- g_cam_ctrl.camera[*num_cameras].camera_id = *num_cameras;
-
- g_cam_ctrl.camera[*num_cameras].
- camera_info.modes_supported = CAMERA_MODE_2D;
-
- if(cam_type > 1) {
- g_cam_ctrl.camera[*num_cameras].
- camera_info.modes_supported |= CAMERA_MODE_3D;
- }
-
- g_cam_ctrl.camera[*num_cameras].camera_info.position =
- (cam_type == 1) ? FRONT_CAMERA : BACK_CAMERA;
-
- g_cam_ctrl.camera[*num_cameras].camera_info.sensor_mount_angle =
- mount_angle;
-
- g_cam_ctrl.camera[*num_cameras].main_sensor_type = 0;
-
- CDBG("%s: dev_info[id=%d,name='%s',pos=%d,modes=0x%x,sensor=%d mount_angle = %d]\n",
- __func__, *num_cameras,
- g_cam_ctrl.camera[*num_cameras].video_dev_name,
- g_cam_ctrl.camera[*num_cameras].camera_info.position,
- g_cam_ctrl.camera[*num_cameras].camera_info.modes_supported,
- g_cam_ctrl.camera[*num_cameras].main_sensor_type,
- g_cam_ctrl.camera[*num_cameras].camera_info.sensor_mount_angle);
-
- *num_cameras += 1;
- if (dev_fd > 0) {
- close(dev_fd);
- }
- }
- *num_cameras = *num_cameras;
- g_cam_ctrl.num_cam = *num_cameras;
-
- /* unlock the mutex */
- pthread_mutex_unlock(&g_intf_lock);
- CDBG("%s: num_cameras=%d\n", __func__, g_cam_ctrl.num_cam);
- if(rc == 0)
- return &g_cam_ctrl.camera[0];
- else
- return NULL;
-}
-
-/* camera ops v-table */
-static mm_camera_ops_t mm_camera_ops = {
- .sync = mm_camera_intf_sync,
- .is_event_supported = mm_camera_intf_is_event_supported,
- .register_event_notify = mm_camera_intf_register_event_notify,
- .qbuf = mm_camera_intf_qbuf,
- .camera_close = mm_camera_intf_close,
- .query_2nd_sensor_info = mm_camera_intf_query_2nd_sensor_info,
- .is_op_supported = mm_camera_intf_is_op_supported,
- .is_parm_supported = mm_camera_intf_is_parm_supported,
- .set_parm = mm_camera_intf_set_parm,
- .get_parm = mm_camera_intf_get_parm,
- .ch_acquire = mm_camera_intf_add_channel,
- .ch_release = mm_camera_intf_del_channel,
- .add_stream = mm_camera_intf_add_stream,
- .del_stream = mm_camera_intf_del_stream,
- .config_stream = mm_camera_intf_config_stream,
- .init_stream_bundle = mm_camera_intf_bundle_streams,
- .destroy_stream_bundle = mm_camera_intf_destroy_bundle,
- .start_streams = mm_camera_intf_start_streams,
- .stop_streams = mm_camera_intf_stop_streams,
- .async_teardown_streams = mm_camera_intf_async_teardown_streams,
- .request_super_buf = mm_camera_intf_request_super_buf,
- .cancel_super_buf_request = mm_camera_intf_cancel_super_buf_request,
- .start_focus = mm_camera_intf_start_focus,
- .abort_focus = mm_camera_intf_abort_focus,
- .prepare_snapshot = mm_camera_intf_prepare_snapshot,
- .set_stream_parm = mm_camera_intf_set_stream_parm,
- .get_stream_parm = mm_camera_intf_get_stream_parm,
- .send_command = mm_camera_intf_send_cmd,
- .open_repro_isp = mm_camera_intf_open_repro_isp,
- .config_repro_isp = mm_camera_intf_config_repro_isp,
- .attach_stream_to_repro_isp = mm_camera_intf_attach_stream_to_repro_isp,
- .start_repro_isp = mm_camera_intf_start_repro_isp,
- .reprocess = mm_camera_intf_reprocess,
- .stop_repro_isp = mm_camera_intf_stop_repro_isp,
- .detach_stream_from_repro_isp = mm_camera_intf_detach_stream_from_repro_isp,
- .close_repro_isp = mm_camera_intf_close_repro_isp
-};
-
-/* open camera. */
-mm_camera_vtbl_t * camera_open(uint8_t camera_idx,
- mm_camear_mem_vtbl_t *mem_vtbl)
-{
- int32_t rc = 0;
- mm_camera_obj_t* cam_obj = NULL;
-
- CDBG("%s: E camera_idx = %d\n", __func__,camera_idx);
- if (MSM_MAX_CAMERA_SENSORS <= camera_idx) {
- CDBG_ERROR("%s: Invalid camera_idx (%d)", __func__, camera_idx);
- return NULL;
- }
-
- pthread_mutex_lock(&g_oem_lock);
- pthread_mutex_lock(&g_intf_lock);
- /* opened already */
- if(NULL != g_cam_ctrl.cam_obj[camera_idx]) {
- /* Add reference */
- g_cam_ctrl.cam_obj[camera_idx]->ref_count++;
- pthread_mutex_unlock(&g_intf_lock);
- pthread_mutex_unlock(&g_oem_lock);
- CDBG("%s: opened alreadyn", __func__);
- return &cam_obj->vtbl;
- }
-
- cam_obj = (mm_camera_obj_t *)malloc(sizeof(mm_camera_obj_t));
- if(NULL == cam_obj) {
- pthread_mutex_unlock(&g_intf_lock);
- pthread_mutex_unlock(&g_oem_lock);
- CDBG("%s: no mem", __func__);
- return NULL;
- }
-
- /* initialize camera obj */
- memset(cam_obj, 0, sizeof(mm_camera_obj_t));
- cam_obj->ctrl_fd = -1;
- cam_obj->ds_fd = -1;
- cam_obj->ref_count++;
- cam_obj->my_hdl = mm_camera_util_generate_handler(camera_idx);
- cam_obj->vtbl.camera_handle = cam_obj->my_hdl; /* set handler */
- cam_obj->vtbl.camera_info = &g_cam_ctrl.camera[camera_idx];
- cam_obj->vtbl.ops = &mm_camera_ops;
- cam_obj->mem_vtbl = mem_vtbl; /* save mem_vtbl */
- pthread_mutex_init(&cam_obj->cam_lock, NULL);
-
- rc = mm_camera_open(cam_obj);
- if(rc != 0) {
- CDBG_ERROR("%s: mm_camera_open err = %d", __func__, rc);
- pthread_mutex_destroy(&cam_obj->cam_lock);
- g_cam_ctrl.cam_obj[camera_idx] = NULL;
- free(cam_obj);
- cam_obj = NULL;
- pthread_mutex_unlock(&g_intf_lock);
- pthread_mutex_unlock(&g_oem_lock);
- return NULL;
- }else{
- CDBG("%s: Open succeded\n", __func__);
- g_cam_ctrl.cam_obj[camera_idx] = cam_obj;
- pthread_mutex_unlock(&g_intf_lock);
- pthread_mutex_unlock(&g_oem_lock);
- return &cam_obj->vtbl;
- }
-}
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_sock.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_sock.c
deleted file mode 100755
index 9d14950..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_sock.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <sys/uio.h>
-#include <linux/un.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_sock.h"
-
-/*===========================================================================
- * FUNCTION - mm_camera_socket_create -
- *
- * DESCRIPTION: opens a domain socket tied to camera ID and socket type
- * int cam_id: camera ID
- * mm_camera_sock_type_t sock_type: socket type, TCP/UDP
- * retured fd related to the domain socket
- *==========================================================================*/
-int mm_camera_socket_create(int cam_id, mm_camera_sock_type_t sock_type)
-{
- int socket_fd;
- struct sockaddr_un sock_addr;
- int sktype;
- int rc;
-
- switch (sock_type)
- {
- case MM_CAMERA_SOCK_TYPE_UDP:
- sktype = SOCK_DGRAM;
- break;
- case MM_CAMERA_SOCK_TYPE_TCP:
- sktype = SOCK_STREAM;
- break;
- default:
- CDBG_ERROR("%s: unknown socket type =%d", __func__, sock_type);
- return -1;
- }
- socket_fd = socket(AF_UNIX, sktype, 0);
- if (socket_fd < 0) {
- CDBG_ERROR("%s: error create socket fd =%d", __func__, socket_fd);
- return socket_fd;
- }
-
- memset(&sock_addr, 0, sizeof(sock_addr));
- sock_addr.sun_family = AF_UNIX;
- snprintf(sock_addr.sun_path, UNIX_PATH_MAX, "/data/cam_socket%d", cam_id);
- if((rc = connect(socket_fd, (struct sockaddr *) &sock_addr,
- sizeof(sock_addr))) != 0) {
- close(socket_fd);
- socket_fd = -1;
- CDBG_ERROR("%s: socket_fd=%d %s ", __func__, socket_fd, strerror(errno));
- }
-
- CDBG("%s: socket_fd=%d %s", __func__, socket_fd, sock_addr.sun_path);
- return socket_fd;
-}
-
-/*===========================================================================
- * FUNCTION - mm_camera_socket_close -
- *
- * DESCRIPTION: close domain socket by its fd
- *==========================================================================*/
-void mm_camera_socket_close(int fd)
-{
- if (fd > 0) {
- close(fd);
- }
-}
-
-/*===========================================================================
- * FUNCTION - mm_camera_socket_sendmsg -
- *
- * DESCRIPTION: send msg through domain socket
- * int fd: socket fd
- * mm_camera_sock_msg_packet_t *msg: pointer to msg to be sent over domain socket
- * int sendfd: file descriptors to be sent
- * return the total bytes of sent msg
- *==========================================================================*/
-int mm_camera_socket_sendmsg(
- int fd,
- void *msg,
- uint32_t buf_size,
- int sendfd)
-{
- struct msghdr msgh;
- struct iovec iov[1];
- struct cmsghdr * cmsghp = NULL;
- char control[CMSG_SPACE(sizeof(int))];
-
- if (msg == NULL) {
- CDBG("%s: msg is NULL", __func__);
- return -1;
- }
- memset(&msgh, 0, sizeof(msgh));
- msgh.msg_name = NULL;
- msgh.msg_namelen = 0;
-
- iov[0].iov_base = msg;
- iov[0].iov_len = buf_size;
- msgh.msg_iov = iov;
- msgh.msg_iovlen = 1;
- CDBG("%s: iov_len=%d", __func__, iov[0].iov_len);
-
- msgh.msg_control = NULL;
- msgh.msg_controllen = 0;
-
- /* if sendfd is valid, we need to pass it through control msg */
- if( sendfd > 0) {
- msgh.msg_control = control;
- msgh.msg_controllen = sizeof(control);
- cmsghp = CMSG_FIRSTHDR(&msgh);
- if (cmsghp != NULL) {
- CDBG("%s: Got ctrl msg pointer", __func__);
- cmsghp->cmsg_level = SOL_SOCKET;
- cmsghp->cmsg_type = SCM_RIGHTS;
- cmsghp->cmsg_len = CMSG_LEN(sizeof(int));
- *((int *)CMSG_DATA(cmsghp)) = sendfd;
- CDBG("%s: cmsg data=%d", __func__, *((int *) CMSG_DATA(cmsghp)));
- } else {
- CDBG("%s: ctrl msg NULL", __func__);
- return -1;
- }
- }
-
- return sendmsg(fd, &(msgh), 0);
-}
-
-/*===========================================================================
- * FUNCTION - mm_camera_socket_recvmsg -
- *
- * DESCRIPTION: receive msg from domain socket.
- * int fd: socket fd
- * void *msg: pointer to mm_camera_sock_msg_packet_t to hold incoming msg,
- * need be allocated by the caller
- * uint32_t buf_size: the size of the buf that holds incoming msg
- * int *rcvdfd: pointer to hold recvd file descriptor if not NULL.
- * return the total bytes of received msg
- *==========================================================================*/
-int mm_camera_socket_recvmsg(
- int fd,
- void *msg,
- uint32_t buf_size,
- int *rcvdfd)
-{
- struct msghdr msgh;
- struct iovec iov[1];
- struct cmsghdr *cmsghp = NULL;
- char control[CMSG_SPACE(sizeof(int))];
- int rcvd_fd = -1;
- int rcvd_len = 0;
-
- if ( (msg == NULL) || (buf_size <= 0) ) {
- CDBG_ERROR(" %s: msg buf is NULL", __func__);
- return -1;
- }
-
- memset(&msgh, 0, sizeof(msgh));
- msgh.msg_name = NULL;
- msgh.msg_namelen = 0;
- msgh.msg_control = control;
- msgh.msg_controllen = sizeof(control);
-
- iov[0].iov_base = msg;
- iov[0].iov_len = buf_size;
- msgh.msg_iov = iov;
- msgh.msg_iovlen = 1;
-
- if ( (rcvd_len = recvmsg(fd, &(msgh), 0)) <= 0) {
- CDBG_ERROR(" %s: recvmsg failed", __func__);
- return rcvd_len;
- }
-
- CDBG("%s: msg_ctrl %p len %d", __func__, msgh.msg_control, msgh.msg_controllen);
-
- if( ((cmsghp = CMSG_FIRSTHDR(&msgh)) != NULL) &&
- (cmsghp->cmsg_len == CMSG_LEN(sizeof(int))) ) {
- if (cmsghp->cmsg_level == SOL_SOCKET &&
- cmsghp->cmsg_type == SCM_RIGHTS) {
- CDBG("%s: CtrlMsg is valid", __func__);
- rcvd_fd = *((int *) CMSG_DATA(cmsghp));
- CDBG("%s: Receieved fd=%d", __func__, rcvd_fd);
- } else {
- CDBG_ERROR("%s: Unexpected Control Msg. Line=%d", __func__, __LINE__);
- }
- }
-
- if (rcvdfd) {
- *rcvdfd = rcvd_fd;
- }
-
- return rcvd_len;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_stream.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_stream.c
deleted file mode 100755
index 9e48f2b..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_stream.c
+++ /dev/null
@@ -1,1672 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <time.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-#define MM_CAMERA_MAX_NUM_FRAMES 16
-
-/* internal function decalre */
-int32_t mm_stream_qbuf(mm_stream_t *my_obj,
- mm_camera_buf_def_t *buf);
-int32_t mm_stream_set_ext_mode(mm_stream_t * my_obj);
-int32_t mm_stream_set_fmt(mm_stream_t * my_obj);
-int32_t mm_stream_get_offset(mm_stream_t *my_obj);
-int32_t mm_stream_set_cid(mm_stream_t *my_obj,stream_cid_t *in_value);
-int32_t mm_stream_init_bufs(mm_stream_t * my_obj);
-int32_t mm_stream_deinit_bufs(mm_stream_t * my_obj);
-int32_t mm_stream_request_buf(mm_stream_t * my_obj);
-int32_t mm_stream_unreg_buf(mm_stream_t * my_obj);
-int32_t mm_stream_release(mm_stream_t *my_obj);
-int32_t mm_stream_get_crop(mm_stream_t *my_obj,
- mm_camera_rect_t *crop);
-int32_t mm_stream_get_cid(mm_stream_t *my_obj,
- stream_cid_t *out_value);
-int32_t mm_stream_set_parm_acquire(mm_stream_t *my_obj,
- void *value);
-int32_t mm_stream_get_parm_acquire(mm_stream_t *my_obj,
- void *value);
-int32_t mm_stream_set_parm_config(mm_stream_t *my_obj,
- void *value);
-int32_t mm_stream_get_parm_config(mm_stream_t *my_obj,
- void *value);
-int32_t mm_stream_set_parm_start(mm_stream_t *my_obj,
- void *value);
-int32_t mm_stream_get_parm_start(mm_stream_t *my_obj,
- void *value);
-int32_t mm_stream_streamon(mm_stream_t *my_obj);
-int32_t mm_stream_streamoff(mm_stream_t *my_obj);
-int32_t mm_stream_read_msm_frame(mm_stream_t * my_obj,
- mm_camera_buf_info_t* buf_info);
-int32_t mm_stream_config(mm_stream_t *my_obj,
- mm_camera_stream_config_t *config);
-int32_t mm_stream_reg_buf(mm_stream_t * my_obj);
-int32_t mm_stream_buf_done(mm_stream_t * my_obj,
- mm_camera_buf_def_t *frame);
-
-
-/* state machine function declare */
-int32_t mm_stream_fsm_inited(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_stream_fsm_acquired(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_stream_fsm_cfg(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_stream_fsm_buffed(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_stream_fsm_reg(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_stream_fsm_active_stream_on(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val);
-int32_t mm_stream_fsm_active_stream_off(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val);
-
-extern int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
- cam_ctrl_type type,
- uint32_t length,
- void *value);
-
-static int get_stream_inst_handle(mm_stream_t *my_obj)
-{
- int rc = 0;
- uint32_t inst_handle;
- struct msm_camera_v4l2_ioctl_t v4l2_ioctl;
-
- v4l2_ioctl.id = MSM_V4L2_PID_INST_HANDLE;
- v4l2_ioctl.ioctl_ptr = &inst_handle;
- v4l2_ioctl.len = sizeof(inst_handle);
- rc = ioctl(my_obj->fd, MSM_CAM_V4L2_IOCTL_PRIVATE_G_CTRL, &v4l2_ioctl);
- if (rc) {
- CDBG_ERROR("%s Error getting mctl pp inst handle", __func__);
- return rc;
- }
-
- my_obj->inst_hdl = inst_handle;
- CDBG("%s: X, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, rc = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, rc);
- return rc;
-}
-
-void mm_stream_handle_rcvd_buf(mm_stream_t *my_obj,
- mm_camera_buf_info_t *buf_info)
-{
- int32_t i;
- uint8_t has_cb = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- /* enqueue to super buf thread */
- if (my_obj->is_bundled) {
- mm_camera_cmdcb_t* node = NULL;
-
- /* send sem_post to wake up channel cmd thread to enqueue to super buffer */
- node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL != node) {
- memset(node, 0, sizeof(mm_camera_cmdcb_t));
- node->cmd_type = MM_CAMERA_CMD_TYPE_DATA_CB;
- memcpy(&node->u.buf, buf_info, sizeof(mm_camera_buf_info_t));
-
- /* enqueue to cmd thread */
- mm_camera_queue_enq(&(my_obj->ch_obj->cmd_thread.cmd_queue), node);
-
- /* wake up cmd thread */
- sem_post(&(my_obj->ch_obj->cmd_thread.cmd_sem));
- } else {
- CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
- }
- }
-
- /* check if has CB */
- for (i=0 ; i< MM_CAMERA_STREAM_BUF_CB_MAX; i++) {
- if(NULL != my_obj->buf_cb[i].cb) {
- has_cb = 1;
- }
- }
- if(has_cb) {
- mm_camera_cmdcb_t* node = NULL;
-
- /* send sem_post to wake up cmd thread to dispatch dataCB */
- node = (mm_camera_cmdcb_t *)malloc(sizeof(mm_camera_cmdcb_t));
- if (NULL != node) {
- memset(node, 0, sizeof(mm_camera_cmdcb_t));
- node->cmd_type = MM_CAMERA_CMD_TYPE_DATA_CB;
- memcpy(&node->u.buf, buf_info, sizeof(mm_camera_buf_info_t));
-
- /* enqueue to cmd thread */
- mm_camera_queue_enq(&(my_obj->cmd_thread.cmd_queue), node);
-
- /* wake up cmd thread */
- sem_post(&(my_obj->cmd_thread.cmd_sem));
- } else {
- CDBG_ERROR("%s: No memory for mm_camera_node_t", __func__);
- }
- }
-}
-
-static void mm_stream_data_notify(void* user_data)
-{
- mm_stream_t *my_obj = (mm_stream_t*)user_data;
- int32_t idx = -1, i, rc;
- uint8_t has_cb = 0;
- mm_camera_buf_info_t buf_info;
-
- if (NULL == my_obj) {
- return;
- }
-
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
- if (MM_STREAM_STATE_ACTIVE_STREAM_ON != my_obj->state) {
- /* this Cb will only received in active_stream_on state
- * if not so, return here */
- CDBG_ERROR("%s: ERROR!! Wrong state (%d) to receive data notify!",
- __func__, my_obj->state);
- return;
- }
-
- memset(&buf_info, 0, sizeof(mm_camera_buf_info_t));
-
- pthread_mutex_lock(&my_obj->buf_lock);
- rc = mm_stream_read_msm_frame(my_obj, &buf_info);
- if (rc != 0) {
- pthread_mutex_unlock(&my_obj->buf_lock);
- return;
- }
- idx = buf_info.buf->buf_idx;
- /* update buffer location */
- my_obj->buf_status[idx].in_kernel = 0;
-
- /* update buf ref count */
- if (my_obj->is_bundled) {
- /* need to add into super buf since bundled, add ref count */
- my_obj->buf_status[idx].buf_refcnt++;
- }
-
- for (i=0; i < MM_CAMERA_STREAM_BUF_CB_MAX; i++) {
- if(NULL != my_obj->buf_cb[i].cb) {
- /* for every CB, add ref count */
- my_obj->buf_status[idx].buf_refcnt++;
- has_cb = 1;
- }
- }
- pthread_mutex_unlock(&my_obj->buf_lock);
-
- mm_stream_handle_rcvd_buf(my_obj, &buf_info);
-}
-
-/* special function for dataCB registered at other stream */
-static void mm_stream_buf_notify(mm_camera_super_buf_t *super_buf,
- void *user_data)
-{
- mm_stream_t * my_obj = (mm_stream_t*)user_data;
- mm_camera_buf_info_t buf_info;
- int8_t i;
- mm_camera_buf_def_t *buf = super_buf->bufs[0];
-
- CDBG("%s : E",__func__);
- if (my_obj == NULL) {
- return;
- }
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- if (MM_STREAM_STATE_ACTIVE_STREAM_OFF != my_obj->state) {
- /* this CB will only received in active_stream_off state
- * if not so, return here */
- return;
- }
-
- /* 1) copy buf into local buf */
- if (my_obj->buf_num <= 0) {
- CDBG_ERROR("%s: Local buf is not allocated yet", __func__);
- return;
- }
-
- my_obj->buf[my_obj->local_buf_idx].buf_idx = 0;
- my_obj->buf[my_obj->local_buf_idx].stream_id = my_obj->my_hdl;
- my_obj->buf[my_obj->local_buf_idx].frame_idx = buf->frame_idx;
-
- memcpy(&my_obj->buf[my_obj->local_buf_idx].ts, &buf->ts, sizeof(buf->ts));
-
- memcpy(my_obj->buf[my_obj->local_buf_idx].buffer, buf->buffer, buf->frame_len);
-
- /* set flag to indicate buf be to sent out is from local */
- my_obj->is_local_buf = 1;
-
- /* 2) buf_done the buf from other stream */
- mm_channel_qbuf(my_obj->ch_obj, buf);
-
- /* 3) handle received buf */
- memset(&buf_info, 0, sizeof(mm_camera_buf_info_t));
- buf_info.frame_idx =my_obj->buf[my_obj->local_buf_idx].frame_idx;
- buf_info.buf = &my_obj->buf[my_obj->local_buf_idx];
- buf_info.stream_id = my_obj->my_hdl;
-
- my_obj->local_buf_idx++;
- if (my_obj->local_buf_idx >= my_obj->buf_num) {
- my_obj->local_buf_idx = 0;
- }
- mm_stream_handle_rcvd_buf(my_obj, &buf_info);
-}
-
-static void mm_stream_dispatch_app_data(mm_camera_cmdcb_t *cmd_cb,
- void* user_data)
-{
- int i;
- mm_stream_t * my_obj = (mm_stream_t *)user_data;
- mm_camera_buf_info_t* buf_info = NULL;
- mm_camera_super_buf_t super_buf;
-
- if (NULL == my_obj) {
- return;
- }
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- if (MM_CAMERA_CMD_TYPE_DATA_CB != cmd_cb->cmd_type) {
- CDBG_ERROR("%s: Wrong cmd_type (%d) for dataCB",
- __func__, cmd_cb->cmd_type);
- return;
- }
-
- buf_info = &cmd_cb->u.buf;
- memset(&super_buf, 0, sizeof(mm_camera_super_buf_t));
- super_buf.num_bufs = 1;
- super_buf.bufs[0] = buf_info->buf;
- super_buf.camera_handle = my_obj->ch_obj->cam_obj->my_hdl;
- super_buf.ch_id = my_obj->ch_obj->my_hdl;
-
-
- pthread_mutex_lock(&my_obj->cb_lock);
- for(i = 0; i < MM_CAMERA_STREAM_BUF_CB_MAX; i++) {
- if(NULL != my_obj->buf_cb[i].cb) {
- if (my_obj->buf_cb[i].cb_count != 0) {
- /* if <0, means infinite CB
- * if >0, means CB for certain times
- * both case we need to call CB */
- my_obj->buf_cb[i].cb(&super_buf,
- my_obj->buf_cb[i].user_data);
- }
-
- /* if >0, reduce count by 1 every time we called CB until reaches 0
- * when count reach 0, reset the buf_cb to have no CB */
- if (my_obj->buf_cb[i].cb_count > 0) {
- my_obj->buf_cb[i].cb_count--;
- if (0 == my_obj->buf_cb[i].cb_count) {
- my_obj->buf_cb[i].cb = NULL;
- my_obj->buf_cb[i].user_data = NULL;
- }
- }
- }
- }
- pthread_mutex_unlock(&my_obj->cb_lock);
-}
-
-/* state machine entry */
-int32_t mm_stream_fsm_fn(mm_stream_t *my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = -1;
-
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, event = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
- switch (my_obj->state) {
- case MM_STREAM_STATE_NOTUSED:
- CDBG("%s: Not handling evt in unused state", __func__);
- break;
- case MM_STREAM_STATE_INITED:
- rc = mm_stream_fsm_inited(my_obj, evt, in_val, out_val);
- break;
- case MM_STREAM_STATE_ACQUIRED:
- rc = mm_stream_fsm_acquired(my_obj, evt, in_val, out_val);
- break;
- case MM_STREAM_STATE_CFG:
- rc = mm_stream_fsm_cfg(my_obj, evt, in_val, out_val);
- break;
- case MM_STREAM_STATE_BUFFED:
- rc = mm_stream_fsm_buffed(my_obj, evt, in_val, out_val);
- break;
- case MM_STREAM_STATE_REG:
- rc = mm_stream_fsm_reg(my_obj, evt, in_val, out_val);
- break;
- case MM_STREAM_STATE_ACTIVE_STREAM_ON:
- rc = mm_stream_fsm_active_stream_on(my_obj, evt, in_val, out_val);
- break;
- case MM_STREAM_STATE_ACTIVE_STREAM_OFF:
- rc = mm_stream_fsm_active_stream_off(my_obj, evt, in_val, out_val);
- break;
- default:
- CDBG("%s: Not a valid state (%d)", __func__, my_obj->state);
- break;
- }
- CDBG("%s : X rc =%d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_fsm_inited(mm_stream_t *my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
- char dev_name[MM_CAMERA_DEV_NAME_LEN];
-
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, event = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
- switch(evt) {
- case MM_STREAM_EVT_ACQUIRE:
- if ((NULL == my_obj->ch_obj) || (NULL == my_obj->ch_obj->cam_obj)) {
- CDBG_ERROR("%s: NULL channel or camera obj\n", __func__);
- rc = -1;
- break;
- }
-
- snprintf(dev_name, sizeof(dev_name), "/dev/%s",
- mm_camera_util_get_dev_name(my_obj->ch_obj->cam_obj->my_hdl));
-
- my_obj->fd = open(dev_name, O_RDWR | O_NONBLOCK);
- if (my_obj->fd <= 0) {
- CDBG_ERROR("%s: open dev returned %d\n", __func__, my_obj->fd);
- rc = -1;
- break;
- }
- CDBG("%s: open dev fd = %d, ext_image_mode = %d, sensor_idx = %d\n",
- __func__, my_obj->fd, my_obj->ext_image_mode, my_obj->sensor_idx);
- rc = mm_stream_set_ext_mode(my_obj);
- if (0 == rc) {
- my_obj->state = MM_STREAM_STATE_ACQUIRED;
- } else {
- /* failed setting ext_mode
- * close fd */
- if(my_obj->fd > 0) {
- close(my_obj->fd);
- my_obj->fd = -1;
- }
- break;
- }
- rc = get_stream_inst_handle(my_obj);
- if(rc) {
- if(my_obj->fd > 0) {
- close(my_obj->fd);
- my_obj->fd = -1;
- }
- }
- break;
- default:
- CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
- __func__,evt,my_obj->state);
- break;
- }
- return rc;
-}
-
-int32_t mm_stream_fsm_acquired(mm_stream_t *my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
-
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, event = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
- switch(evt) {
- case MM_STREAM_EVT_SET_FMT:
- {
- mm_camera_stream_config_t *config =
- (mm_camera_stream_config_t *)in_val;
-
- rc = mm_stream_config(my_obj, config);
-
- /* change state to configed */
- my_obj->state = MM_STREAM_STATE_CFG;
-
- break;
- }
- case MM_STREAM_EVT_RELEASE:
- rc = mm_stream_release(my_obj);
- /* change state to not used */
- my_obj->state = MM_STREAM_STATE_NOTUSED;
- break;
- case MM_STREAM_EVT_SET_PARM:
- rc = mm_stream_set_parm_acquire(my_obj, in_val);
- break;
- case MM_STREAM_EVT_GET_PARM:
- rc = mm_stream_get_parm_acquire(my_obj,out_val);
- break;
- default:
- CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
- __func__, evt, my_obj->state);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_fsm_cfg(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, event = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
- switch(evt) {
- case MM_STREAM_EVT_SET_FMT:
- {
- mm_camera_stream_config_t *config =
- (mm_camera_stream_config_t *)in_val;
-
- rc = mm_stream_config(my_obj, config);
-
- /* change state to configed */
- my_obj->state = MM_STREAM_STATE_CFG;
-
- break;
- }
- case MM_STREAM_EVT_RELEASE:
- rc = mm_stream_release(my_obj);
- my_obj->state = MM_STREAM_STATE_NOTUSED;
- break;
- case MM_STREAM_EVT_SET_PARM:
- rc = mm_stream_set_parm_config(my_obj, in_val);
- break;
- case MM_STREAM_EVT_GET_PARM:
- rc = mm_stream_get_parm_config(my_obj, out_val);
- break;
- case MM_STREAM_EVT_GET_BUF:
- rc = mm_stream_init_bufs(my_obj);
- /* change state to buff allocated */
- if(0 == rc) {
- my_obj->state = MM_STREAM_STATE_BUFFED;
- }
- break;
- default:
- CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
- __func__, evt, my_obj->state);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_fsm_buffed(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, event = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
- switch(evt) {
- case MM_STREAM_EVT_PUT_BUF:
- rc = mm_stream_deinit_bufs(my_obj);
- /* change state to configed */
- if(0 == rc) {
- my_obj->state = MM_STREAM_STATE_CFG;
- }
- break;
- case MM_STREAM_EVT_REG_BUF:
- rc = mm_stream_reg_buf(my_obj);
- /* change state to regged */
- if(0 == rc) {
- my_obj->state = MM_STREAM_STATE_REG;
- }
- break;
- case MM_STREAM_EVT_SET_PARM:
- rc = mm_stream_set_parm_config(my_obj, in_val);
- break;
- case MM_STREAM_EVT_GET_PARM:
- rc = mm_stream_get_parm_config(my_obj, out_val);
- break;
- default:
- CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
- __func__, evt, my_obj->state);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_fsm_reg(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, event = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
-
- switch(evt) {
- case MM_STREAM_EVT_UNREG_BUF:
- rc = mm_stream_unreg_buf(my_obj);
-
- /* change state to buffed */
- my_obj->state = MM_STREAM_STATE_BUFFED;
- break;
- case MM_STREAM_EVT_START:
- {
- /* launch cmd thread if CB is not null */
- if (NULL != my_obj->buf_cb) {
- mm_camera_cmd_thread_launch(&my_obj->cmd_thread,
- mm_stream_dispatch_app_data,
- (void *)my_obj);
-
- }
-
- if(my_obj->need_stream_on) {
- rc = mm_stream_streamon(my_obj);
- if (0 != rc) {
- /* failed stream on, need to release cmd thread if it's launched */
- if (NULL != my_obj->buf_cb) {
- mm_camera_cmd_thread_release(&my_obj->cmd_thread);
-
- }
- break;
- }
- my_obj->state = MM_STREAM_STATE_ACTIVE_STREAM_ON;
- } else {
- /* register CB at video fd */
- CDBG("%s : Video Size snapshot Enabled",__func__);
- mm_stream_data_cb_t cb;
- memset(&cb, 0, sizeof(mm_stream_data_cb_t));
- cb.cb_count = my_obj->num_stream_cb_times; /* reigstration cb times */
- if (cb.cb_count == 0) {
- cb.cb_count = 1;
- }
- cb.user_data = (void*)my_obj;
- cb.cb = mm_stream_buf_notify;
- rc = mm_channel_reg_stream_cb(my_obj->ch_obj, &cb,
- MSM_V4L2_EXT_CAPTURE_MODE_VIDEO,
- my_obj->sensor_idx);
- my_obj->state = MM_STREAM_STATE_ACTIVE_STREAM_OFF;
- }
- }
- break;
- case MM_STREAM_EVT_SET_PARM:
- rc = mm_stream_set_parm_config(my_obj, in_val);
- break;
- case MM_STREAM_EVT_GET_PARM:
- rc = mm_stream_get_parm_config(my_obj, out_val);
- break;
- default:
- CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
- __func__, evt, my_obj->state);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_fsm_active_stream_on(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, event = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
- switch(evt) {
- case MM_STREAM_EVT_QBUF:
- rc = mm_stream_buf_done(my_obj, (mm_camera_buf_def_t *)in_val);
- break;
- case MM_STREAM_EVT_STOP:
- {
- rc = mm_stream_streamoff(my_obj);
- if (NULL != my_obj->buf_cb) {
- mm_camera_cmd_thread_release(&my_obj->cmd_thread);
-
- }
- my_obj->state = MM_STREAM_STATE_REG;
- }
- break;
- case MM_STREAM_EVT_SET_PARM:
- rc = mm_stream_set_parm_start(my_obj, in_val);
- break;
- case MM_STREAM_EVT_GET_PARM:
- rc = mm_stream_get_parm_start(my_obj, out_val);
- break;
- default:
- CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
- __func__, evt, my_obj->state);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_fsm_active_stream_off(mm_stream_t * my_obj,
- mm_stream_evt_type_t evt,
- void * in_val,
- void * out_val)
-{
- int32_t rc = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, event = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, evt);
- switch(evt) {
- case MM_STREAM_EVT_QBUF:
- rc = mm_stream_buf_done(my_obj, (mm_camera_buf_def_t *)in_val);
- break;
- case MM_STREAM_EVT_STOP:
- {
- if (NULL != my_obj->buf_cb) {
- rc = mm_camera_cmd_thread_release(&my_obj->cmd_thread);
-
- }
- my_obj->state = MM_STREAM_STATE_REG;
- }
- break;
- case MM_STREAM_EVT_SET_PARM:
- rc = mm_stream_set_parm_config(my_obj, in_val);
- break;
- case MM_STREAM_EVT_GET_PARM:
- rc = mm_stream_get_parm_config(my_obj, out_val);
- break;
- default:
- CDBG_ERROR("%s: Invalid evt=%d, stream_state=%d",
- __func__, evt, my_obj->state);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_config(mm_stream_t *my_obj,
- mm_camera_stream_config_t *config)
-{
- int32_t rc = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
- memcpy(&my_obj->fmt, &config->fmt, sizeof(mm_camera_image_fmt_t));
- my_obj->hal_requested_num_bufs = config->num_of_bufs;
- my_obj->need_stream_on = config->need_stream_on;
- my_obj->num_stream_cb_times = config->num_stream_cb_times;
-
- rc = mm_stream_get_offset(my_obj);
- if(rc != 0) {
- CDBG_ERROR("%s: Error in offset query",__func__);
- return rc;
- }
- /* write back width and height to config in case mctl has modified the value */
- config->fmt.width = my_obj->fmt.width;
- config->fmt.height = my_obj->fmt.height;
- if(my_obj->need_stream_on) {
- /* only send fmt to backend if we need streamon */
- rc = mm_stream_set_fmt(my_obj);
- }
- return rc;
-}
-
-int32_t mm_stream_release(mm_stream_t *my_obj)
-{
- int32_t rc;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- /* close fd */
- if(my_obj->fd > 0)
- {
- close(my_obj->fd);
- }
-
- /* destroy mutex */
- pthread_mutex_destroy(&my_obj->buf_lock);
- pthread_mutex_destroy(&my_obj->cb_lock);
-
- /* reset stream obj */
- memset(my_obj, 0, sizeof(mm_stream_t));
- my_obj->fd = -1;
-
- return 0;
-}
-
-int32_t mm_stream_streamon(mm_stream_t *my_obj)
-{
- int32_t rc;
- enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
- /* Add fd to data poll thread */
- rc = mm_camera_poll_thread_add_poll_fd(&my_obj->ch_obj->poll_thread[0],
- my_obj->my_hdl,
- my_obj->fd,
- mm_stream_data_notify,
- (void*)my_obj);
- if (rc < 0) {
- return rc;
- }
- rc = ioctl(my_obj->fd, VIDIOC_STREAMON, &buf_type);
- if (rc < 0) {
- CDBG_ERROR("%s: ioctl VIDIOC_STREAMON failed: rc=%d\n",
- __func__, rc);
- /* remove fd from data poll thread in case of failure */
- mm_camera_poll_thread_del_poll_fd(&my_obj->ch_obj->poll_thread[0], my_obj->my_hdl);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_streamoff(mm_stream_t *my_obj)
-{
- int32_t rc;
- enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- /* step1: remove fd from data poll thread */
- mm_camera_poll_thread_del_poll_fd(&my_obj->ch_obj->poll_thread[0], my_obj->my_hdl);
-
- /* step2: stream off */
- rc = ioctl(my_obj->fd, VIDIOC_STREAMOFF, &buf_type);
- if (rc < 0) {
- CDBG_ERROR("%s: STREAMOFF failed: %s\n",
- __func__, strerror(errno));
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-static uint32_t mm_stream_util_get_v4l2_fmt(cam_format_t fmt,
- uint8_t *num_planes)
-{
- uint32_t val;
- switch(fmt) {
- case CAMERA_YUV_420_NV12:
- val = V4L2_PIX_FMT_NV12;
- *num_planes = 2;
- break;
- case CAMERA_YUV_420_NV21:
- val = V4L2_PIX_FMT_NV21;
- *num_planes = 2;
- break;
- case CAMERA_BAYER_SBGGR10:
- case CAMERA_RDI:
- val= V4L2_PIX_FMT_SBGGR10;
- *num_planes = 1;
- break;
- case CAMERA_YUV_422_NV61:
- val= V4L2_PIX_FMT_NV61;
- *num_planes = 2;
- break;
- case CAMERA_SAEC:
- val = V4L2_PIX_FMT_STATS_AE;
- *num_planes = 1;
- break;
- case CAMERA_SAWB:
- val = V4L2_PIX_FMT_STATS_AWB;
- *num_planes = 1;
- break;
- case CAMERA_SAFC:
- val = V4L2_PIX_FMT_STATS_AF;
- *num_planes = 1;
- break;
- case CAMERA_SHST:
- val = V4L2_PIX_FMT_STATS_IHST;
- *num_planes = 1;
- break;
- case CAMERA_YUV_422_YUYV:
- val= V4L2_PIX_FMT_YUYV;
- *num_planes = 1;
- break;
- case CAMERA_YUV_420_YV12:
- val= V4L2_PIX_FMT_NV12;
- *num_planes = 3;
- break;
- default:
- val = 0;
- *num_planes = 0;
- CDBG_ERROR("%s: Unknown fmt=%d", __func__, fmt);
- break;
- }
- CDBG("%s: fmt=%d, val =%d, num_planes=%d", __func__, fmt, val , *num_planes);
- return val;
-}
-
-int32_t mm_stream_read_msm_frame(mm_stream_t * my_obj,
- mm_camera_buf_info_t* buf_info)
-{
- int32_t idx = -1, rc = 0;
- struct v4l2_buffer vb;
- struct v4l2_plane planes[VIDEO_MAX_PLANES];
- uint32_t i = 0;
- uint8_t num_planes = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- mm_stream_util_get_v4l2_fmt(my_obj->fmt.fmt,
- &num_planes);
-
- memset(&vb, 0, sizeof(vb));
- vb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- vb.memory = V4L2_MEMORY_USERPTR;
- vb.m.planes = &planes[0];
- vb.length = num_planes;
-
- rc = ioctl(my_obj->fd, VIDIOC_DQBUF, &vb);
- if (rc < 0) {
- CDBG_ERROR("%s: VIDIOC_DQBUF ioctl call failed (rc=%d)\n",
- __func__, rc);
- } else {
- int8_t idx = vb.index;
- buf_info->buf = &my_obj->buf[idx];
- buf_info->frame_idx = vb.sequence;
- buf_info->stream_id = my_obj->my_hdl;
-
- buf_info->buf->stream_id = my_obj->my_hdl;
- buf_info->buf->buf_idx = idx;
- buf_info->buf->frame_idx = vb.sequence;
- buf_info->buf->ts.tv_sec = vb.timestamp.tv_sec;
- buf_info->buf->ts.tv_nsec = vb.timestamp.tv_usec * 1000;
-
- for(i = 0; i < vb.length; i++) {
- CDBG("%s plane %d addr offset: %d data offset:%d\n",
- __func__, i, vb.m.planes[i].reserved[0],
- vb.m.planes[i].data_offset);
- buf_info->buf->planes[i].reserved[0] =
- vb.m.planes[i].reserved[0];
- buf_info->buf->planes[i].data_offset =
- vb.m.planes[i].data_offset;
- }
-
-
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_get_crop(mm_stream_t *my_obj,
- mm_camera_rect_t *crop)
-{
- struct v4l2_crop crop_info;
- int32_t rc = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- memset(&crop_info, 0, sizeof(crop_info));
- crop_info.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- rc = ioctl(my_obj->fd, VIDIOC_G_CROP, &crop_info);
- if (0 == rc) {
- crop->left = crop_info.c.left;
- crop->top = crop_info.c.top;
- crop->width = crop_info.c.width;
- crop->height = crop_info.c.height;
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_set_parm_acquire(mm_stream_t *my_obj,
- void *in_value)
-{
- int32_t rc = 0;
- mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)in_value;
- mm_camera_stream_parm_t parm_type = payload->parm_type;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, parm_type = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, parm_type);
-
- switch(parm_type) {
- case MM_CAMERA_STREAM_CID:{
- stream_cid_t *value = (stream_cid_t *)in_value;
- mm_stream_set_cid(my_obj,value);
- break;
- }
- default:
- CDBG_ERROR("%s : Parm -%d set is not supported here",__func__,(int)parm_type);
- break;
- }
- return rc;
-}
-int32_t mm_stream_get_parm_acquire(mm_stream_t *my_obj,
- void *out_value)
-{
- int32_t rc = 0;
- mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)out_value;
- mm_camera_stream_parm_t parm_type = payload->parm_type;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, parm_type = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, parm_type);
-
- switch(parm_type) {
- case MM_CAMERA_STREAM_CID:{
- stream_cid_t *value = (stream_cid_t *)out_value;
- rc = mm_stream_get_cid(my_obj,value);
- break;
- }
- case MM_CAMERA_STREAM_CROP:{
- mm_camera_rect_t *crop = (mm_camera_rect_t *)out_value;
- rc = mm_stream_get_crop(my_obj, crop);
- break;
- }
- default:
- CDBG_ERROR("%s : Parm -%d get is not supported here",__func__,(int)parm_type);
- break;
- }
- return rc;
-}
-
-int32_t mm_stream_set_parm_config(mm_stream_t *my_obj,
- void *in_value)
-{
- int32_t rc = 0;
- mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)in_value;
- mm_camera_stream_parm_t parm_type = payload->parm_type;
- void *value = payload->value;
-
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, parm_type = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, parm_type);
- switch(parm_type) {
- default:
- CDBG_ERROR("%s : Parm -%d set is not supported here",__func__,(int)parm_type);
- break;
- }
- return rc;
-}
-int32_t mm_stream_get_parm_config(mm_stream_t *my_obj,
- void *out_value)
-{
- int32_t rc = 0;
- mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)out_value;
-
- if(payload == NULL) {
- CDBG_ERROR("%s : Invalid Argument",__func__);
- return -1;
- }
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, parm_type = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, (int)payload->parm_type);
- switch(payload->parm_type) {
- case MM_CAMERA_STREAM_OFFSET:
- memcpy(payload->value,(void *)&my_obj->frame_offset,sizeof(mm_camera_frame_len_offset));
- break;
- case MM_CAMERA_STREAM_CROP:{
- mm_camera_rect_t *crop = (mm_camera_rect_t *)payload->value;
- rc = mm_stream_get_crop(my_obj, crop);
- break;
- }
- default:
- CDBG_ERROR("%s : Parm -%d get is not supported here",__func__,(int)payload->parm_type);
- break;
- }
- return rc;
-}
-
-int32_t mm_stream_set_parm_start(mm_stream_t *my_obj,
- void *in_value)
-{
- int32_t rc = 0;
- mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)in_value;
- mm_camera_stream_parm_t parm_type = payload->parm_type;
- void *value = payload->value;
-
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, parm_type = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, parm_type);
- switch(parm_type) {
- default:
- CDBG_ERROR("%s : Parm -%d set is not supported here",__func__,(int)parm_type);
- break;
- }
- return rc;
-}
-int32_t mm_stream_get_parm_start(mm_stream_t *my_obj,
- void *out_value)
-{
- int32_t rc = 0;
- mm_evt_paylod_stream_parm_t *payload = (mm_evt_paylod_stream_parm_t *)out_value;
-
- if(payload == NULL) {
- CDBG_ERROR("%s : Invalid Argument",__func__);
- return -1;
- }
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d, parm_type = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state, (int)payload->parm_type);
- switch(payload->parm_type) {
- case MM_CAMERA_STREAM_OFFSET:
- memcpy(payload->value,(void *)&my_obj->frame_offset,sizeof(mm_camera_frame_len_offset));
- break;
- case MM_CAMERA_STREAM_CROP:{
- mm_camera_rect_t *crop = (mm_camera_rect_t *)payload->value;
- rc = mm_stream_get_crop(my_obj, crop);
- break;
- }
- default:
- CDBG_ERROR("%s : Parm -%d get is not supported here",__func__,(int)payload->parm_type);
- break;
- }
- return rc;
-}
-int32_t mm_stream_set_ext_mode(mm_stream_t * my_obj)
-{
- int32_t rc = 0;
- struct v4l2_streamparm s_parm;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- s_parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- s_parm.parm.capture.extendedmode = my_obj->ext_image_mode;
-
- rc = ioctl(my_obj->fd, VIDIOC_S_PARM, &s_parm);
- CDBG("%s:stream fd=%d, rc=%d, extended_mode=%d\n",
- __func__, my_obj->fd, rc,
- s_parm.parm.capture.extendedmode);
- return rc;
-}
-
-int32_t mm_stream_qbuf(mm_stream_t *my_obj, mm_camera_buf_def_t *buf)
-{
- int32_t i, rc = 0;
- int *ret;
- struct v4l2_buffer buffer;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- memset(&buffer, 0, sizeof(buffer));
- buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- buffer.memory = V4L2_MEMORY_USERPTR;
- buffer.index = buf->buf_idx;
- buffer.m.planes = &buf->planes[0];
- buffer.length = buf->num_planes;
-
- CDBG("%s:stream_hdl=%d,fd=%d,frame idx=%d,num_planes = %d\n", __func__,
- buf->stream_id, buf->fd, buffer.index, buffer.length);
-
- rc = ioctl(my_obj->fd, VIDIOC_QBUF, &buffer);
- CDBG("%s: qbuf idx:%d, rc:%d", __func__, buffer.index, rc);
- return rc;
-}
-
-/* This function let kernel know amount of buffers will be registered */
-int32_t mm_stream_request_buf(mm_stream_t * my_obj)
-{
- int32_t rc = 0;
- uint8_t i,reg = 0;
- struct v4l2_requestbuffers bufreq;
- uint8_t buf_num = my_obj->buf_num;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- if(buf_num > MM_CAMERA_MAX_NUM_FRAMES) {
- CDBG_ERROR("%s: buf num %d > max limit %d\n",
- __func__, buf_num, MM_CAMERA_MAX_NUM_FRAMES);
- return -1;
- }
- pthread_mutex_lock(&my_obj->buf_lock);
- for(i = 0; i < buf_num; i++){
- if (my_obj->buf_status[i].initial_reg_flag){
- reg = 1;
- break;
- }
- }
- pthread_mutex_unlock(&my_obj->buf_lock);
- if(!reg) {
- //No need to register a buffer
- CDBG_ERROR("No Need to register this buffer");
- return rc;
- }
- memset(&bufreq, 0, sizeof(bufreq));
- bufreq.count = buf_num;
- bufreq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- bufreq.memory = V4L2_MEMORY_USERPTR;
- rc = ioctl(my_obj->fd, VIDIOC_REQBUFS, &bufreq);
- if (rc < 0) {
- CDBG_ERROR("%s: fd=%d, ioctl VIDIOC_REQBUFS failed: rc=%d\n",
- __func__, my_obj->fd, rc);
- }
- CDBG("%s :X rc = %d",__func__,rc);
- return rc;
-}
-
-int32_t mm_stream_init_bufs(mm_stream_t * my_obj)
-{
- int32_t i, rc = 0, j;
- int image_type;
- mm_camear_mem_vtbl_t *mem_vtbl = NULL;
- mm_camera_frame_len_offset frame_offset;
- uint8_t *reg_flags = NULL;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- /* deinit buf if it's not NULL*/
- if (NULL != my_obj->buf) {
- mm_stream_deinit_bufs(my_obj);
- }
-
- my_obj->buf_num = my_obj->hal_requested_num_bufs;
- if (mm_camera_util_get_pp_mask(my_obj->ch_obj->cam_obj) > 0) {
- /* reserve extra one buf for pp */
- my_obj->buf_num++;
- }
-
- my_obj->buf =
- (mm_camera_buf_def_t*)malloc(sizeof(mm_camera_buf_def_t) * my_obj->buf_num);
- my_obj->buf_status =
- (mm_stream_buf_status_t*)malloc(sizeof(mm_stream_buf_status_t) * my_obj->buf_num);
- reg_flags = (uint8_t *)malloc(sizeof(uint8_t) * my_obj->buf_num);
-
- if (NULL == my_obj->buf ||
- NULL == my_obj->buf_status ||
- NULL == reg_flags) {
- CDBG_ERROR("%s: No memory for buf", __func__);
- rc = -1;
- goto error_malloc;
- }
-
- memset(my_obj->buf, 0, sizeof(mm_camera_buf_def_t) * my_obj->buf_num);
- memset(my_obj->buf_status, 0, sizeof(mm_stream_buf_status_t) * my_obj->buf_num);
- memset(reg_flags, 0, sizeof(uint8_t) * my_obj->buf_num);
-
- mem_vtbl = my_obj->ch_obj->cam_obj->mem_vtbl;
- rc = mem_vtbl->get_buf(my_obj->ch_obj->cam_obj->my_hdl,
- my_obj->ch_obj->my_hdl,
- my_obj->my_hdl,
- mem_vtbl->user_data,
- &my_obj->frame_offset,
- my_obj->buf_num,
- reg_flags,
- my_obj->buf);
-
- if (0 != rc) {
- CDBG_ERROR("%s: Error get buf, rc = %d\n", __func__, rc);
- goto error_malloc;
- }
-
- for (i=0; i < my_obj->buf_num; i++) {
- my_obj->buf_status[i].initial_reg_flag = reg_flags[i];
- my_obj->buf[i].stream_id = my_obj->my_hdl;
- }
-
- free(reg_flags);
- reg_flags = NULL;
-
- for (i=0; i < my_obj->buf_num; i++) {
- if (my_obj->buf[i].fd > 0) {
- if(0 >= (rc = mm_camera_map_buf(my_obj->ch_obj->cam_obj,
- my_obj->ext_image_mode,
- i,
- my_obj->buf[i].fd,
- my_obj->buf[i].frame_len)))
- {
- CDBG_ERROR("%s: Error mapping buf (rc = %d)", __func__, rc);
- goto error_map;
- }
- } else {
- CDBG_ERROR("%s: Invalid fd for buf idx (%d)", __func__, i);
- }
- }
-
- return 0;
-
-error_map:
- /* error, unmapping previously mapped bufs */
- for (j=0; j<i; j++) {
- if (my_obj->buf[j].fd > 0) {
- mm_camera_unmap_buf(my_obj->ch_obj->cam_obj,
- my_obj->ext_image_mode,
- j);
- }
- }
-
- /* put buf back */
- mem_vtbl->put_buf(my_obj->ch_obj->cam_obj->my_hdl,
- my_obj->ch_obj->my_hdl,
- my_obj->my_hdl,
- mem_vtbl->user_data,
- my_obj->buf_num,
- my_obj->buf);
-
-error_malloc:
- if (NULL != my_obj->buf) {
- free(my_obj->buf);
- my_obj->buf = NULL;
- }
- if (NULL != my_obj->buf_status) {
- free(my_obj->buf_status);
- my_obj->buf_status = NULL;
- }
- if (NULL != reg_flags) {
- free(reg_flags);
- reg_flags = NULL;
- }
-
- return rc;
-}
-
-/* return buffers to surface or release buffers allocated */
-int32_t mm_stream_deinit_bufs(mm_stream_t * my_obj)
-{
- int32_t rc = 0, i;
- mm_camear_mem_vtbl_t *mem_vtbl = NULL;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- if (NULL == my_obj->buf) {
- CDBG("%s: Buf is NULL, no need to deinit", __func__);
- return rc;
- }
-
- /* IOMMU unmapping */
- for (i=0; i<my_obj->buf_num; i++) {
- if (my_obj->buf[i].fd > 0) {
- rc = mm_camera_unmap_buf(my_obj->ch_obj->cam_obj,
- my_obj->ext_image_mode,
- i);
- if (rc < 0 ) {
- CDBG_ERROR("%s: Error unmapping bufs at idx(%d) rc=%d",
- __func__, i, rc);
- }
- }
- }
-
- /* release bufs */
- mem_vtbl = my_obj->ch_obj->cam_obj->mem_vtbl;
- if (NULL != mem_vtbl) {
- rc = mem_vtbl->put_buf(my_obj->ch_obj->cam_obj->my_hdl,
- my_obj->ch_obj->my_hdl,
- my_obj->my_hdl,
- mem_vtbl->user_data,
- my_obj->buf_num,
- my_obj->buf);
- } else {
- CDBG_ERROR("%s: mem table is NULL, cannot release buf", __func__);
- rc = -1;
- }
- free(my_obj->buf);
- my_obj->buf = NULL;
- free(my_obj->buf_status);
- my_obj->buf_status = NULL;
-
- return rc;
-}
-
-int32_t mm_stream_reg_buf(mm_stream_t * my_obj)
-{
- int32_t rc = 0;
- uint8_t i;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- rc = mm_stream_request_buf(my_obj);
- if (rc != 0) {
- return rc;
- }
-
- pthread_mutex_lock(&my_obj->buf_lock);
- for(i = 0; i < my_obj->buf_num; i++){
- my_obj->buf[i].buf_idx = i;
-
- /* check if need to qbuf initially */
- if (my_obj->buf_status[i].initial_reg_flag) {
- rc = mm_stream_qbuf(my_obj, &my_obj->buf[i]);
- if (rc != 0) {
- CDBG_ERROR("%s: VIDIOC_QBUF rc = %d\n", __func__, rc);
- break;
- }
- my_obj->buf_status[i].buf_refcnt = 0;
- my_obj->buf_status[i].in_kernel = 1;
- } else {
- /* the buf is held by upper layer, will not queue into kernel.
- * add buf reference count */
- my_obj->buf_status[i].buf_refcnt = 1;
- my_obj->buf_status[i].in_kernel = 0;
- }
- }
-
- pthread_mutex_unlock(&my_obj->buf_lock);
- return rc;
-}
-
-int32_t mm_stream_unreg_buf(mm_stream_t * my_obj)
-{
- struct v4l2_requestbuffers bufreq;
- int32_t i, rc = 0,reg = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- pthread_mutex_lock(&my_obj->buf_lock);
- if (NULL != my_obj->buf_status) {
- for(i = 0; i < my_obj->buf_num; i++){
- if (my_obj->buf_status[i].initial_reg_flag){
- reg = 1;
- break;
- }
- }
- }
- pthread_mutex_unlock(&my_obj->buf_lock);
- if(!reg) {
- //No need to unregister a buffer
- goto end;
- }
- bufreq.count = 0;
- bufreq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- bufreq.memory = V4L2_MEMORY_USERPTR;
- rc = ioctl(my_obj->fd, VIDIOC_REQBUFS, &bufreq);
- if (rc < 0) {
- CDBG_ERROR("%s: fd=%d, VIDIOC_REQBUFS failed, rc=%d\n",
- __func__, my_obj->fd, rc);
- }
-
-end:
- /* reset buf reference count */
- pthread_mutex_lock(&my_obj->buf_lock);
- if (NULL != my_obj->buf_status) {
- for(i = 0; i < my_obj->buf_num; i++){
- my_obj->buf_status[i].buf_refcnt = 0;
- my_obj->buf_status[i].in_kernel = 0;
- }
- }
- pthread_mutex_unlock(&my_obj->buf_lock);
-
- return rc;
-}
-
-int32_t mm_stream_set_fmt(mm_stream_t *my_obj)
-{
- int32_t rc = 0;
- struct v4l2_format fmt;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- if(my_obj->fmt.width == 0 || my_obj->fmt.height == 0) {
- CDBG_ERROR("%s:invalid input[w=%d,h=%d,fmt=%d]\n",
- __func__, my_obj->fmt.width, my_obj->fmt.height, my_obj->fmt.fmt);
- return -1;
- }
-
- memset(&fmt, 0, sizeof(fmt));
- fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- fmt.fmt.pix_mp.width = my_obj->fmt.width;
- fmt.fmt.pix_mp.height= my_obj->fmt.height;
- fmt.fmt.pix_mp.field = V4L2_FIELD_NONE;
- fmt.fmt.pix_mp.pixelformat =
- mm_stream_util_get_v4l2_fmt(my_obj->fmt.fmt,
- &(fmt.fmt.pix_mp.num_planes));
- rc = ioctl(my_obj->fd, VIDIOC_S_FMT, &fmt);
- CDBG("%s:fd=%d, ext_image_mode=%d, rc=%d, fmt.fmt.pix_mp.pixelformat : 0x%x\n",
- __func__, my_obj->fd, my_obj->ext_image_mode, rc,
- fmt.fmt.pix_mp.pixelformat);
- return rc;
-}
-
-int32_t mm_stream_get_offset(mm_stream_t *my_obj)
-{
- int32_t rc = 0;
- cam_frame_resolution_t frame_offset;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- memset(&my_obj->frame_offset,0,sizeof(mm_camera_frame_len_offset));
-
- frame_offset.format = my_obj->fmt.fmt;
- frame_offset.rotation = my_obj->fmt.rotation;
- frame_offset.width = my_obj->fmt.width;
- frame_offset.height = my_obj->fmt.height;
- frame_offset.image_mode = my_obj->ext_image_mode;
- if (!my_obj->need_stream_on &&
- my_obj->ext_image_mode == MSM_V4L2_EXT_CAPTURE_MODE_MAIN) {
- /* in case of video-sized snapshot,
- * image_mode should be video when querying frame offset*/
- frame_offset.image_mode = MSM_V4L2_EXT_CAPTURE_MODE_VIDEO;
- }
-
- switch (frame_offset.image_mode) {
- case MSM_V4L2_EXT_CAPTURE_MODE_PREVIEW:
- if (CAMERA_YUV_420_YV12 == frame_offset.format) {
- frame_offset.padding_format = CAMERA_PAD_TO_2K;
- } else {
- frame_offset.padding_format = CAMERA_PAD_TO_WORD;
- }
- break;
- case MSM_V4L2_EXT_CAPTURE_MODE_MAIN:
- case MSM_V4L2_EXT_CAPTURE_MODE_RAW:
- case MSM_V4L2_EXT_CAPTURE_MODE_THUMBNAIL:
- case MSM_V4L2_EXT_CAPTURE_MODE_RDI:
- frame_offset.padding_format = CAMERA_PAD_TO_WORD;
- break;
- case MSM_V4L2_EXT_CAPTURE_MODE_AEC:
- case MSM_V4L2_EXT_CAPTURE_MODE_AWB:
- case MSM_V4L2_EXT_CAPTURE_MODE_AF:
- case MSM_V4L2_EXT_CAPTURE_MODE_IHIST:
- break;
- case MSM_V4L2_EXT_CAPTURE_MODE_VIDEO:
- default:
- frame_offset.padding_format = CAMERA_PAD_TO_2K;
- break;
- }
-
- CDBG("%s: format = %d, image_mode = %d, padding_format = %d, rotation = %d,"
- "width = %d height = %d",
- __func__,frame_offset.format,frame_offset.image_mode,frame_offset.padding_format,
- frame_offset.rotation,frame_offset.width,frame_offset.height);
-
- rc = mm_camera_send_native_ctrl_cmd(my_obj->ch_obj->cam_obj,
- CAMERA_GET_PARM_FRAME_RESOLUTION,
- sizeof(cam_frame_resolution_t),
- &frame_offset);
- if(rc != 0) {
- CDBG_ERROR("%s: Failed to get the stream offset and frame length",__func__);
- return rc;
- }
- my_obj->fmt.width = frame_offset.width;
- my_obj->fmt.height = frame_offset.height;
- memcpy(&my_obj->frame_offset,&frame_offset.frame_offset,sizeof(mm_camera_frame_len_offset));
- CDBG("%s: Frame length = %d width = %d, height = %d, rc = %d",
- __func__,my_obj->frame_offset.frame_len,my_obj->fmt.width,my_obj->fmt.height,rc);
- return rc;
-}
-
-
-int32_t mm_stream_set_cid(mm_stream_t *my_obj,stream_cid_t *value)
-{
- int32_t rc = 0;
- cam_cid_info_t cam_cid_info;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- cam_cid_info.num_cids = 1;
- cam_cid_info.cid_entries[0].cid = value->cid;
- cam_cid_info.cid_entries[0].dt = value->dt;
- cam_cid_info.cid_entries[0].inst_handle = my_obj->inst_hdl;
-
- rc = mm_camera_send_native_ctrl_cmd(my_obj->ch_obj->cam_obj,
- CAMERA_SET_PARM_CID,
- sizeof(cam_cid_info_t),
- &cam_cid_info);
- if(rc != 0) {
- CDBG_ERROR("%s: Failed to set the CID",__func__);
- return rc;
- }
- return rc;
-}
-
-int32_t mm_stream_get_cid(mm_stream_t *my_obj,stream_cid_t *out_value)
-{
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
- //TODO: Need to use sensor structure init in camera query
- int32_t rc = 0;
- return rc;
-}
-
-int32_t mm_stream_buf_done(mm_stream_t * my_obj,
- mm_camera_buf_def_t *frame)
-{
- int32_t rc = 0;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- if (my_obj->is_local_buf) {
- /* special case for video-sized live snapshot
- * buf is local, no need to qbuf to kernel */
- return 0;
- }
-
- pthread_mutex_lock(&my_obj->buf_lock);
-
- if(my_obj->buf_status[frame->buf_idx].buf_refcnt == 0) {
- CDBG("%s: Error Trying to free second time?(idx=%d) count=%d, ext_image_mode=%d\n",
- __func__, frame->buf_idx,
- my_obj->buf_status[frame->buf_idx].buf_refcnt,
- my_obj->ext_image_mode);
- rc = -1;
- }else{
- my_obj->buf_status[frame->buf_idx].buf_refcnt--;
- if (0 == my_obj->buf_status[frame->buf_idx].buf_refcnt) {
- CDBG("<DEBUG> : Buf done for buffer:%d:%d", my_obj->ext_image_mode, frame->buf_idx);
- rc = mm_stream_qbuf(my_obj, frame);
- if(rc < 0) {
- CDBG_ERROR("%s: mm_camera_stream_qbuf(idx=%d) err=%d\n",
- __func__, frame->buf_idx, rc);
- } else {
- my_obj->buf_status[frame->buf_idx].in_kernel = 1;
- }
- }else{
- CDBG("<DEBUG> : Still ref count pending count :%d",
- my_obj->buf_status[frame->buf_idx].buf_refcnt);
- CDBG("<DEBUG> : for buffer:%p:%d, ext_image_mode=%d",
- my_obj, frame->buf_idx, my_obj->ext_image_mode);
- }
- }
- pthread_mutex_unlock(&my_obj->buf_lock);
- return rc;
-}
-
-int32_t mm_stream_reg_buf_cb(mm_stream_t *my_obj,
- mm_stream_data_cb_t *val)
-{
- int32_t rc = -1;
- uint8_t i;
- CDBG("%s: E, inst_handle = 0x%x, my_handle = 0x%x, "
- "image_mode = %d, fd = %d, state = %d",
- __func__, my_obj->inst_hdl, my_obj->my_hdl,
- my_obj->ext_image_mode, my_obj->fd, my_obj->state);
-
- pthread_mutex_lock(&my_obj->cb_lock);
- for (i=0 ;i < MM_CAMERA_STREAM_BUF_CB_MAX; i++) {
- if(NULL == my_obj->buf_cb[i].cb) {
- memcpy(&my_obj->buf_cb[i], val, sizeof(mm_stream_data_cb_t));
- rc = 0;
- break;
- }
- }
- pthread_mutex_unlock(&my_obj->cb_lock);
-
- return rc;
-}
diff --git a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_thread.c b/camera/QCamera/stack/mm-camera-interface/src/mm_camera_thread.c
deleted file mode 100755
index 6947ed4..0000000
--- a/camera/QCamera/stack/mm-camera-interface/src/mm_camera_thread.c
+++ /dev/null
@@ -1,361 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <semaphore.h>
-
-#include "mm_camera_dbg.h"
-#include "mm_camera_interface.h"
-#include "mm_camera.h"
-
-typedef enum {
- /* poll entries updated */
- MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED,
- /* exit */
- MM_CAMERA_PIPE_CMD_EXIT,
- /* max count */
- MM_CAMERA_PIPE_CMD_MAX
-} mm_camera_pipe_cmd_type_t;
-
-typedef enum {
- MM_CAMERA_POLL_TASK_STATE_STOPPED,
- MM_CAMERA_POLL_TASK_STATE_POLL, /* polling pid in polling state. */
- MM_CAMERA_POLL_TASK_STATE_MAX
-} mm_camera_poll_task_state_type_t;
-
-typedef struct {
- uint8_t cmd;
- mm_camera_event_t event;
-} mm_camera_sig_evt_t;
-
-static int32_t mm_camera_poll_sig(mm_camera_poll_thread_t *poll_cb,
- uint32_t cmd)
-{
- /* send through pipe */
- /* get the mutex */
- mm_camera_sig_evt_t cmd_evt;
- int len;
-
- CDBG("%s: E cmd = %d", __func__,cmd);
- memset(&cmd_evt, 0, sizeof(cmd_evt));
- cmd_evt.cmd = cmd;
- pthread_mutex_lock(&poll_cb->mutex);
- /* reset the statue to false */
- poll_cb->status = FALSE;
- /* send cmd to worker */
-
- len = write(poll_cb->pfds[1], &cmd_evt, sizeof(cmd_evt));
- if(len < 1) {
- CDBG_ERROR("%s: len = %d, errno = %d", __func__, len, errno);
- }
- CDBG("%s: begin IN mutex write done, len = %d", __func__, len);
- /* wait till worker task gives positive signal */
- if (FALSE == poll_cb->status) {
- CDBG("%s: wait", __func__);
- pthread_cond_wait(&poll_cb->cond_v, &poll_cb->mutex);
- }
- /* done */
- pthread_mutex_unlock(&poll_cb->mutex);
- CDBG("%s: X", __func__);
- return 0;
-}
-
-static void mm_camera_poll_sig_done(mm_camera_poll_thread_t *poll_cb)
-{
- pthread_mutex_lock(&poll_cb->mutex);
- poll_cb->status = TRUE;
- pthread_cond_signal(&poll_cb->cond_v);
- CDBG("%s: done, in mutex", __func__);
- pthread_mutex_unlock(&poll_cb->mutex);
-}
-
-static void mm_camera_poll_set_state(mm_camera_poll_thread_t *poll_cb,
- mm_camera_poll_task_state_type_t state)
-{
- poll_cb->state = state;
-}
-
-static void mm_camera_poll_proc_pipe(mm_camera_poll_thread_t *poll_cb)
-{
- ssize_t read_len;
- int i;
- mm_camera_sig_evt_t cmd_evt;
- read_len = read(poll_cb->pfds[0], &cmd_evt, sizeof(cmd_evt));
- CDBG("%s: read_fd = %d, read_len = %d, expect_len = %d cmd = %d",
- __func__, poll_cb->pfds[0], (int)read_len, (int)sizeof(cmd_evt), cmd_evt.cmd);
- switch (cmd_evt.cmd) {
- case MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED:
- /* we always have index 0 for pipe read */
- poll_cb->num_fds = 0;
- poll_cb->poll_fds[poll_cb->num_fds].fd = poll_cb->pfds[0];
- poll_cb->poll_fds[poll_cb->num_fds].events = POLLIN|POLLRDNORM|POLLPRI;
- poll_cb->num_fds++;
-
- if (MM_CAMERA_POLL_TYPE_EVT == poll_cb->poll_type) {
- if (poll_cb->poll_entries[0].fd > 0) {
- /* fd is valid, we update poll_fds */
- poll_cb->poll_fds[poll_cb->num_fds].fd = poll_cb->poll_entries[0].fd;
- poll_cb->poll_fds[poll_cb->num_fds].events = POLLIN|POLLRDNORM|POLLPRI;
- poll_cb->num_fds++;
- }
- } else if (MM_CAMERA_POLL_TYPE_CH == poll_cb->poll_type) {
- for(i = 0; i < MM_CAMEAR_STRAEM_NUM_MAX; i++) {
- if(poll_cb->poll_entries[i].fd > 0) {
- /* fd is valid, we update poll_fds to this fd */
- poll_cb->poll_fds[poll_cb->num_fds].fd = poll_cb->poll_entries[i].fd;
- poll_cb->poll_fds[poll_cb->num_fds].events = POLLIN|POLLRDNORM|POLLPRI;
- poll_cb->num_fds++;
- } else {
- /* fd is invalid, we set the entry to -1 to prevent polling.
- * According to spec, polling will not poll on entry with fd=-1.
- * If this is not the case, we need to skip these invalid fds
- * when updating this array.
- * We still keep fd=-1 in this array because this makes easier to
- * map cb associated with this fd once incoming data avail by directly
- * using the index-1(0 is reserved for pipe read, so need to reduce index by 1) */
- poll_cb->poll_fds[poll_cb->num_fds].fd = -1;
- poll_cb->poll_fds[poll_cb->num_fds].events = 0;
- poll_cb->num_fds++;
- }
- }
- }
- mm_camera_poll_sig_done(poll_cb);
- break;
-
- case MM_CAMERA_PIPE_CMD_EXIT:
- default:
- mm_camera_poll_set_state(poll_cb, MM_CAMERA_POLL_TASK_STATE_STOPPED);
- mm_camera_poll_sig_done(poll_cb);
- break;
- }
-}
-
-static void *mm_camera_poll_fn(mm_camera_poll_thread_t *poll_cb)
-{
- int rc = 0, i;
-
- CDBG("%s: poll type = %d, num_fd = %d poll_cb = %p\n",
- __func__, poll_cb->poll_type, poll_cb->num_fds,poll_cb);
- do {
- for(i = 0; i < poll_cb->num_fds; i++) {
- poll_cb->poll_fds[i].events = POLLIN|POLLRDNORM|POLLPRI;
- }
-
- rc = poll(poll_cb->poll_fds, poll_cb->num_fds, poll_cb->timeoutms);
- if(rc > 0) {
- if ((poll_cb->poll_fds[0].revents & POLLIN) &&
- (poll_cb->poll_fds[0].revents & POLLRDNORM)) {
- /* if we have data on pipe, we only process pipe in this iteration */
- CDBG("%s: cmd received on pipe\n", __func__);
- mm_camera_poll_proc_pipe(poll_cb);
- } else {
- for(i=1; i<poll_cb->num_fds; i++) {
- /* Checking for ctrl events */
- if ((poll_cb->poll_type == MM_CAMERA_POLL_TYPE_EVT) &&
- (poll_cb->poll_fds[i].revents & POLLPRI)) {
- CDBG("%s: mm_camera_evt_notify\n", __func__);
- if (NULL != poll_cb->poll_entries[i-1].notify_cb) {
- poll_cb->poll_entries[i-1].notify_cb(poll_cb->poll_entries[i-1].user_data);
- }
- }
-
- if ((poll_cb->poll_type == MM_CAMERA_POLL_TYPE_CH) &&
- (poll_cb->poll_fds[i].revents & POLLIN) &&
- (poll_cb->poll_fds[i].revents & POLLRDNORM)) {
- CDBG("%s: mm_stream_data_notify\n", __func__);
- if (NULL != poll_cb->poll_entries[i-1].notify_cb) {
- poll_cb->poll_entries[i-1].notify_cb(poll_cb->poll_entries[i-1].user_data);
- }
- }
- }
- }
- } else {
- /* in error case sleep 10 us and then continue. hard coded here */
- usleep(10);
- continue;
- }
- } while (poll_cb->state == MM_CAMERA_POLL_TASK_STATE_POLL);
- return NULL;
-}
-
-static void *mm_camera_poll_thread(void *data)
-{
- int rc = 0;
- int i;
- void *ret = NULL;
- mm_camera_poll_thread_t *poll_cb = (mm_camera_poll_thread_t *)data;
-
- /* add pipe read fd into poll first */
- poll_cb->poll_fds[poll_cb->num_fds++].fd = poll_cb->pfds[0];
-
- //poll_cb->poll_fds[poll_cb->num_fds++].fd = (((mm_camera_obj_t *)poll_cb->my_obj)->ctrl_fd);
-
- mm_camera_poll_sig_done(poll_cb);
- mm_camera_poll_set_state(poll_cb, MM_CAMERA_POLL_TASK_STATE_POLL);
- ret = mm_camera_poll_fn(poll_cb);
- return ret;
-}
-
-int32_t mm_camera_poll_thread_notify_entries_updated(mm_camera_poll_thread_t * poll_cb)
-{
- /* send poll entries updated signal to poll thread */
- return mm_camera_poll_sig(poll_cb, MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED);
-}
-
-int32_t mm_camera_poll_thread_add_poll_fd(mm_camera_poll_thread_t * poll_cb,
- uint32_t handler,
- int32_t fd,
- mm_camera_poll_notify_t notify_cb,
- void* userdata)
-{
- int32_t rc = -1;
- uint8_t idx = 0;
-
- if (MM_CAMERA_POLL_TYPE_CH == poll_cb->poll_type) {
- /* get stream idx from handler if CH type */
- idx = mm_camera_util_get_index_by_handler(handler);
- } else {
- /* for EVT type, only idx=0 is valid */
- idx = 0;
- }
-
- if (MM_CAMEAR_STRAEM_NUM_MAX > idx) {
- poll_cb->poll_entries[idx].fd = fd;
- poll_cb->poll_entries[idx].handler = handler;
- poll_cb->poll_entries[idx].notify_cb = notify_cb;
- poll_cb->poll_entries[idx].user_data = userdata;
- /* send poll entries updated signal to poll thread */
- rc = mm_camera_poll_sig(poll_cb, MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED);
- } else {
- CDBG_ERROR("%s: invalid handler %d (%d)",
- __func__, handler, idx);
- }
- return rc;
-}
-
-int32_t mm_camera_poll_thread_del_poll_fd(mm_camera_poll_thread_t * poll_cb,
- uint32_t handler)
-{
- int32_t rc = -1;
- uint8_t idx = 0;
-
- if (MM_CAMERA_POLL_TYPE_CH == poll_cb->poll_type) {
- /* get stream idx from handler if CH type */
- idx = mm_camera_util_get_index_by_handler(handler);
- } else {
- /* for EVT type, only idx=0 is valid */
- idx = 0;
- }
-
- if ((MM_CAMEAR_STRAEM_NUM_MAX > idx) &&
- (handler == poll_cb->poll_entries[idx].handler)) {
- /* reset poll entry */
- poll_cb->poll_entries[idx].fd = -1; /* set fd to invalid */
- poll_cb->poll_entries[idx].handler = 0;
- poll_cb->poll_entries[idx].notify_cb = NULL;
-
- /* send poll entries updated signal to poll thread */
- rc = mm_camera_poll_sig(poll_cb, MM_CAMERA_PIPE_CMD_POLL_ENTRIES_UPDATED);
- } else {
- CDBG_ERROR("%s: invalid handler %d (%d)",
- __func__, handler, idx);
- }
-
- return rc;
-}
-
-int32_t mm_camera_poll_thread_launch(mm_camera_poll_thread_t * poll_cb,
- mm_camera_poll_thread_type_t poll_type)
-{
- int32_t rc = 0;
- poll_cb->poll_type = poll_type;
-
- poll_cb->pfds[0] = 0;
- poll_cb->pfds[1] = 0;
- rc = pipe(poll_cb->pfds);
- if(rc < 0) {
- CDBG_ERROR("%s: pipe open rc=%d\n", __func__, rc);
- return -1;
- }
-
- poll_cb->timeoutms = -1; /* Infinite seconds */
-
- CDBG("%s: poll_type = %d, read fd = %d, write fd = %d timeout = %d",
- __func__, poll_cb->poll_type,
- poll_cb->pfds[0], poll_cb->pfds[1],poll_cb->timeoutms);
-
- pthread_mutex_init(&poll_cb->mutex, NULL);
- pthread_cond_init(&poll_cb->cond_v, NULL);
-
- /* launch the thread */
- pthread_mutex_lock(&poll_cb->mutex);
- poll_cb->status = 0;
- pthread_create(&poll_cb->pid, NULL, mm_camera_poll_thread, (void *)poll_cb);
- if(!poll_cb->status) {
- pthread_cond_wait(&poll_cb->cond_v, &poll_cb->mutex);
- }
- pthread_mutex_unlock(&poll_cb->mutex);
- CDBG("%s: End",__func__);
- return rc;
-}
-
-int32_t mm_camera_poll_thread_release(mm_camera_poll_thread_t *poll_cb)
-{
- int32_t rc = 0;
- if(MM_CAMERA_POLL_TASK_STATE_STOPPED == poll_cb->state) {
- CDBG_ERROR("%s: err, poll thread is not running.\n", __func__);
- return rc;
- }
-
- /* send exit signal to poll thread */
- mm_camera_poll_sig(poll_cb, MM_CAMERA_PIPE_CMD_EXIT);
- /* wait until poll thread exits */
- if (pthread_join(poll_cb->pid, NULL) != 0) {
- CDBG_ERROR("%s: pthread dead already\n", __func__);
- }
-
- /* close pipe */
- if(poll_cb->pfds[0]) {
- close(poll_cb->pfds[0]);
- }
- if(poll_cb->pfds[1]) {
- close(poll_cb->pfds[1]);
- }
-
- pthread_mutex_destroy(&poll_cb->mutex);
- pthread_cond_destroy(&poll_cb->cond_v);
- memset(poll_cb, 0, sizeof(mm_camera_poll_thread_t));
- return rc;
-}
diff --git a/camera/QCamera/stack/mm-camera-test/Android.mk b/camera/QCamera/stack/mm-camera-test/Android.mk
deleted file mode 100755
index 9613d05..0000000
--- a/camera/QCamera/stack/mm-camera-test/Android.mk
+++ /dev/null
@@ -1,62 +0,0 @@
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH:=$(call my-dir)
-include $(CLEAR_VARS)
-
-ifeq ($(call is-board-platform,msm8960),true)
-LOCAL_CFLAGS:= \
- -DAMSS_VERSION=$(AMSS_VERSION) \
- $(mmcamera_debug_defines) \
- $(mmcamera_debug_cflags) \
- $(USE_SERVER_TREE)
-
-LOCAL_CFLAGS += -include $(TARGET_OUT_INTERMEDIATES)/include/mm-camera/camera_defs_i.h
-LOCAL_CFLAGS += -include $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/linux/msm_ion.h
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
-LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_CFLAGS += -D_ANDROID_
-
-LOCAL_SRC_FILES:= \
- src/mm_qcamera_main_menu.c \
- src/mm_qcamera_display.c \
- src/mm_qcamera_app.c \
- src/mm_qcamera_snapshot.c \
- src/mm_qcamera_video.c \
- src/mm_qcamera_preview.c \
- src/mm_qcamera_rdi.c \
- src/mm_qcamera_unit_test.c \
- src/mm_qcamera_dual_test.c \
- src/mm_qcamera_pp.c
-
-LOCAL_C_INCLUDES:=$(LOCAL_PATH)/inc
-LOCAL_C_INCLUDES+= \
- $(TARGET_OUT_INTERMEDIATES)/include/mm-still/jpeg \
- $(TARGET_OUT_INTERMEDIATES)/include/mm-camera \
- $(LOCAL_PATH)/../mm-camera-interface/inc \
- $(LOCAL_PATH)/../mm-jpeg-interface/inc \
- $(LOCAL_PATH)/../common \
- $(LOCAL_PATH)/../../../ \
-
-LOCAL_C_INCLUDES+= $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/media
-LOCAL_C_INCLUDES+= $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
-
-ifeq ($(call is-board-platform,msm8960),true)
-LOCAL_CFLAGS += -DCAMERA_ION_HEAP_ID=ION_CP_MM_HEAP_ID
-else
-LOCAL_CFLAGS += -DCAMERA_ION_HEAP_ID=ION_CAMERA_HEAP_ID
-endif
-
-LOCAL_SHARED_LIBRARIES:= \
- libcutils libdl
-
-LOCAL_MODULE:= mm-qcamera-app
-
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_EXECUTABLE)
-endif
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
diff --git a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_app.h b/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_app.h
deleted file mode 100755
index 9b51825..0000000
--- a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_app.h
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#ifndef __MM_QCAMERA_APP_H__
-#define __MM_QCAMERA_APP_H__
-
-#include "camera.h"
-#include "mm_qcamera_main_menu.h"
-#include "mm_camera_interface.h"
-#include "mm_jpeg_interface.h"
-
-#define MM_QCAMERA_APP_INTERATION 1
-
-#define MM_APP_MAX_DUMP_FRAME_NUM 1000
-
-#define PREVIEW_BUF_NUM 7
-#define VIDEO_BUF_NUM 7
-#define ISP_PIX_BUF_NUM 9
-
-#define STATS_BUF_NUM 4
-
-typedef enum {
- MM_CAMERA_OK,
- MM_CAMERA_E_GENERAL,
- MM_CAMERA_E_NO_MEMORY,
- MM_CAMERA_E_NOT_SUPPORTED,
- MM_CAMERA_E_INVALID_INPUT,
- MM_CAMERA_E_INVALID_OPERATION, /* 5 */
- MM_CAMERA_E_ENCODE,
- MM_CAMERA_E_BUFFER_REG,
- MM_CAMERA_E_PMEM_ALLOC,
- MM_CAMERA_E_CAPTURE_FAILED,
- MM_CAMERA_E_CAPTURE_TIMEOUT, /* 10 */
-}mm_camera_status_type_t;
-
-typedef struct {
- int num;
- mm_camera_buf_def_t bufs[MM_CAMERA_MAX_NUM_FRAMES];
- struct ion_allocation_data alloc[MM_CAMERA_MAX_NUM_FRAMES];
- struct ion_fd_data ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES];
-} mm_camear_app_buf_t;
-
-typedef struct {
- uint32_t id;
- mm_camera_stream_config_t str_config;
- mm_camear_app_buf_t app_bufs;
-}mm_camear_stream_t;
-
-typedef enum{
- CAMERA_STATE_OPEN,
- CAMERA_STATE_PREVIEW,
- CAMERA_STATE_RECORD,
- CAMERA_STATE_SNAPSHOT,
- CAMERA_STATE_RDI
-}camera_state;
-
-typedef enum{
- CAMERA_MODE,
- RECORDER_MODE,
- ZSL_MODE,
- RDI_MODE
-}camera_mode;
-
-#define MM_QCAM_APP_MAX_STREAM_NUM MM_CAMERA_IMG_MODE_MAX
-
-typedef struct {
- mm_camera_buf_def_t *frame;
- uint8_t ref_cnt;
-} repro_src_buf_info;
-
-typedef struct {
- struct cam_list list;
- void* data;
-} mm_qcamera_q_node_t;
-
-typedef struct {
- mm_qcamera_q_node_t head; /* dummy head */
- uint32_t size;
- pthread_mutex_t lock;
-} mm_qcamera_queue_t;
-
-typedef struct {
- mm_camera_vtbl_t *cam;
- mm_camear_mem_vtbl_t *mem_cam;
- int8_t my_id;
- //mm_camera_op_mode_type_t op_mode;
- uint32_t ch_id;
- cam_ctrl_dimension_t dim;
- int open_flag;
- int ionfd;
- mm_camear_stream_t stream[MM_QCAM_APP_MAX_STREAM_NUM];
- camera_mode cam_mode;
- camera_state cam_state;
- int fullSizeSnapshot;
-
- mm_jpeg_ops_t jpeg_ops;
- uint32_t jpeg_hdl;
- mm_camera_super_buf_t* current_job_frames;
- uint32_t current_job_id;
- mm_camear_app_buf_t jpeg_buf;
-
- uint32_t isp_repro_handle;
- uint8_t repro_dest_num;
- mm_qcamera_queue_t repro_q;
- repro_src_buf_info repro_buf_info[ISP_PIX_BUF_NUM];
- mm_camera_repro_config_data_t repro_config;
-} mm_camera_app_obj_t;
-
-typedef struct {
- void *ptr;
- void* ptr_jpeg;
-
- mm_camera_info_t *(*mm_camera_query) (uint8_t *num_cameras);
- mm_camera_vtbl_t *(*mm_camera_open) (uint8_t camera_idx,
- mm_camear_mem_vtbl_t *mem_vtbl);
- uint32_t (*jpeg_open) (mm_jpeg_ops_t *ops);
-
- /*uint8_t *(*mm_camera_do_mmap)(uint32_t size, int *pmemFd);
- int (*mm_camera_do_munmap)(int pmem_fd, void *addr, size_t size);
-
- uint8_t *(*mm_camera_do_mmap_ion)(int ion_fd, struct ion_allocation_data *alloc,
- struct ion_fd_data *ion_info_fd, int *mapFd);
- int (*mm_camera_do_munmap_ion) (int ion_fd, struct ion_fd_data *ion_info_fd,
- void *addr, size_t size);*/
-#if 0
- uint32_t (*mm_camera_get_msm_frame_len)(cam_format_t fmt_type,
- camera_mode_t mode,
- int width,
- int height,
- int image_type,
- uint8_t *num_planes,
- uint32_t planes[]);
-#ifndef DISABLE_JPEG_ENCODING
- void (*set_callbacks)(jpegfragment_callback_t fragcallback,
- jpeg_callback_t eventcallback, void* userdata, void* output_buffer,
- int * outBufferSize);
- int8_t (*omxJpegOpen)(void);
- void (*omxJpegClose)(void);
- int8_t (*omxJpegStart)(void);
- int8_t (*omxJpegEncode)(omx_jpeg_encode_params *encode_params);
- void (*omxJpegFinish)(void);
- int8_t (*mm_jpeg_encoder_setMainImageQuality)(uint32_t quality);
-#endif
-#endif
-} hal_interface_lib_t;
-
-typedef struct {
- //mm_camera_vtbl_t *cam;
- uint8_t num_cameras;
- mm_camera_app_obj_t *obj[2];
- mm_camera_info_t *cam_info;
- int use_overlay;
- int use_user_ptr;
- hal_interface_lib_t hal_lib;
- int cam_open;
- int run_sanity;
-} mm_camera_app_t;
-
-extern mm_camera_app_t my_cam_app;
-extern USER_INPUT_DISPLAY_T input_display;
-extern int mm_app_dl_render(int frame_fd, struct crop_info * cropinfo);
-extern mm_camera_app_obj_t *mm_app_get_cam_obj(int8_t cam_id);
-extern int mm_app_load_hal();
-extern int mm_app_init();
-extern void mm_app_user_ptr(int use_user_ptr);
-extern int mm_app_open_ch(int cam_id);
-extern void mm_app_close_ch(int cam_id, int ch_type);
-extern int mm_app_set_dim(int8_t cam_id, cam_ctrl_dimension_t *dim);
-extern int mm_app_run_unit_test();
-extern int mm_app_unit_test_entry(mm_camera_app_t *cam_app);
-extern int mm_app_unit_test();
-extern void mm_app_set_dim_def(cam_ctrl_dimension_t *dim);
-extern int mm_app_open(uint8_t camera_idx);
-extern int mm_app_close(int8_t cam_id);
-extern int startPreview(int cam_id);
-extern int mm_app_stop_preview(int cam_id);
-extern int mm_app_stop_video(int cam_id);
-extern int startRecording(int cam_id);
-extern int stopRecording(int cam_id);
-extern int mm_app_take_picture(int cam_id);
-extern int mm_app_take_raw_picture(int cam_id);
-extern int mm_app_get_dim(int8_t cam_id, cam_ctrl_dimension_t *dim);
-extern int mm_app_streamon_preview(int cam_id);
-extern int mm_app_set_snapshot_fmt(int cam_id,mm_camera_image_fmt_t *fmt);
-
-extern int mm_app_dual_test_entry(mm_camera_app_t *cam_app);
-extern int mm_app_dual_test();
-
-extern int mm_camera_app_wait();
-extern void mm_camera_app_done();
-
-extern int mm_stream_initbuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs);
-
-extern int mm_stream_deinitbuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs);
-
-extern void mm_app_preview_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data);
-#endif /* __MM_QCAMERA_APP_H__ */
-
-
-
-
-
-
-
-
-
diff --git a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_display_dimensions.h b/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_display_dimensions.h
deleted file mode 100755
index 7ff486b..0000000
--- a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_display_dimensions.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-
-#ifndef __MM_QCAMERA_DISPLAY_DIMENSIONS__
-#define __MM_QCAMERA_DISPLAY_DIMENSIONS__
-
-#define PREVIEW_WIDTH 800
-#define PREVIEW_HEIGHT 480
-#define DISPLAY_WIDTH 800
-#define DISPLAY_HEIGHT 480
-#define THUMBNAIL_WIDTH 192
-#define THUMBNAIL_HEIGHT 144
-#define PICTURE_WIDTH 1280
-#define PICTURE_HEIGHT 960
-
-#endif /* __MM_QCAMERA_DISPLAY_DIMENSIONS__ */
diff --git a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_main_menu.h b/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_main_menu.h
deleted file mode 100755
index 898f0b8..0000000
--- a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_main_menu.h
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#ifndef __MM_QCAMERA_MAIN_MENU_H__
-#define __MM_QCAMERA_MAIN_MENU_H__
-
-#include "camera.h"
-#include "mm_camera_interface.h"
-
-
-#define VIDEO_BUFFER_SIZE (PREVIEW_WIDTH * PREVIEW_HEIGHT * 3/2)
-#define THUMBNAIL_BUFFER_SIZE (THUMBNAIL_WIDTH * THUMBNAIL_HEIGHT * 3/2)
-#define SNAPSHOT_BUFFER_SIZE (PICTURE_WIDTH * PICTURE_HEIGHT * 3/2)
-
-/*===========================================================================
- * Macro
- *===========================================================================*/
-#define PREVIEW_FRAMES_NUM 4
-#define VIDEO_FRAMES_NUM 4
-#define THUMBNAIL_FRAMES_NUM 1
-#define SNAPSHOT_FRAMES_NUM 1
-#define MAX_NUM_FORMAT 32
-
-typedef enum
-{
- STOP_CAMERA = 1,
- PREVIEW_VIDEO_RESOLUTION = 2,
- TAKE_YUV_SNAPSHOT = 3,
- TAKE_RAW_SNAPSHOT = 4,
- TAKE_ZSL_SNAPSHOT = 5,
- //TAKE_LIVE_SNAPSHOT = 17,
- START_RECORDING = 6,
- START_RDI = 7,
- STOP_RDI = 8,
- SWITCH_CAMERA = 9,
- //STOP_RECORDING = 7,
- //SET_WHITE_BALANCE = 3,
- //SET_EXP_METERING = 4,
- //GET_CTRL_VALUE = 5,
- //TOGGLE_AFR = 6,
- //SET_ISO = 7,
- //BRIGHTNESS_GOTO_SUBMENU = 8,
- //CONTRAST_GOTO_SUBMENU = 9,
- //EV_GOTO_SUBMENU = 10,
- //SATURATION_GOTO_SUBMENU = 11,
- //SET_ZOOM = 12,
- //SET_SHARPNESS = 13,
-} Camera_main_menu_t;
-
-typedef enum
-{
- ACTION_NO_ACTION,
- ACTION_STOP_CAMERA,
- ACTION_PREVIEW_VIDEO_RESOLUTION,
- ACTION_TAKE_YUV_SNAPSHOT,
- ACTION_TAKE_RAW_SNAPSHOT,
- ACTION_TAKE_ZSL_SNAPSHOT,
- ACTION_TAKE_LIVE_SNAPSHOT,
- ACTION_START_RECORDING,
- ACTION_STOP_RECORDING,
- ACTION_START_RDI,
- ACTION_STOP_RDI,
- ACTION_SWITCH_CAMERA,
- ACTION_SET_WHITE_BALANCE,
- ACTION_SET_EXP_METERING,
- ACTION_GET_CTRL_VALUE,
- ACTION_TOGGLE_AFR,
- ACTION_SET_ISO,
- ACTION_BRIGHTNESS_INCREASE,
- ACTION_BRIGHTNESS_DECREASE,
- ACTION_CONTRAST_INCREASE,
- ACTION_CONTRAST_DECREASE,
- ACTION_EV_INCREASE,
- ACTION_EV_DECREASE,
- ACTION_SATURATION_INCREASE,
- ACTION_SATURATION_DECREASE,
- ACTION_SET_ZOOM,
- ACTION_SHARPNESS_INCREASE,
- ACTION_SHARPNESS_DECREASE,
-} camera_action_t;
-
-#define INVALID_KEY_PRESS 0
-#define BASE_OFFSET ('Z' - 'A' + 1)
-#define BASE_OFFSET_NUM ('Z' - 'A' + 2)
-#define PAD_TO_WORD(a) (((a)+3)&~3)
-
-
-#define SQCIF_WIDTH 128
-#define SQCIF_HEIGHT 96
-#define QCIF_WIDTH 176
-#define QCIF_HEIGHT 144
-#define QVGA_WIDTH 320
-#define QVGA_HEIGHT 240
-#define HD_THUMBNAIL_WIDTH 256
-#define HD_THUMBNAIL_HEIGHT 144
-#define CIF_WIDTH 352
-#define CIF_HEIGHT 288
-#define VGA_WIDTH 640
-#define VGA_HEIGHT 480
-#define WVGA_WIDTH 800
-#define WVGA_HEIGHT 480
-
-#define MP1_WIDTH 1280
-#define MP1_HEIGHT 960
-#define MP2_WIDTH 1600
-#define MP2_HEIGHT 1200
-#define MP3_WIDTH 2048
-#define MP3_HEIGHT 1536
-#define MP5_WIDTH 2592
-#define MP5_HEIGHT 1944
-
-#define SVGA_WIDTH 800
-#define SVGA_HEIGHT 600
-#define XGA_WIDTH 1024
-#define XGA_HEIGHT 768
-#define HD720_WIDTH 1280
-#define HD720_HEIGHT 720
-#define WXGA_WIDTH 1280
-#define WXGA_HEIGHT 768
-#define HD1080_WIDTH 1920
-#define HD1080_HEIGHT 1080
-
-typedef enum
-{
- RESOLUTION_MIN = 1,
- SQCIF = RESOLUTION_MIN,
- QCIF = 2,
- QVGA = 3,
- CIF = 4,
- VGA = 5,
- WVGA = 6,
- SVGA = 7,
- XGA = 8,
- HD720 = 9,
- RESOLUTION_PREVIEW_VIDEO_MAX = HD720,
- WXGA = 10,
- MP1 = 11,
- MP2 = 12,
- HD1080 = 13,
- MP3 = 14,
- MP5 = 15,
- RESOLUTION_MAX = MP5,
-} Camera_Resolution;
-
-
-typedef enum {
- WHITE_BALANCE_STATE = 1,
- WHITE_BALANCE_TEMPERATURE = 2,
- BRIGHTNESS_CTRL = 3,
- EV = 4,
- CONTRAST_CTRL = 5,
- SATURATION_CTRL = 6,
- SHARPNESS_CTRL = 7,
-} Get_Ctrl_modes;
-
-typedef enum {
- EXP_METERING_FRAME_AVERAGE = 1,
- EXP_METERING_CENTER_WEIGHTED = 2,
- EXP_METERING_SPOT_METERING = 3,
-} Exp_Metering_modes;
-
-typedef enum {
- ISO_AUTO = 1,
- ISO_DEBLUR = 2,
- ISO_100 = 3,
- ISO_200 = 4,
- ISO_400 = 5,
- ISO_800 = 6,
- ISO_1600 = 7,
-} ISO_modes;
-
-typedef enum
-{
- MENU_ID_MAIN,
- MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE,
- MENU_ID_WHITEBALANCECHANGE,
- MENU_ID_EXPMETERINGCHANGE,
- MENU_ID_GET_CTRL_VALUE,
- MENU_ID_TOGGLEAFR,
- MENU_ID_ISOCHANGE,
- MENU_ID_BRIGHTNESSCHANGE,
- MENU_ID_CONTRASTCHANGE,
- MENU_ID_EVCHANGE,
- MENU_ID_SATURATIONCHANGE,
- MENU_ID_ZOOMCHANGE,
- MENU_ID_SHARPNESSCHANGE,
- MENU_ID_SWITCHCAMERA,
- MENU_ID_RECORD,
- MENU_ID_INVALID,
-} menu_id_change_t;
-
-typedef enum
-{
- INCREASE_ZOOM = 1,
- DECREASE_ZOOM = 2,
- INCREASE_STEP_ZOOM = 3,
- DECREASE_STEP_ZOOM = 4,
-} Camera_Zoom;
-
-typedef enum
-{
- INC_CONTRAST = 1,
- DEC_CONTRAST = 2,
-} Camera_Contrast_changes;
-
-typedef enum
-{
- INC_BRIGHTNESS = 1,
- DEC_BRIGHTNESS = 2,
-} Camera_Brightness_changes;
-
-typedef enum
-{
- INCREASE_EV = 1,
- DECREASE_EV = 2,
-} Camera_EV_changes;
-
-typedef enum {
- INC_SATURATION = 1,
- DEC_SATURATION = 2,
-} Camera_Saturation_changes;
-
-typedef enum
-{
- INC_ISO = 1,
- DEC_ISO = 2,
-} Camera_ISO_changes;
-
-typedef enum
-{
- INC_SHARPNESS = 1,
- DEC_SHARPNESS = 2,
-} Camera_Sharpness_changes;
-
-typedef enum {
- ZOOM_IN = 1,
- ZOOM_OUT = 2,
-} Zoom_direction;
-
-typedef enum
-{
- LIVE_SNAPSHOT_MENU = 1,
- STOP_RECORDING_MENU = 2,
-} Record_changes;
-
-typedef struct{
- Camera_main_menu_t main_menu;
- char * menu_name;
-} CAMERA_MAIN_MENU_TBL_T;
-
-typedef struct{
- Camera_Resolution cs_id;
- uint16_t width;
- uint16_t height;
- char * name;
- char * str_name;
-} PREVIEW_DIMENSION_TBL_T;
-
-typedef struct {
- config3a_wb_t wb_id;
- char * wb_name;
-} WHITE_BALANCE_TBL_T;
-
-typedef struct {
- int cam_id;
- char * cam_name;
-} CAMERA_TBL_T;
-
-typedef struct {
- int act_id;
- char * act_name;
-} RECORD_TBL_T;
-
-typedef struct {
- Get_Ctrl_modes get_ctrl_id;
- char * get_ctrl_name;
-} GET_CTRL_TBL_T;
-
-typedef struct{
- Exp_Metering_modes exp_metering_id;
- char * exp_metering_name;
-} EXP_METERING_TBL_T;
-
-typedef struct {
- ISO_modes iso_modes;
- char *iso_modes_name;
-} ISO_TBL_T;
-
-typedef struct {
- Zoom_direction zoom_direction;
- char * zoom_direction_name;
-} ZOOM_TBL_T;
-
-typedef struct {
- Camera_Sharpness_changes sharpness_change;
- char *sharpness_change_name;
-} SHARPNESS_TBL_T;
-
-typedef struct {
- Camera_Brightness_changes bc_id;
- char * brightness_name;
-} CAMERA_BRIGHTNESS_TBL_T;
-
-typedef struct {
- Camera_Contrast_changes cc_id;
- char * contrast_name;
-} CAMERA_CONTRST_TBL_T;
-
-typedef struct {
- Camera_EV_changes ec_id;
- char * EV_name;
-} CAMERA_EV_TBL_T;
-
-typedef struct {
- Camera_Saturation_changes sc_id;
- char * saturation_name;
-} CAMERA_SATURATION_TBL_T;
-
-typedef struct {
- Camera_Sharpness_changes bc_id;
- char * sharpness_name;
-} CAMERA_SHARPNESS_TBL_T;
-
-
-typedef struct {
- void *frameThread;
- int8_t (*setDimension)(int , void *);
- int8_t (*setDefaultParams)(int );
- int8_t (*registerPreviewBuf)(int , void *, uint32_t, struct msm_frame *, int8_t );
- int8_t (*unregisterPreviewBuf)(int , void *, uint32_t, int , unsigned char *);
- int8_t (*registerVideoBuf)(int , void *, uint32_t, struct msm_frame *, int8_t );
- int8_t (*unregisterVideoBuf)(int , void *, uint32_t, int , unsigned char *);
- int8_t (*startPreview)(int );
- int8_t (*stopPreview)(int );
- int8_t (*startVideo)(int );
- int8_t (*stopVideo)(int );
- int8_t (*startRecording)(int );
- int8_t (*stopRecording)(int );
- int8_t (*startSnapshot)(int );
- int8_t (*startRawSnapshot)(int );
-
- int8_t (*registerSnapshotBuf)(int , void *, int , int ,
- unsigned char *, unsigned char *);
-
- int8_t (*registerRawSnapshotBuf)(int , void *, int , unsigned char *);
-
- int8_t (*unregisterSnapshotBuf)(int , void *, int , int ,
- unsigned char *, unsigned char *);
-
- int8_t (*unregisterRawSnapshotBuf)(int , void *, int , unsigned char *);
- int8_t (*getPicture)(int fd, struct crop_info *cropInfo );
- int8_t (*stopSnapshot)(int );
- int8_t (*jpegEncode)(const char *path, void *, int, int , unsigned char *,
- unsigned char *, void *, camera_encoding_rotate_t rotate);
- int8_t (*setZoom)(int , void *);
- int8_t (*getMaxZoom)(int fd, void *pZm);
- int8_t (*setSpecialEffect)(int, int effect);
- int8_t (*setBrightness)(int, int);
- int8_t (*setContrast)(int, int);
- int8_t (*setSaturation)(int, int);
- int8_t (*setEV)(int , int );
- int8_t (*setAntiBanding)(int , int32_t antibanding);
- int8_t (*setWhiteBalance)(int , int32_t );
- int8_t (*setAecMode)(int , camera_auto_exposure_mode_type );
- int8_t (*setIso)(int , camera_iso_mode_type );
- int8_t (*setSharpness)(int , int );
- int8_t (*setAutoFocus)(int , isp3a_af_mode_t, cam_af_ctrl_t *);
- int8_t (*sethjr) (int fd, int8_t hjr_status);
- int8_t (*setLensShading) (int fd, int8_t rolloff_status);
- int8_t (*setLedMode) (int fd, led_mode_t led_mode);
- int8_t (*getSharpness_AF) (int fd, int32_t *sharpness);
- int8_t (*setMotionIso) (int fd, motion_iso_t motion_iso);
- int8_t (*setHue) (int fd, int32_t hue);
- int8_t (*cancelAF) (int fd);
- int8_t (*getAfStep) (int fd, int32_t *afStep);
- int8_t (*setAfStep) (int fd, int32_t afStep);
- int8_t (*enableAFD) (int fd);
- int8_t (*prepareSnapshot) (int fd);
- int8_t (*setFpsMode) (int fd, fps_mode_t fps_mode);
- int8_t (*setFps) (int fd, uint16_t fps);
- int8_t (*setAFFocusRect) (int fd, cam_af_focusrect_t af_focus_rect);
-} interface_ctrl_t;
-
-int8_t native_interface_init(interface_ctrl_t *intrfcCtrl, int *camfd);
-int8_t v4l2_interface_init(interface_ctrl_t *intrfcCtrl, int *videofd);
-
-int set_zoom (int zoom_action_param);
-int set_hjr (void);
-int LensShading (void);
-int decrease_contrast (void);
-int increase_contrast (void);
-int decrease_saturation (void);
-int increase_saturation (void);
-int decrease_brightness (void);
-int increase_brightness (void);
-int decrease_EV (void);
-int increase_EV (void);
-int set_iso (int iso_action_param);
-int decrease_sharpness (void);
-int increase_sharpness (void);
-int SpecialEffect (void);
-int set_exp_metering (int exp_metering_action_param);
-int LED_mode_change (void);
-int set_sharpness_AF (void);
-int set_auto_focus (void);
-int set_antibanding (void);
-int set_whitebalance (int wb_action_param);
-int print_current_menu ();
-int set_MotionIso (void);
-int start_preview (void);
-int stop_preview (void);
-static int start_video (void);
-static int stop_video (void);
-int start_recording (void);
-int stop_recording (void);
-int snapshot_resolution (int);
-int preview_video_resolution (int);
-int system_init(void);
-int system_destroy(void);
-int toggle_hue(void);
-int cancel_af(void);
-int get_af_step();
-int set_af_step();
-int enable_afd();
-int prepare_snapshot();
-int set_fps_mode(void);
-int get_ctrl_value (int ctrl_value_mode_param);
-int toggle_afr ();
-int take_yuv_snapshot(int cam_id);
-int take_raw_snapshot();
-#endif /* __MM_QCAMERA_MAIN_MENU_H__ */
diff --git a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_unit_test.h b/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_unit_test.h
deleted file mode 100755
index 8e3e0a4..0000000
--- a/camera/QCamera/stack/mm-camera-test/inc/mm_qcamera_unit_test.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#ifndef __MM_QCAMERA_APP_UNIT_TEST_H__
-#define __MM_QCAMERA_APP_UNIT_TEST_H__
-
-#include "camera.h"
-#include "mm_qcamera_main_menu.h"
-#include "mm_camera_interface.h"
-#include "mm_qcamera_app.h"
-
-typedef int (*mm_app_test_t) (mm_camera_app_t *cam_apps);
-typedef struct {
- mm_app_test_t f;
- int r;
-} mm_app_tc_t;
-
-#endif
-
-/* __MM_QCAMERA_APP_UNIT_TEST_H__ */
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_app.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_app.c
deleted file mode 100755
index b90f2b0..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_app.c
+++ /dev/null
@@ -1,621 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <dlfcn.h>
-#include "mm_qcamera_main_menu.h"
-#include "mm_qcamera_app.h"
-
-mm_camera_app_t my_cam_app;
-
-extern uint8_t *mm_camera_do_mmap_ion(int ion_fd, struct ion_allocation_data *alloc,
- struct ion_fd_data *ion_info_fd, int *mapFd);
-extern int mm_camera_do_munmap_ion (int ion_fd, struct ion_fd_data *ion_info_fd,
- void *addr, size_t size);
-
-static pthread_mutex_t app_mutex;
-static int thread_status = 0;
-static pthread_cond_t app_cond_v;
-
-#define MM_QCAMERA_APP_WAIT_TIME 1000000000
-
-int mm_camera_app_timedwait()
-{
- int rc = 0;
- pthread_mutex_lock(&app_mutex);
- if(FALSE == thread_status) {
- struct timespec tw;
- memset(&tw, 0, sizeof tw);
- tw.tv_sec = 0;
- tw.tv_nsec = time(0) + MM_QCAMERA_APP_WAIT_TIME;
-
- //pthread_cond_wait(&app_cond_v, &app_mutex);
- rc = pthread_cond_timedwait(&app_cond_v, &app_mutex,&tw);
- thread_status = FALSE;
- }
- pthread_mutex_unlock(&app_mutex);
- return rc;
-}
-
-int mm_camera_app_wait()
-{
- int rc = 0;
- pthread_mutex_lock(&app_mutex);
- if(FALSE == thread_status){
- pthread_cond_wait(&app_cond_v, &app_mutex);
- thread_status = FALSE;
- }
- pthread_mutex_unlock(&app_mutex);
- return rc;
-}
-
-void mm_camera_app_done()
-{
- pthread_mutex_lock(&app_mutex);
- thread_status = TRUE;
- pthread_cond_signal(&app_cond_v);
- pthread_mutex_unlock(&app_mutex);
-}
-
-
-mm_camera_app_obj_t *mm_app_get_cam_obj(int8_t cam_id)
-{
- mm_camera_app_obj_t *temp = my_cam_app.obj[cam_id];
- return temp;
-}
-
-void mm_app_user_ptr(int use_user_ptr)
-{
- my_cam_app.use_user_ptr = use_user_ptr;
-}
-
-void mm_app_set_dim_def(cam_ctrl_dimension_t *dim)
-{
- dim->display_width = WVGA_WIDTH;
- dim->display_height = WVGA_HEIGHT;
- input_display.user_input_display_width = dim->display_width;
- input_display.user_input_display_height = dim->display_height;
- dim->video_width = WVGA_WIDTH;
- dim->video_width = CEILING32(dim->video_width);
- dim->video_height = WVGA_HEIGHT;
- dim->orig_video_width = dim->video_width;
- dim->orig_video_height = dim->video_height;
- dim->picture_width = MP1_WIDTH;
- dim->picture_height = MP1_HEIGHT;
- dim->orig_picture_dx = dim->picture_width;
- dim->orig_picture_dy = dim->picture_height;
- dim->ui_thumbnail_height = QVGA_HEIGHT;
- dim->ui_thumbnail_width = QVGA_WIDTH;
- dim->thumbnail_height = dim->ui_thumbnail_height;
- dim->thumbnail_width = dim->ui_thumbnail_width;
- dim->orig_picture_width = dim->picture_width;
- dim->orig_picture_height = dim->picture_height;
- dim->orig_thumb_width = dim->thumbnail_width;
- dim->orig_thumb_height = dim->thumbnail_height;
- dim->raw_picture_height = MP1_HEIGHT;
- dim->raw_picture_width = MP1_WIDTH;
- dim->hjr_xtra_buff_for_bayer_filtering;
- dim->prev_format = CAMERA_YUV_420_NV21;
- dim->enc_format = CAMERA_YUV_420_NV12;
- dim->thumb_format = CAMERA_YUV_420_NV21;
- dim->main_img_format = CAMERA_YUV_420_NV21;
- dim->raw_img_format = CAMERA_BAYER_SBGGR10;
- dim->rdi0_format = CAMERA_YUV_422_YUYV;
- dim->prev_padding_format = CAMERA_PAD_TO_4K;
- dim->display_luma_width = dim->display_width;
- dim->display_luma_height = dim->display_height;
- dim->display_chroma_width = dim->display_width;
- dim->display_chroma_height = dim->display_height;
- dim->video_luma_width = dim->orig_video_width;
- dim->video_luma_height = dim->orig_video_height;
- dim->video_chroma_width = dim->orig_video_width;
- dim->video_chroma_height = dim->orig_video_height;
- dim->thumbnail_luma_width = dim->thumbnail_width;
- dim->thumbnail_luma_height = dim->thumbnail_height;
- dim->thumbnail_chroma_width = dim->thumbnail_width;
- dim->thumbnail_chroma_height = dim->thumbnail_height;
- dim->main_img_luma_width = dim->picture_width;
- dim->main_img_luma_height = dim->picture_height;
- dim->main_img_chroma_width = dim->picture_width;
- dim->main_img_chroma_height = dim->picture_height;
-}
-
-int mm_app_load_hal()
-{
- memset(&my_cam_app, 0, sizeof(my_cam_app));
- memset(&my_cam_app.hal_lib, 0, sizeof(hal_interface_lib_t));
-#if defined(_MSM7630_)
- my_cam_app.hal_lib.ptr = dlopen("/usr/lib/hw/camera.msm7630.so", RTLD_LAZY);
-#elif defined(_MSM7627A_)
- my_cam_app.hal_lib.ptr = dlopen("/usr/lib/hw/camera.msm7627A.so", RTLD_LAZY);
-#else
- //my_cam_app.hal_lib.ptr = dlopen("hw/camera.msm8960.so", RTLD_NOW);
- my_cam_app.hal_lib.ptr = dlopen("libmmcamera_interface.so", RTLD_NOW);
- my_cam_app.hal_lib.ptr_jpeg = dlopen("libmmjpeg_interface.so", RTLD_NOW);
-#endif
- if (!my_cam_app.hal_lib.ptr) {
- CDBG_ERROR("%s Error opening HAL library %s\n", __func__, dlerror());
- return -1;
- }
- *(void **)&(my_cam_app.hal_lib.mm_camera_query) =
- dlsym(my_cam_app.hal_lib.ptr,
- "camera_query");
- *(void **)&(my_cam_app.hal_lib.mm_camera_open) =
- dlsym(my_cam_app.hal_lib.ptr,
- "camera_open");
- *(void **)&(my_cam_app.hal_lib.jpeg_open) =
- dlsym(my_cam_app.hal_lib.ptr_jpeg,
- "jpeg_open");
- return 0;
-}
-
-int mm_app_init()
-{
- int rc = MM_CAMERA_OK;
- CDBG("%s:BEGIN\n", __func__);
- my_cam_app.cam_info = (mm_camera_info_t *)my_cam_app.hal_lib.mm_camera_query(&my_cam_app.num_cameras);
- if(my_cam_app.cam_info == NULL) {
- CDBG_ERROR("%s: Failed to query camera\n", __func__);
- rc = -1;
- }
- CDBG("%s:END, num_cameras = %d\n", __func__, my_cam_app.num_cameras);
- return rc;
-}
-
-static void notify_evt_cb(uint32_t camera_handle,
- mm_camera_event_t *evt,void *user_data)
-{
- CDBG("%s:E evt = %d",__func__,evt->event_type);
-
- switch(evt->event_type)
- {
- case MM_CAMERA_EVT_TYPE_CH:
- break;
- case MM_CAMERA_EVT_TYPE_CTRL:
- break;
- case MM_CAMERA_EVT_TYPE_STATS:
- break;
- case MM_CAMERA_EVT_TYPE_INFO:
- break;
- case MM_CAMERA_EVT_TYPE_PRIVATE_EVT:
- CDBG("%s: private evt (%s)", __func__, (char *)evt->e.pri_evt.evt_data);
- break;
- default:
- break;
- }
- CDBG("%s:X",__func__);
-}
-
-int mm_app_open(uint8_t cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = NULL;
- int i;
- mm_camera_event_type_t evt;
-
- pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN\n", __func__);
- if(pme != NULL) {
- CDBG("%s:cam already open.nop\n",__func__);
- goto end;
- }
- my_cam_app.cam_open = cam_id;
- my_cam_app.obj[cam_id] = (mm_camera_app_obj_t *)malloc(sizeof(mm_camera_app_obj_t));
- pme = my_cam_app.obj[cam_id];
-
- pme->mem_cam = (mm_camear_mem_vtbl_t *)malloc(sizeof(mm_camear_mem_vtbl_t));
- memset(pme->mem_cam,0,sizeof(mm_camear_mem_vtbl_t));
- pme->mem_cam->user_data = pme;
-
- pme->cam = my_cam_app.hal_lib.mm_camera_open(cam_id,pme->mem_cam);
- if(pme->cam == NULL) {
- CDBG("%s:dev open error=%d\n", __func__, rc);
- memset(pme,0, sizeof(pme));
- return -1;
- }
- CDBG("Open Camera id = %d handle = %d", cam_id, pme->cam->camera_handle);
-
- pme->cam->ops->sync(pme->cam->camera_handle);
-
- pme->my_id = cam_id;
- pme->open_flag = TRUE;
- mm_app_set_dim_def(&pme->dim);
-
- for (i = 0; i < MM_CAMERA_EVT_TYPE_MAX; i++) {
- evt = (mm_camera_event_type_t) i;
- pme->cam->ops->register_event_notify(pme->cam->camera_handle, notify_evt_cb, pme,evt);
- }
- pme->cam_state = CAMERA_STATE_OPEN;
- pme->cam_mode = CAMERA_MODE;
- pme->fullSizeSnapshot = 0;
-
- pme->ch_id = pme->cam->ops->ch_acquire(pme->cam->camera_handle);
- CDBG("Channel Acquired Successfully %d",pme->ch_id);
-
- memset(&pme->jpeg_ops, 0, sizeof(mm_jpeg_ops_t));
- pme->jpeg_hdl = my_cam_app.hal_lib.jpeg_open(&pme->jpeg_ops);
- if (pme->jpeg_hdl == 0) {
- CDBG_ERROR("%s: jpeg lib open err", __func__);
- rc = -1;
- goto end;
- }
-
- pme->ionfd = open("/dev/ion", O_RDONLY);
- if (pme->ionfd < 0) {
- CDBG_ERROR("Ion dev open failed\n");
- CDBG_ERROR("Error is %s\n", strerror(errno));
- rc = -1;
- }
-
-end:
- CDBG("%s:END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_close(int8_t cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN\n", __func__);
- if(!pme->cam) {
- CDBG("%s:cam already closed. nop\n",__func__);
- goto end;
- }
-
- pme->cam->ops->ch_release(pme->cam->camera_handle,pme->ch_id);
- pme->cam->ops->camera_close(pme->cam->camera_handle);
- pme->open_flag = FALSE;
- pme->cam = NULL;
- pme->my_id = 0;
- free(pme->mem_cam);
- pme->mem_cam = NULL;
- memset(&pme->dim, 0, sizeof(pme->dim));
-
- /* close jpeg client */
- if (pme->jpeg_hdl && pme->jpeg_ops.close) {
- pme->jpeg_ops.close(pme->jpeg_hdl);
- pme->jpeg_hdl = 0;
- }
- close(pme->ionfd);
-
- free(pme);
- pme = NULL;
- my_cam_app.obj[cam_id] = NULL;
-
-end:
- CDBG("%s:END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-void switchRes(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- switch(pme->cam_state) {
- case CAMERA_STATE_RECORD:
- if(MM_CAMERA_OK != stopRecording(cam_id)){
- CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
- return;
- }
- case CAMERA_STATE_PREVIEW:
- if(MM_CAMERA_OK != mm_app_stop_preview(cam_id)){
- CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
- return;
- }
- break;
- case CAMERA_STATE_SNAPSHOT:
- default:
- break;
- }
-}
-void switchCamera(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if(my_cam_app.cam_open == cam_id){
- return;
- }
-
- switch(pme->cam_state) {
- case CAMERA_STATE_RECORD:
- if(MM_CAMERA_OK != stopRecording(cam_id)){
- CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
- return;
- }
- case CAMERA_STATE_PREVIEW:
- if(MM_CAMERA_OK != mm_app_stop_preview(cam_id)){
- CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
- return;
- }
- break;
- case CAMERA_STATE_SNAPSHOT:
- default:
- break;
- }
-
- mm_app_close(my_cam_app.cam_open);
- mm_app_open(cam_id);
-}
-
-int mm_app_set_dim(int8_t cam_id, cam_ctrl_dimension_t *dim)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN\n", __func__);
-
- memcpy(&pme->dim, dim, sizeof(cam_ctrl_dimension_t));
- if(MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
- pme->cam->camera_handle,MM_CAMERA_PARM_DIMENSION, &pme->dim)))
- {
- CDBG_ERROR("%s: set dimension err=%d\n", __func__, rc);
- }
- CDBG("%s:END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_get_dim(int8_t cam_id, cam_ctrl_dimension_t *dim)
-{
- int rc = MM_CAMERA_OK;
-#if 0
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- CDBG("%s:BEGIN\n", __func__);
- if(pme->open_flag != TRUE) {
- CDBG("%s: dev not open yet\n", __func__);
- rc = -MM_CAMERA_E_INVALID_OPERATION;
- goto end;
- }
- /* now we only use the upper portion. TBD: needs to be fixed later */
- //memcpy(&pme->dim, dim, sizeof(cam_ctrl_dimension_t));
- if(MM_CAMERA_OK != (rc = pme->cam->cfg->get_parm(pme->cam,
- MM_CAMERA_PARM_DIMENSION, &pme->dim))) {
- CDBG("%s: set dimension err=%d\n", __func__, rc);
- }
- CDBG("%s: raw_w=%d,raw_h=%d\n",
- __func__, pme->dim.orig_picture_width, pme->dim.orig_picture_height);
- if(dim)
- memcpy(dim, &pme->dim, sizeof(cam_ctrl_dimension_t));
-
-end:
- CDBG("%s:END, rc=%d\n", __func__, rc);
-#endif
- return rc;
-}
-
-void mm_app_close_ch(int cam_id, int ch_type)
-{
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- pme->cam->ops->ch_release(pme->cam->camera_handle,pme->ch_id);
- CDBG("%s:END,cam_id = %d, ch = %d\n", __func__, cam_id, ch_type);
-
-}
-
-int mm_app_unit_test()
-{
- my_cam_app.run_sanity = 1;
- mm_app_unit_test_entry(&my_cam_app);
- return 0;
-}
-
-int mm_app_dual_test()
-{
- my_cam_app.run_sanity = 1;
- mm_app_dual_test_entry(&my_cam_app);
- return 0;
-}
-
-int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,mm_camera_buf_def_t *frame)
-{
- struct ion_flush_data cache_inv_data;
- struct ion_custom_data custom_data;
- mm_camear_app_buf_t* app_bufs = NULL;
- int ion_fd;
- int index = -1;
- int i;
-
- if(frame == NULL) {
- CDBG_ERROR("%s: Invalid input",__func__);
- return -1;
- }
-#ifdef USE_ION
- for (i = 0; i < MM_QCAM_APP_MAX_STREAM_NUM; i++) {
- if (pme->stream[i].id == frame->stream_id) {
- app_bufs = &pme->stream [i].app_bufs;
- break;
- }
- }
- if(app_bufs == NULL) {
- CDBG_ERROR("Failed to match Stream");
- return -1;
- }
- for (i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i++) {
- if (app_bufs->bufs[i].buf_idx == frame->buf_idx) {
- index = i;
- break;
- }
- }
- if(index < 0) {
- CDBG_ERROR("Failed to match Frame");
- return -1;
- }
-
- cache_inv_data.vaddr = app_bufs->bufs[index].buffer;
- cache_inv_data.fd = app_bufs->bufs[index].fd;
- cache_inv_data.handle = app_bufs->ion_info_fd[index].handle;
- cache_inv_data.length = app_bufs->alloc[index].len;
- cache_inv_data.offset = 0;
- custom_data.cmd = ION_IOC_INV_CACHES;
- custom_data.arg = (unsigned long)&cache_inv_data;
- ion_fd = pme->ionfd;
-
- CDBG("addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d",
- cache_inv_data.vaddr,cache_inv_data.fd,cache_inv_data.handle,cache_inv_data.length,ion_fd);
- if(ion_fd > 0) {
- if(ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data) < 0)
- CDBG_ERROR("%s: Cache Invalidate failed\n", __func__);
- else {
- CDBG("%s: Successful cache invalidate\n", __func__);
- }
- }
-#endif
- return MM_CAMERA_OK;
-}
-
-int mm_stream_clear_invalid_cache(mm_camera_app_obj_t *pme,mm_camera_buf_def_t *frame)
-{
-
-#ifdef USE_ION
- int i,index = -1;
- struct ion_flush_data cache_inv_data;
- struct ion_custom_data custom_data;
- mm_camear_app_buf_t* app_bufs = NULL;
- int ion_fd;
-
- if (frame) {
- memset(&cache_inv_data, 0, sizeof(struct ion_flush_data));
-
- for (i = 0; i < MM_QCAM_APP_MAX_STREAM_NUM; i++) {
- if (pme->stream[i].id == frame->stream_id) {
- app_bufs = &pme->stream [i].app_bufs;
- break;
- }
- }
- if(app_bufs == NULL) {
- CDBG_ERROR("Failed to match Stream");
- return -1;
- }
- for (i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i++) {
- if (app_bufs->bufs[i].buf_idx == frame->buf_idx) {
- index = i;
- break;
- }
- }
- if(index < 0) {
- CDBG_ERROR("Failed to match Frame");
- return -1;
- }
-
- cache_inv_data.vaddr = app_bufs->bufs[index].buffer;
- cache_inv_data.fd = app_bufs->bufs[index].fd;
- cache_inv_data.handle = app_bufs->ion_info_fd[index].handle;
- cache_inv_data.length = app_bufs->alloc[index].len;
- cache_inv_data.offset = 0;
- custom_data.cmd = ION_IOC_CLEAN_INV_CACHES;
- custom_data.arg = (unsigned long)&cache_inv_data;
- ion_fd = pme->ionfd;
- if(ion_fd > 0) {
- if(ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data) < 0)
- ALOGE("%s: Cache Invalidate failed\n", __func__);
- else {
- ALOGD("%s: Successful cache invalidate\n", __func__);
- }
- }
- }
-#endif
- return MM_CAMERA_OK;
-}
-
-int mm_stream_alloc_bufs(mm_camera_app_obj_t *pme,
- mm_camear_app_buf_t* app_bufs,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs)
-{
- int i, num_planes;
-
- num_planes = frame_offset_info->num_planes;
- CDBG("%s: num_planes = %d",__func__,num_planes);
-
- app_bufs->num = num_bufs;
- for (i = 0; i < num_bufs ; i++) {
- int j;
- app_bufs->bufs[i].buf_idx = i;
- app_bufs->alloc[i].len = frame_offset_info->frame_len;
- app_bufs->alloc[i].flags = ION_FLAG_CACHED;
- app_bufs->alloc[i].heap_mask =
- (0x1 << CAMERA_ION_HEAP_ID | 0x1 << ION_IOMMU_HEAP_ID);
- app_bufs->alloc[i].align = 4096;
-
- app_bufs->bufs[i].buffer = mm_camera_do_mmap_ion(pme->ionfd,
- &app_bufs->alloc[i],
- &app_bufs->ion_info_fd[i],
- &app_bufs->bufs[i].fd);
- CDBG(" %s : Buffer allocated fd = %d, length = %d",
- __func__,app_bufs->bufs[i].fd,app_bufs->alloc[i].len);
-
- app_bufs->bufs[i].frame_len = app_bufs->alloc[i].len;
- app_bufs->bufs[i].num_planes = num_planes;
-
- /* Plane 0 needs to be set seperately. Set other planes
- * in a loop. */
- app_bufs->bufs[i].planes[0].length = frame_offset_info->mp[0].len;
- app_bufs->bufs[i].planes[0].m.userptr = app_bufs->bufs[i].fd;
- app_bufs->bufs[i].planes[0].data_offset = frame_offset_info->mp[0].offset;
- app_bufs->bufs[i].planes[0].reserved[0] = 0;
- for (j = 1; j < num_planes; j++) {
- app_bufs->bufs[i].planes[j].length = frame_offset_info->mp[j].len;
- app_bufs->bufs[i].planes[j].m.userptr = app_bufs->bufs[i].fd;
- app_bufs->bufs[i].planes[j].data_offset = frame_offset_info->mp[j].offset;
- app_bufs->bufs[i].planes[j].reserved[0] =
- app_bufs->bufs[i].planes[j-1].reserved[0] +
- app_bufs->bufs[i].planes[j-1].length;
- }
- }
- CDBG("%s: X",__func__);
- return MM_CAMERA_OK;
-}
-
-int mm_stream_release_bufs(mm_camera_app_obj_t *pme,
- mm_camear_app_buf_t* app_bufs)
-{
- int i, rc = MM_CAMERA_OK;
-
- CDBG("%s: E",__func__);
-
- for (i = 0; i < app_bufs->num; i++) {
- rc = mm_camera_do_munmap_ion (pme->ionfd,
- &app_bufs->ion_info_fd[i],
- (void *)app_bufs->bufs[i].buffer,
- app_bufs->bufs[i].frame_len);
- }
- memset(app_bufs, 0, sizeof(mm_camear_app_buf_t));
- CDBG("%s: X",__func__);
- return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_display.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_display.c
deleted file mode 100755
index 9c27054..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_display.c
+++ /dev/null
@@ -1,572 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <fcntl.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <sys/ioctl.h>
-struct file;
-struct inode;
-#include <linux/android_pmem.h>
-#include <sys/mman.h>
-#include <errno.h>
-#include <sys/time.h>
-#include <string.h>
-
-#include <inttypes.h>
-#include <linux/msm_mdp.h>
-#include <linux/fb.h>
-#include "camera.h"
-#include "mm_camera_dbg.h"
-
-#ifdef DRAW_RECTANGLES
-extern roi_info_t camframe_roi;
-
-#undef CAM_FRM_DRAW_RECT
-#define CAM_FRM_DRAW_RECT
-#endif
-
-#ifdef CAM_FRM_DRAW_FD_RECT
-#undef CAM_FRM_DRAW_RECT
-#define CAM_FRM_DRAW_RECT
-#endif
-
-struct fb_var_screeninfo vinfo;
-struct fb_fix_screeninfo finfo;
-int fb_fd = 0;
-union {
- char dummy[sizeof(struct mdp_blit_req_list) +
- sizeof(struct mdp_blit_req) * 1];
- struct mdp_blit_req_list list;
-} yuv;
-
-static pthread_t cam_frame_fb_thread_id;
-static int camframe_fb_exit;
-
-static int is_camframe_fb_thread_ready;
-USER_INPUT_DISPLAY_T input_display;
-
-unsigned use_overlay = 0;
-struct msmfb_overlay_data ov_front, ov_back, *ovp_front, *ovp_back;
-struct mdp_overlay overlay, *overlayp;
-int vid_buf_front_id, vid_buf_back_id;
-static unsigned char please_initialize = 1;
-int num_of_ready_frames = 0;
-
-static pthread_cond_t sub_thread_ready_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t sub_thread_ready_mutex = PTHREAD_MUTEX_INITIALIZER;
-pthread_cond_t camframe_fb_cond = PTHREAD_COND_INITIALIZER;
-pthread_mutex_t camframe_fb_mutex = PTHREAD_MUTEX_INITIALIZER;
-static void notify_camframe_fb_thread();
-
-void use_overlay_fb_display_driver(void)
-{
- use_overlay = 1;
-}
-
-void overlay_set_params(struct mdp_blit_req *e)
-{
- int result;
-
- if (please_initialize) {
- overlayp = &overlay;
- ovp_front = &ov_front;
- ovp_back = &ov_back;
-
- overlayp->id = MSMFB_NEW_REQUEST;
- }
-
- overlayp->src.width = e->src.width;
- overlayp->src.height = e->src.height;
- overlayp->src.format = e->src.format;
-
- overlayp->src_rect.x = e->src_rect.x;
- overlayp->src_rect.y = e->src_rect.y;
- overlayp->src_rect.w = e->src_rect.w;
- overlayp->src_rect.h = e->src_rect.h;
-
- overlayp->dst_rect.x = e->dst_rect.x;
- overlayp->dst_rect.y = e->dst_rect.y;
- /* ROTATOR is enabled in overlay library, swap dimensions
- here to take care of that */
- overlayp->dst_rect.w = e->dst_rect.h;
- overlayp->dst_rect.h = e->dst_rect.w;
-
- if (overlayp->dst_rect.w > 480)
- overlayp->dst_rect.w = 480;
- if (overlayp->dst_rect.h > 800)
- overlayp->dst_rect.h = 800;
-
- overlayp->z_order = 0; // FB_OVERLAY_VID_0;
- overlayp->alpha = e->alpha;
- overlayp->transp_mask = 0; /* 0xF81F */
- overlayp->flags = e->flags;
- overlayp->is_fg = 1;
-
- if (please_initialize) {
- CDBG("src.width %d height %d; src_rect.x %d y %d w %d h %d; dst_rect.x %d y %d w %d h %d\n",
- overlayp->src.width, overlayp->src.height,
- overlayp->src_rect.x, overlayp->src_rect.y, overlayp->src_rect.w, overlayp->src_rect.h,
- overlayp->dst_rect.x, overlayp->dst_rect.y, overlayp->dst_rect.w, overlayp->dst_rect.h
- );
-
- result = ioctl(fb_fd, MSMFB_OVERLAY_SET, overlayp);
- if (result < 0) {
- CDBG("ERROR: MSMFB_OVERLAY_SET failed!, result =%d\n", result);
- }
- }
-
- if (please_initialize) {
- vid_buf_front_id = overlayp->id; /* keep return id */
-
- ov_front.id = overlayp->id;
- ov_back.id = overlayp->id;
- please_initialize = 0;
- }
-
- return;
-}
-
-void overlay_set_frame(struct msm_frame *frame)
-{
- ov_front.data.offset = 0;
- ov_front.data.memory_id = frame->fd;
- return;
-}
-
-/*===========================================================================
- * FUNCTION test_app_camframe_callback
- * DESCRIPTION display frame
- *==========================================================================*/
-void test_app_camframe_callback(struct msm_frame *frame)
-{
- int result = 0;
- struct mdp_blit_req *e;
- struct timeval td1, td2;
- struct timezone tz;
-
- common_crop_t *crop = (common_crop_t *) (frame->cropinfo);
-
- /* Initialize yuv structure */
- yuv.list.count = 1;
-
- e = &yuv.list.req[0];
-
- e->src.width = input_display.user_input_display_width;
- e->src.height = input_display.user_input_display_height;
- e->src.format = MDP_Y_CRCB_H2V2;
- e->src.offset = 0;
- e->src.memory_id = frame->fd;
-
- e->dst.width = vinfo.xres;
- e->dst.height = vinfo.yres;
- e->dst.format = MDP_RGB_565;
- e->dst.offset = 0;
- e->dst.memory_id = fb_fd;
-
- e->transp_mask = 0xffffffff;
- e->flags = 0;
- e->alpha = 0xff;
-
- /* Starting doing MDP Cropping */
- if (frame->path == OUTPUT_TYPE_P) {
-
- if (crop->in2_w != 0 || crop->in2_h != 0) {
-
- e->src_rect.x = (crop->out2_w - crop->in2_w + 1) / 2 - 1;
-
- e->src_rect.y = (crop->out2_h - crop->in2_h + 1) / 2 - 1;
-
- e->src_rect.w = crop->in2_w;
- e->src_rect.h = crop->in2_h;
-
- CDBG("e->src_rect.x = %d\n", e->src_rect.x);
- CDBG("e->src_rect.y = %d\n", e->src_rect.y);
- CDBG("e->src_rect.w = %d\n", e->src_rect.w);
- CDBG("e->src_rect.h = %d\n", e->src_rect.h);
-
- e->dst_rect.x = 0;
- e->dst_rect.y = 0;
- e->dst_rect.w = input_display.user_input_display_width;
- e->dst_rect.h = input_display.user_input_display_height;
- } else {
- e->src_rect.x = 0;
- e->src_rect.y = 0;
- e->src_rect.w = input_display.user_input_display_width;
- e->src_rect.h = input_display.user_input_display_height;
-
- e->dst_rect.x = 0;
- e->dst_rect.y = 0;
- e->dst_rect.w = input_display.user_input_display_width;
- e->dst_rect.h = input_display.user_input_display_height;
- }
- if (use_overlay) overlay_set_params(e);
- } else {
-
- }
-
- gettimeofday(&td1, &tz);
-
- if (use_overlay) overlay_set_frame(frame);
- else {
- result = ioctl(fb_fd, MSMFB_BLIT, &yuv.list);
- if (result < 0) {
- CDBG("MSM_FBIOBLT failed! line=%d\n", __LINE__);
- }
- }
-
- gettimeofday(&td2, &tz);
- CDBG("Profiling: MSMFB_BLIT takes %ld microseconds\n",
- ((td2.tv_sec - td1.tv_sec) * 1000000 + (td2.tv_usec - td1.tv_usec)));
-
- td1 = td2;
- notify_camframe_fb_thread();
- /* add frame back to the free queue*/
- //camframe_add_frame(CAM_PREVIEW_FRAME, frame);
-}
-
-void notify_camframe_fb_thread()
-{
- pthread_mutex_lock(&camframe_fb_mutex);
-
- num_of_ready_frames ++;
- pthread_cond_signal(&camframe_fb_cond);
-
- pthread_mutex_unlock(&camframe_fb_mutex);
-}
-
-void camframe_fb_thread_ready_signal(void);
-
-void *camframe_fb_thread(void *data)
-{
- int result = 0;
- static struct timeval td1, td2;
- struct timezone tz;
-
-#ifdef _ANDROID_
- fb_fd = open(ANDROID_FB0, O_RDWR);
- CDBG("%s:android dl '%s', fd=%d\n", __func__, ANDROID_FB0, fb_fd);
-#else
- fb_fd = open(LE_FB0, O_RDWR);
- CDBG("%s:LE_FB0 dl, '%s', fd=%d\n", __func__, LE_FB0, fb_fd);
-#endif
- if (fb_fd < 0) {
- CDBG_ERROR("cannot open framebuffer %s or %s file node\n",
- ANDROID_FB0, LE_FB0);
- goto fail1;
- }
-
- if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo) < 0) {
- CDBG_ERROR("cannot retrieve vscreenInfo!\n");
- goto fail;
- }
-
- if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo) < 0) {
- CDBG_ERROR("can't retrieve fscreenInfo!\n");
- goto fail;
- }
-
- vinfo.activate = FB_ACTIVATE_VBL;
-
- camframe_fb_thread_ready_signal();
-
- pthread_mutex_lock(&camframe_fb_mutex);
- while (!camframe_fb_exit) {
- CDBG("cam_frame_fb_thread: num_of_ready_frames: %d\n", num_of_ready_frames);
- if (num_of_ready_frames <= 0) {
- pthread_cond_wait(&camframe_fb_cond, &camframe_fb_mutex);
- }
- if (num_of_ready_frames > 0) {
- num_of_ready_frames --;
-
- gettimeofday(&td1, &tz);
- if (use_overlay) {
- result = ioctl(fb_fd, MSMFB_OVERLAY_PLAY, ovp_front);
- } else {
- result = ioctl(fb_fd, FBIOPAN_DISPLAY, &vinfo);
- }
-
- gettimeofday(&td2, &tz);
-
- CDBG("Profiling: frame timestamp after FBIO display = %ld ms\n",
- (td2.tv_sec*1000) + (td2.tv_usec/1000));
-
- CDBG("cam_frame_fb_thread: elapse time for FBIOPAN_DISPLAY = %ld, return = %d\n",
- (td2.tv_sec - td1.tv_sec) * 1000000 + td2.tv_usec - td1.tv_usec, result);
-
- if (result < 0) {
- CDBG("DISPLAY: Failed\n");
- }
- }
- }
-
- pthread_mutex_unlock(&camframe_fb_mutex);
-
- if (use_overlay) {
- if (ioctl(fb_fd, MSMFB_OVERLAY_UNSET, &vid_buf_front_id)) {
- CDBG("\nERROR! MSMFB_OVERLAY_UNSET failed! (Line %d)\n", __LINE__);
- goto fail;
- }
- }
-
- return NULL;
-
- fail:
- close(fb_fd);
- fail1:
- camframe_fb_exit = -1;
- camframe_fb_thread_ready_signal();
- return NULL;
-}
-
-int launch_camframe_fb_thread(void)
-{
-
- camframe_fb_exit = 0;
- is_camframe_fb_thread_ready = 0;
- pthread_create(&cam_frame_fb_thread_id, NULL, camframe_fb_thread, NULL);
-
- /* Waiting for launching sub thread ready signal. */
- CDBG("launch_camframe_fb_thread(), call pthread_cond_wait\n");
-
- pthread_mutex_lock(&sub_thread_ready_mutex);
- if (!is_camframe_fb_thread_ready) {
- pthread_cond_wait(&sub_thread_ready_cond, &sub_thread_ready_mutex);
- }
- pthread_mutex_unlock(&sub_thread_ready_mutex);
-
- CDBG("launch_camframe_fb_thread(), call pthread_cond_wait done\n");
- CDBG("%s:fb rc=%d\n", __func__, camframe_fb_exit);
- return camframe_fb_exit;
-}
-
-void release_camframe_fb_thread(void)
-{
- camframe_fb_exit = 1;
- please_initialize = 1;
-
- /* Notify the camframe fb thread to wake up */
- if (cam_frame_fb_thread_id != 0) {
- pthread_mutex_lock(&camframe_fb_mutex);
- pthread_cond_signal(&camframe_fb_cond);
- pthread_mutex_unlock(&camframe_fb_mutex);
- if (pthread_join(cam_frame_fb_thread_id, NULL) != 0) {
- CDBG("cam_frame_fb_thread exit failure!\n");
- }
- close(fb_fd);
- }
-}
-
-void camframe_fb_thread_ready_signal(void)
-{
- /* Send the signal to control thread to indicate that the cam frame fb
- * ready.
- */
- CDBG("cam_frame_fb_thread() is ready, call pthread_cond_signal\n");
-
- pthread_mutex_lock(&sub_thread_ready_mutex);
- is_camframe_fb_thread_ready = 1;
- pthread_cond_signal(&sub_thread_ready_cond);
- pthread_mutex_unlock(&sub_thread_ready_mutex);
-
- CDBG("cam_frame_fb_thread() is ready, call pthread_cond_signal done\n");
-}
-
-#ifdef CAM_FRM_DRAW_RECT
-void draw_rect(char *buf, int buf_w,
- int x, int y, int dx, int dy)
-{
- int i;
- int left = x;
- int right = x+dx;
- int top = y;
- int bottom = y+dy;
-
- for (i = left; i < right; i++) {
- buf[top*buf_w+i] = 0xff;
- buf[bottom*buf_w+i] = 0xff;
- }
- for (i = top; i < bottom; i++) {
- buf[i*buf_w+left] = 0xff;
- buf[i*buf_w+right] = 0xff;
- }
-}
-#endif
-
-void draw_rectangles(struct msm_frame* newFrame)
-{
- struct fd_roi_t *p_fd_roi;
-#ifdef DRAW_RECTANGLES
- uint8_t i;
- for (i = 0; i < camframe_roi.num_roi; i++) {
- CDBG("%s: camframe_roi: i=%d, x=%d, y=%d, dx=%d, dy=%d\n", __func__,
- i, camframe_roi.roi[i].x, camframe_roi.roi[i].y,
- camframe_roi.roi[i].dx, camframe_roi.roi[i].dy);
- draw_rect((char*)newFrame->buffer, 640,
- camframe_roi.roi[i].x, camframe_roi.roi[i].y,
- camframe_roi.roi[i].dx, camframe_roi.roi[i].dy);
- }
-#endif
-
-#ifdef CAM_FRM_DRAW_FD_RECT
- p_fd_roi = (struct fd_roi_t *)newFrame->roi_info.info;
- if(p_fd_roi && p_fd_roi->rect_num > 0){
- int i;
- for(i =0; i < p_fd_roi->rect_num; i++)
- {
- draw_rect((char*)newFrame->buffer, 800,
- p_fd_roi->faces[i].x, p_fd_roi->faces[i].y,
- p_fd_roi->faces[i].dx, p_fd_roi->faces[i].dy);
- }
- }
-#endif
-}
-
-/*===========================================================================
- * FUNCTION - v4l2_render -
- *
- * DESCRIPTION:
- *==========================================================================*/
-int v4l2_render(int frame_fd, struct v4l2_buffer *vb, struct v4l2_crop *crop)
-{
- struct mdp_blit_req *e;
- /* Initialize yuv structure */
- yuv.list.count = 1;
- e = &yuv.list.req[0];
-
- e->src.width = input_display.user_input_display_width;
- e->src.height = input_display.user_input_display_height;
- e->src.format = MDP_Y_CBCR_H2V2;
- e->src.offset = 0;
- e->src.memory_id = frame_fd;
-
- e->dst.width = vinfo.xres;
- e->dst.height = vinfo.yres;
- e->dst.format = MDP_RGB_565;
- e->dst.offset = 0;
- e->dst.memory_id = fb_fd;
-
- e->transp_mask = 0xffffffff;
- e->flags = 0;
- e->alpha = 0xff;
-
- if (crop != NULL && (crop->c.width != 0 || crop->c.height != 0)) {
- e->src_rect.x = crop->c.left;
- e->src_rect.y = crop->c.top;
- e->src_rect.w = crop->c.width;
- e->src_rect.h = crop->c.height;
-
- e->dst_rect.x = 0;
- e->dst_rect.y = 0;
- e->dst_rect.w = input_display.user_input_display_width;
- e->dst_rect.h = input_display.user_input_display_height;
- } else {
- e->dst_rect.x = 0;
- e->dst_rect.y = 0;
- e->dst_rect.w = input_display.user_input_display_width;
- e->dst_rect.h = input_display.user_input_display_height;
-
- e->src_rect.x = 0;
- e->src_rect.y = 0;
- e->src_rect.w = input_display.user_input_display_width;
- e->src_rect.h = input_display.user_input_display_height;
- }
- overlay_set_params(e);
- ov_front.data.offset = 0;
- ov_front.data.memory_id = frame_fd;
- notify_camframe_fb_thread();
-
- return TRUE;
-}
-
-int mm_app_dl_render(int frame_fd, struct crop_info * cropinfo)
-{
- struct mdp_blit_req *e;
- int croplen = 0;
- //struct crop_info *cropinfo;
- common_crop_t *crop;
-
- //cropinfo = (struct crop_info *)vb->input;
- if(cropinfo != NULL) {
- crop = (common_crop_t *)cropinfo->info;
- }
- /* Initialize yuv structure */
- yuv.list.count = 1;
- e = &yuv.list.req[0];
-
- e->src.width = input_display.user_input_display_width;
- e->src.height = input_display.user_input_display_height;
- e->src.format = MDP_Y_CRCB_H2V2;
- e->src.offset = 0;
- e->src.memory_id = frame_fd;
-
- e->dst.width = vinfo.xres;
- e->dst.height = vinfo.yres;
- e->dst.format = MDP_RGB_565;
- e->dst.offset = 0;
- e->dst.memory_id = fb_fd;
-
- e->transp_mask = 0xffffffff;
- e->flags = 0;
- e->alpha = 0xff;
-
- if (cropinfo != NULL && (crop->in2_w != 0 || crop->in2_h != 0)) {
- e->src_rect.x = (crop->out2_w - crop->in2_w + 1) / 2 - 1;
- e->src_rect.y = (crop->out2_h - crop->in2_h + 1) / 2 - 1;
- e->src_rect.w = crop->in2_w;
- e->src_rect.h = crop->in2_h;
-
- e->dst_rect.x = 0;
- e->dst_rect.y = 0;
- e->dst_rect.w = input_display.user_input_display_width;
- e->dst_rect.h = input_display.user_input_display_height;
- } else {
- e->dst_rect.x = 0;
- e->dst_rect.y = 0;
- e->dst_rect.w = input_display.user_input_display_width;
- e->dst_rect.h = input_display.user_input_display_height;
-
- e->src_rect.x = 0;
- e->src_rect.y = 0;
- e->src_rect.w = input_display.user_input_display_width;
- e->src_rect.h = input_display.user_input_display_height;
- }
-
- overlay_set_params(e);
-
- ov_front.data.offset = 0;
- ov_front.data.memory_id = frame_fd;
- notify_camframe_fb_thread();
-
- return TRUE;
-}
-
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_dual_test.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_dual_test.c
deleted file mode 100755
index 6a3515c..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_dual_test.c
+++ /dev/null
@@ -1,1936 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include "mm_qcamera_unit_test.h"
-
-#define MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP 4
-#define MM_QCAM_APP_TEST_NUM 128
-
-#define MM_QCAMERA_APP_WAIT_TIME 1000000000
-
-extern int system_dimension_set(int cam_id);
-extern int stopPreview(int cam_id);
-extern int takePicture_yuv(int cam_id);
-extern int takePicture_rdi(int cam_id);
-extern int startRdi(int cam_id);
-extern int stopRdi(int cam_id);
-extern int startStats(int cam_id);
-extern int stopStats(int cam_id);
-
-
-/*
-* 1. open back
-* 2. open front
-* 3. start back
-* 4. start front
-* 5. stop back
-* 6. stop front
-* 7. close back
-* 8. close front
-* 9. take picture
-* a. start recording
-* b. stop recording
-* c. take picture rdi
-*/
-static mm_app_tc_t mm_app_tc[MM_QCAM_APP_TEST_NUM];
-static int num_test_cases = 0;
-struct test_case_params {
- uint16_t launch;
- uint16_t preview;
- uint16_t recording;
- uint16_t snapshot;
-};
-
-/* Test case 12436857 :*/
-
-int mm_app_dtc_0(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera 0...\n");
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Rdi for front \n");
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL stop camera Rdi for front \n");
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
-
- CDBG_ERROR("DUAL close front camera\n");
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- sleep(1);
- CDBG_ERROR("DUAL stop camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL close back camera \n");
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case 12436587 :*/
-
-int mm_app_dtc_1(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera 1...\n");
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Rdi for front \n");
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
-
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL end \n");
-
- CDBG_ERROR("DUAL stop camera Preview for front \n");
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL stop camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL close front camera\n");
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL close back camera \n");
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case 12436578 :*/
-
-int mm_app_dtc_2(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera 2...\n");
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Rdi for front \n");
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
-
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL end \n");
-
- CDBG_ERROR("DUAL stop camera Preview for front \n");
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL stop camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL close back camera \n");
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL close front camera\n");
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case 241395768 : 1357 * 3, This is performed three times
-* And for each iteration 9 is performed thrice */
-
-int mm_app_dtc_3(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j,k;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview and snapshot on back Camera and RDI on Front camera 3...\n");
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for front \n");
-
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() frontcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- usleep(10*1000);
-
- for (k = 0; k < MM_QCAMERA_APP_INTERATION ; k++) {
- CDBG_ERROR("DUAL open back camera %d \n",k);
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
-
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- CDBG_ERROR("DUAL take picture for back \n");
- if ( MM_CAMERA_OK != (rc = takePicture_yuv(back_camera))) {
- CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
- break;
- }
- mm_camera_app_wait();
-
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL stop camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG_ERROR("%s: stopPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
-
- CDBG_ERROR("DUAL close back camera\n");
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- usleep(20*1000);
- }
- CDBG_ERROR("DUAL stop camera Preview for Rdi \n");
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG("%s: stopRdi() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL close front camera \n");
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case 2413ab5768 : 1357 * 3, This is performed three times
-* And for each iteration ab is performed thrice */
-
-int mm_app_dtc_4(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j,k;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera 4...\n");
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for front \n");
-
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() frontcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- usleep(20*1000);
-
- for (k = 0; k < MM_QCAMERA_APP_INTERATION ; k++){
- CDBG_ERROR("DUAL open back camera %d \n",k);
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(30*1000);
-
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- CDBG_ERROR("DUAL start camera record for back \n");
- if ( MM_CAMERA_OK != (rc = startRecording(back_camera))) {
- CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
- break;
- }
-
- mm_camera_app_wait();
- usleep(15*1000);
- CDBG_ERROR("DUAL stop camera record for back \n");
- if ( MM_CAMERA_OK != (rc = stopRecording(back_camera))) {
- CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
- break;
- }
- }
- usleep(10*1000);
-
- CDBG_ERROR("DUAL stop camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG_ERROR("%s: stopPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
-
- CDBG_ERROR("DUAL close back camera\n");
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- usleep(20*1000);
- }
- CDBG_ERROR("DUAL stop camera Preview for Rdi \n");
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG("%s: stopRdi() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL close front camera \n");
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case 24135768 : 1357 * 3, This is performed three times*/
-
-int mm_app_dtc_5(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j,k;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera 5...\n");
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for front \n");
-
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() frontcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- for (k = 0; k < 4 ; k++) {
- CDBG_ERROR("DUAL open back camera %d \n",k);
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL stop camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG_ERROR("%s: stopPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
-
- CDBG_ERROR("DUAL close back camera\n");
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- sleep(1);
- }
- CDBG_ERROR("DUAL stop camera Preview for Rdi \n");
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG("%s: stopRdi() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL close front camera \n");
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case 13246857 : 2468 * 3, This is performed three times*/
-
-int mm_app_dtc_6(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j,k;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera 6...\n");
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
-
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- for (k = 0; k < 4 ; k++) {
- CDBG_ERROR("DUAL open front camera %d \n",k);
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Rdi for front \n");
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL stop camera Preview for front \n");
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
-
- CDBG_ERROR("DUAL close front camera\n");
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- sleep(1);
- }
- CDBG_ERROR("DUAL stop camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL close back camera \n");
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/*Multi Threaded Test Cases*/
-static void *front_thread(void *data)
-{
- int front_camera = 1;
- int rc = MM_CAMERA_OK;
- int i,j,k,m;
- struct test_case_params params
- = *((struct test_case_params *)data);
- for (i = 0; i < params.launch; i++) {
- CDBG_ERROR("DUAL open front camera %d\n",i);
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- for (j = 0; j < params.preview; j++) {
- CDBG_ERROR("DUAL start camera Rdi for front %d ,%d \n",i,j);
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- usleep(20*1000);
- for (k = 0; k < params.snapshot; k++) {
- CDBG_ERROR("DUAL take picture for front %d,%d,%d \n",i,j,k);
- if ( MM_CAMERA_OK != (rc = takePicture_rdi(front_camera))) {
- CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- usleep(30*1000);
- }
- CDBG_ERROR("DUAL stop camera Rdi for front %d,%d\n",i,j);
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- }
-
- CDBG_ERROR("DUAL close front camera %d\n",i);
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- }
-end:
- CDBG_ERROR("DUAL front thread close %d",rc);
- return NULL;
-}
-
-static void *back_thread(void *data)
-{
- int rc = MM_CAMERA_OK;
- int back_camera = 0;
- int i,j,k,m;
- struct test_case_params params
- = *((struct test_case_params *)data);
- for (i = 0; i < params.launch; i++) {
- CDBG_ERROR("DUAL open back camera %d\n",i);
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- for (j = 0; j < params.preview; j++) {
- CDBG_ERROR("DUAL start camera Preview for back %d, %d\n",i,j);
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- usleep(20*1000);
- for (k = 0; k < params.snapshot; k++) {
- CDBG_ERROR("DUAL take picture for back %d, %d, %d\n",i,j,k);
- if ( MM_CAMERA_OK != (rc = takePicture_yuv(back_camera))) {
- CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- usleep(30*1000);
- }
-
- for (m = 0; m < params.recording; m++) {
- CDBG_ERROR("DUAL start record for back %d, %d, %d\n",i,j,m);
- if ( MM_CAMERA_OK != (rc = startRecording(back_camera))) {
- CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
- break;
- }
-
- mm_camera_app_wait();
- usleep(10*1000);
- CDBG_ERROR("DUAL stop camera record for back \n");
- if ( MM_CAMERA_OK != (rc = stopRecording(back_camera))) {
- CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
- break;
- }
- usleep(10*1000);
- }
- CDBG_ERROR("DUAL stop camera Preview for back %d, %d\n",i,j);
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- }
-
- CDBG_ERROR("DUAL close back camera %d\n",i);
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- }
-end:
- CDBG_ERROR("DUAL back thread close %d",rc);
- return NULL;
-}
-
-/* Test case m13572468 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_7(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int result = 0;
- pthread_t back_thread_id, front_thread_id;
- struct test_case_params params;
- memset(¶ms, 0, sizeof(struct test_case_params));
- params.launch = 5;
- params.preview = 5;
- printf("\n Verifying Preview on back Camera and RDI on Front camera 7...\n");
-
- CDBG_ERROR("start back DUAL ");
- rc = pthread_create(&back_thread_id, NULL, back_thread, ¶ms);
- CDBG_ERROR("start front DUAL ");
- rc = pthread_create(&front_thread_id, NULL, front_thread, ¶ms);
- sleep(1);
- CDBG_ERROR("stop back DUAL ");
- rc = pthread_join(back_thread_id, NULL);
- CDBG_ERROR("stop front DUAL ");
- rc = pthread_join(front_thread_id, NULL);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case m139572468 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_8(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int result = 0;
-
- pthread_t back_thread_id, front_thread_id;
- struct test_case_params bparams, fparams;
- memset(&bparams, 0, sizeof(struct test_case_params));
- memset(&fparams, 0, sizeof(struct test_case_params));
- bparams.launch = 5;
- bparams.preview = 5;
- bparams.snapshot= 5;
- fparams.launch = 5;
- fparams.preview = 5;
- printf("\n Verifying Preview on back Camera and RDI on Front camera 8...\n");
-
- CDBG_ERROR("start back DUAL ");
- rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
- CDBG_ERROR("start front DUAL ");
- rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
- sleep(1);
- CDBG_ERROR("stop back DUAL ");
- rc = pthread_join(back_thread_id, NULL);
- CDBG_ERROR("stop front DUAL ");
- rc = pthread_join(front_thread_id, NULL);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0)
- printf("\nPassed\n");
- else
- printf("\nFailed\n");
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case m1395724c68 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_9(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int result = 0;
-
- pthread_t back_thread_id, front_thread_id;
- struct test_case_params bparams, fparams;
- memset(&bparams, 0, sizeof(struct test_case_params));
- memset(&fparams, 0, sizeof(struct test_case_params));
- bparams.launch = 5;
- bparams.preview = 5;
- bparams.snapshot= 5;
- fparams.launch = 5;
- fparams.preview = 5;
- fparams.snapshot = 5;
- printf("\n Verifying Preview on back Camera and RDI on Front camera 9...\n");
-
- CDBG_ERROR("start back DUAL ");
- rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
- CDBG_ERROR("start front DUAL ");
- rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
- sleep(1);
- CDBG_ERROR("stop back DUAL ");
- rc = pthread_join(back_thread_id, NULL);
- CDBG_ERROR("stop front DUAL ");
- rc = pthread_join(front_thread_id, NULL);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case m13ab572468 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_10(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int result = 0;
-
- pthread_t back_thread_id, front_thread_id;
- struct test_case_params bparams, fparams;
- memset(&bparams, 0, sizeof(struct test_case_params));
- memset(&fparams, 0, sizeof(struct test_case_params));
- bparams.launch = 5;
- bparams.preview = 5;
- bparams.recording= 5;
- fparams.launch = 5;
- fparams.preview = 5;
- printf("\n Verifying Preview on back Camera and RDI on Front camera 10...\n");
-
- CDBG_ERROR("start back DUAL ");
- rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
- CDBG_ERROR("start front DUAL ");
- rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
- sleep(1);
- CDBG_ERROR("stop back DUAL ");
- rc = pthread_join(back_thread_id, NULL);
- CDBG_ERROR("stop front DUAL ");
- rc = pthread_join(front_thread_id, NULL);
- CDBG_ERROR("DUAL end \n");
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case m13ab5724c68 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_11(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int result = 0;
-
- pthread_t back_thread_id, front_thread_id;
- struct test_case_params bparams, fparams;
- memset(&bparams, 0, sizeof(struct test_case_params));
- memset(&fparams, 0, sizeof(struct test_case_params));
- bparams.launch = 5;
- bparams.preview = 5;
- bparams.recording= 5;
- fparams.launch = 5;
- fparams.preview = 5;
- fparams.snapshot = 5;
- printf("\n Verifying Preview on back Camera and RDI on Front camera 11...\n");
-
- CDBG_ERROR("start back DUAL ");
- rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
- CDBG_ERROR("start front DUAL ");
- rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
- sleep(1);
- CDBG_ERROR("stop back DUAL ");
- rc = pthread_join(back_thread_id, NULL);
- CDBG_ERROR("stop front DUAL ");
- rc = pthread_join(front_thread_id, NULL);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case m1728 : Open & start in 2 concurrent pthread*/
-int mm_app_dtc_12(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int result = 0;
-
- pthread_t back_thread_id, front_thread_id;
- struct test_case_params bparams, fparams;
- memset(&bparams, 0, sizeof(struct test_case_params));
- memset(&fparams, 0, sizeof(struct test_case_params));
- bparams.launch = 15;
- fparams.launch = 15;
- printf("\n Verifying Preview on back Camera and RDI on Front camera 12...\n");
-
- CDBG_ERROR("start back DUAL ");
- rc = pthread_create(&back_thread_id, NULL, back_thread, &bparams);
- CDBG_ERROR("start front DUAL ");
- rc = pthread_create(&front_thread_id, NULL, front_thread, &fparams);
- sleep(1);
- CDBG_ERROR("stop back DUAL ");
- rc = pthread_join(back_thread_id, NULL);
- CDBG_ERROR("stop front DUAL ");
- rc = pthread_join(front_thread_id, NULL);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* Test case 2413(ab)5768
- * Test the dual camera usecase. We startPreview on front camera,
- * but backend will allocate RDI buffers and start front camera in
- * RDI streaming mode. It then diverts RDI frames, converts them into YUV 420
- * through C2D and generate preview data in the buffers allocated here.
- * Back camera will use the pixel interface as usual.
- */
-
-int mm_app_dtc_13(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j,k;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n 13. Verifying Preview + Recording on back Camera and Preview(through RDI) on Front camera\n");
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for front \n");
- if( MM_CAMERA_OK != (rc = startPreview(front_camera))) {
- CDBG_ERROR("%s: front camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- usleep(20*1000);
-
- for (k = 0; k < MM_QCAMERA_APP_INTERATION ; k++){
- CDBG_ERROR("DUAL open back camera %d \n",k);
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- usleep(30*1000);
-
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- CDBG_ERROR("DUAL start camera record for back Iteration %d \n", j);
- if ( MM_CAMERA_OK != (rc = startRecording(back_camera))) {
- CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
- break;
- }
-
- mm_camera_app_wait();
- usleep(10*1000*1000);
- CDBG_ERROR("DUAL stop camera record for back Iteration %d\n", j);
- if ( MM_CAMERA_OK != (rc = stopRecording(back_camera))) {
- CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
- break;
- }
- }
- usleep(10*1000);
-
- CDBG_ERROR("DUAL stop camera Preview for back \n");
- if( MM_CAMERA_OK != (rc = stopPreview(back_camera))) {
- CDBG_ERROR("%s: stopPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
-
- CDBG_ERROR("DUAL close back camera\n");
- if( mm_app_close(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- usleep(20*1000);
- }
- CDBG_ERROR("DUAL stop camera Preview for Rdi \n");
- if( MM_CAMERA_OK != (rc = stopPreview(front_camera))) {
- CDBG_ERROR("%s: stopPreview() frontcamera err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
- CDBG_ERROR("DUAL close front camera \n");
- if( mm_app_close(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/*Below 6 are reference test cases just to test the open path for dual camera*/
-int mm_app_dtc_1243(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Rdi for front \n");
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL start camera Preview for back \n");
-
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_dtc_2134(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera Preview for front \n");
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL start camera Rdi for back \n");
-
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-int mm_app_dtc_2143(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera rdi for front \n");
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL start camera preview for back \n");
-
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_dtc_2413(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera rdi for front \n");
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera preview for back \n");
-
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_dtc_1234(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
- CDBG_ERROR("DUAL open back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL open front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("DUAL start camera preview for back \n");
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
-
- CDBG_ERROR("DUAL start camera rdi for front \n");
-
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_dtc_1324(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
- CDBG_ERROR("DUAL start back camera \n");
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL start camera preview for back \n");
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
- //mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL start front camera \n");
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("DUAL start rdi preview \n");
-
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
- sleep(1);
- CDBG_ERROR("DUAL end \n");
-
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* single camera test cases*/
-int mm_app_dtc_s_0(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if( MM_CAMERA_OK != (rc = startPreview(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
-
- mm_camera_app_wait();
- if(mm_app_open(front_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() front camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(front_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if( MM_CAMERA_OK != (rc = startRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait();
-
- if( MM_CAMERA_OK != (rc = stopRdi(front_camera))) {
- CDBG_ERROR("%s: startPreview() backcamera err=%d\n", __func__, rc);
- goto end;
- }
-
- if( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- goto end;
- }
-
- if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_dtc_s_1(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying Snapshot on front and back camera...\n");
- for(i = 0; i < cam_apps->num_cameras; i++) {
- if( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- for(j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if( MM_CAMERA_OK != (rc = takePicture_yuv(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
- break;
- }
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Snapshot/Preview Callback not received in time or qbuf Faile\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- result++;
- }
- if( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Snapshot Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
-end:
- if(rc == 0) {
- printf("\t***Passed***\n");
- }else{
- printf("\t***Failed***\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_dtc_s_2(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying Video on front and back camera...\n");
- for(i = 0; i < cam_apps->num_cameras; i++) {
- if( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- for(j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if( MM_CAMERA_OK != (rc = startRecording(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
- break;
- }
-
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Video Callback not received in time\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- if( MM_CAMERA_OK != (rc = stopRecording(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
- break;
- }
- result++;
- }
- if( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_dtc_s_3(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying RDI Stream on front and back camera...\n");
- if(cam_apps->num_cameras == 0) {
- CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
- rc = -1;
- goto end;
- }
- for(i = 0; i < cam_apps->num_cameras; i++) {
- if( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- for(j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if( MM_CAMERA_OK != (rc = startRdi(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
- break;
- }
-
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Video Callback not received in time\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- if( MM_CAMERA_OK != (rc = stopRdi(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
- break;
- }
- result++;
- }
- if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/*Stats Test Case*/
-int mm_app_dtc_s_5(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
- int front_camera = 1;
- int back_camera = 0;
-
- printf("\n Verifying Preview on back Camera and RDI on Front camera...\n");
-
- if(mm_app_open(back_camera) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() back camera err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if(system_dimension_set(back_camera) != MM_CAMERA_OK){
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if( MM_CAMERA_OK != (rc = startStats(back_camera))) {
- CDBG_ERROR("%s: back camera startPreview() err=%d\n", __func__, rc);
- goto end;
- }
-
- mm_camera_app_wait();
-
- if( MM_CAMERA_OK != (rc = stopStats(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- goto end;
- }
-
- if( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-end:
- if(rc == 0) {
- printf("\nPassed\n");
- }else{
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_gen_dual_test_cases()
-{
- int tc = 0;
- memset(mm_app_tc, 0, sizeof(mm_app_tc));
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_0;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_1;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_2;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_3;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_4;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_5;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_6;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_7;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_8;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_9;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_10;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_11;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_12;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_dtc_13;
-
- return tc;
-}
-
-int mm_app_dual_test_entry(mm_camera_app_t *cam_app)
-{
- int rc = MM_CAMERA_OK;
- int i, tc = 0;
- int cam_id = 0;
-
- tc = mm_app_gen_dual_test_cases();
- CDBG("Running %d test cases\n",tc);
- for(i = 0; i < tc; i++) {
- mm_app_tc[i].r = mm_app_tc[i].f(cam_app);
- if(mm_app_tc[i].r != MM_CAMERA_OK) {
- printf("%s: test case %d error = %d, abort unit testing engine!!!!\n",
- __func__, i, mm_app_tc[i].r);
- rc = mm_app_tc[i].r;
- goto end;
- }
- }
-end:
- printf("nTOTAL_TSET_CASE = %d, NUM_TEST_RAN = %d, rc=%d\n", tc, i, rc);
- return rc;
-}
-
-
-
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_main_menu.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_main_menu.c
deleted file mode 100755
index 1b26e1a..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_main_menu.c
+++ /dev/null
@@ -1,1931 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <termios.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <signal.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-#include <linux/fb.h>
-#ifdef _ANDROID_
-#include <cutils/log.h>
-#endif
-#include <dlfcn.h>
-
-#include "camera.h"
-#include "mm_camera_dbg.h"
-#include "mm_qcamera_main_menu.h"
-#include "mm_qcamera_display_dimensions.h"
-#include "camera_defs_i.h"
-#include "mm_qcamera_app.h"
-
-#define CAMERA_OPENED 0
-
-#define VIDEO_BUFFER_SIZE (PREVIEW_WIDTH * PREVIEW_HEIGHT * 3/2)
-#define THUMBNAIL_BUFFER_SIZE (THUMBNAIL_WIDTH * THUMBNAIL_HEIGHT * 3/2)
-#define SNAPSHOT_BUFFER_SIZE (PICTURE_WIDTH * PICTURE_HEIGHT * 3/2)
-
-extern int mm_app_take_zsl(int cam_id);
-extern int mm_app_take_live_snapshot(int cam_id);
-extern int stopPreview(int cam_id);
-extern void switchRes(int cam_id);
-extern void switchCamera(int cam_id);
-extern int startRdi(int cam_id);
-extern int stopRdi(int cam_id);
-
-/*===========================================================================
- * Macro
- *===========================================================================*/
-#define PREVIEW_FRAMES_NUM 4
-#define VIDEO_FRAMES_NUM 4
-#define THUMBNAIL_FRAMES_NUM 1
-#define SNAPSHOT_FRAMES_NUM 1
-#define MAX_NUM_FORMAT 32
-/*===========================================================================
- * Defines
- *===========================================================================*/
-
-const CAMERA_MAIN_MENU_TBL_T camera_main_menu_tbl[] = {
- {STOP_CAMERA, "Stop preview/video and exit camera."},
- {PREVIEW_VIDEO_RESOLUTION, "Preview/Video Resolution: SQCIF/QCIF/"
- "QVGA/CIF/VGA/WVGA... Default WVGA."},
- {TAKE_YUV_SNAPSHOT, "Take a snapshot"},
- {TAKE_RAW_SNAPSHOT, "Take a raw snapshot"},
- {TAKE_ZSL_SNAPSHOT, "Take a ZSL snapshot"},
- {START_RECORDING, "Start RECORDING"},
- {START_RDI, "Start RDI stream"},
- {STOP_RDI, "Stop RDI stream"},
- {SWITCH_CAMERA, "Switch Camera"},
-#if 0
- {SET_WHITE_BALANCE, "Set white balance mode: Auto/Off/Daylight/Incandescent/Fluorescent. Default Auto."},
- {SET_EXP_METERING, "Set exposure metering mode: FrameAverage/CenterWeighted/SpotMetering. Default CenterWeighted"},
- {GET_CTRL_VALUE, "Get control value menu"},
- {TOGGLE_AFR, "Toggle auto frame rate. Default fixed frame rate"},
- {SET_ISO, "ISO changes."},
- {BRIGHTNESS_GOTO_SUBMENU, "Brightness changes."},
- {CONTRAST_GOTO_SUBMENU, "Contrast changes."},
- {EV_GOTO_SUBMENU, "EV changes."},
- {SATURATION_GOTO_SUBMENU, "Saturation changes."},
- {SET_ZOOM, "Set Digital Zoom."},
- {SET_SHARPNESS, "Set Sharpness."},
-#endif
-};
-
-const PREVIEW_DIMENSION_TBL_T preview_video_dimension_tbl[] = {
- { SQCIF, SQCIF_WIDTH, SQCIF_HEIGHT, "SQCIF", "Preview/Video Resolution: SQCIF <128x96>"},
- { QCIF, QCIF_WIDTH, QCIF_HEIGHT, "QCIF", "Preview/Video Resolution: QCIF <176x144>"},
- { QVGA, QVGA_WIDTH, QVGA_HEIGHT, "QVGA", "Preview/Video Resolution: QVGA <320x240>"},
- { CIF, CIF_WIDTH, CIF_HEIGHT, "CIF", "Preview/Video Resolution: CIF <352x288>"},
- { VGA, VGA_WIDTH, VGA_HEIGHT, "VGA", "Preview/Video Resolution: VGA <640x480>"},
- { WVGA, WVGA_WIDTH, WVGA_HEIGHT, "WVGA", "Preview/Video Resolution: WVGA <800x480>"},
- { SVGA, SVGA_WIDTH, SVGA_HEIGHT, "SVGA", "Preview/Video Resolution: SVGA <800x600>"},
- { XGA, XGA_WIDTH, XGA_HEIGHT, "XGA", "Preview/Video Resolution: XGA <1024x768>"},
- { HD720, HD720_WIDTH, HD720_HEIGHT, "HD720", "Preview/Video Resolution: HD720 <1280x720>"},
-};
-
-const CAMERA_BRIGHTNESS_TBL_T brightness_change_tbl[] = {
- {INC_BRIGHTNESS, "Increase Brightness by one step."},
- {DEC_BRIGHTNESS, "Decrease Brightness by one step."},
-};
-
-const CAMERA_CONTRST_TBL_T contrast_change_tbl[] = {
- {INC_CONTRAST, "Increase Contrast by one step."},
- {DEC_CONTRAST, "Decrease Contrast by one step."},
-};
-
-const CAMERA_EV_TBL_T camera_EV_tbl[] = {
- {INCREASE_EV, "Increase EV by one step."},
- {DECREASE_EV, "Decrease EV by one step."},
-};
-
-const CAMERA_SATURATION_TBL_T camera_saturation_tbl[] = {
- {INC_SATURATION, "Increase Satuation by one step."},
- {DEC_SATURATION, "Decrease Satuation by one step."},
-};
-
-const CAMERA_SHARPNESS_TBL_T camera_sharpness_tbl[] = {
- {INC_SHARPNESS, "Increase Sharpness."},
- {DEC_SHARPNESS, "Decrease Sharpness."},
-};
-
-const WHITE_BALANCE_TBL_T white_balance_tbl[] = {
- { CAMERA_WB_AUTO, "White Balance - Auto"},
- { CAMERA_WB_DAYLIGHT, "White Balance - Daylight"},
- { CAMERA_WB_INCANDESCENT, "White Balance - Incandescent"},
- { CAMERA_WB_FLUORESCENT, "White Balance - Fluorescent"},
- { CAMERA_WB_CLOUDY_DAYLIGHT, "White Balance - Cloudy"},
-};
-
-const CAMERA_TBL_T cam_tbl[] = {
- { 1, "Back Camera"},
- { 2, "Front Camera"},
-};
-
-const RECORD_TBL_T record_tbl[] = {
- { LIVE_SNAPSHOT_MENU, "Take Live snapshot"},
- { STOP_RECORDING_MENU, "Stop Recording"},
-};
-
-const GET_CTRL_TBL_T get_ctrl_tbl[] = {
- { WHITE_BALANCE_STATE, "Get white balance state (auto/off)"},
- { WHITE_BALANCE_TEMPERATURE, "Get white balance temperature"},
- { BRIGHTNESS_CTRL, "Get brightness value"},
- { EV, "Get exposure value"},
- { CONTRAST_CTRL, "Get contrast value"},
- { SATURATION_CTRL, "Get saturation value"},
- { SHARPNESS_CTRL, "Get sharpness value"},
-};
-
-const EXP_METERING_TBL_T exp_metering_tbl[] = {
- { EXP_METERING_FRAME_AVERAGE, "Exposure Metering - Frame Average"},
- { EXP_METERING_CENTER_WEIGHTED, "Exposure Metering - Center Weighted"},
- { EXP_METERING_SPOT_METERING, "Exposure Metering - Spot Metering"},
-};
-
-const ISO_TBL_T iso_tbl[] = {
- { ISO_AUTO, "ISO: Auto"},
- { ISO_DEBLUR, "ISO: Deblur"},
- { ISO_100, "ISO: 100"},
- { ISO_200, "ISO: 200"},
- { ISO_400, "ISO: 400"},
- { ISO_800, "ISO: 800"},
- { ISO_1600, "ISO: 1600"},
-};
-
-const ZOOM_TBL_T zoom_tbl[] = {
- { ZOOM_IN, "Zoom In one step"},
- { ZOOM_OUT, "Zoom Out one step"},
-};
-
-
-struct v4l2_fmtdesc enumfmtdesc[MAX_NUM_FORMAT];
-struct v4l2_format current_fmt;
-
-/*===========================================================================
- * Forward declarations
- *===========================================================================*/
-static int set_fps(int fps);
-static int start_snapshot (void);
-static int stop_snapshot (void);
-/*===========================================================================
- * Static global variables
- *===========================================================================*/
-USER_INPUT_DISPLAY_T input_display;
-static int camframe_status = 0;
-
-#ifdef _ANDROID_
-char *sdcard_path = "/data";
-#else
-char *sdcard_path = ".";
-#endif
-
-//void *libqcamera = NULL;
-//void (**LINK_jpegfragment_callback)(uint8_t * buff_ptr , uint32_t buff_size);
-//void (**LINK_jpeg_callback)(void);
-
-int num_supported_fmts = 0;
-int memoryType = V4L2_MEMORY_MMAP; /* default */
-int preview_video_resolution_flag = 0;
-int effect = CAMERA_EFFECT_OFF;
-int brightness = CAMERA_DEF_BRIGHTNESS;
-int contrast = CAMERA_DEF_CONTRAST;
-int saturation = CAMERA_DEF_SATURATION;
-int sharpness = CAMERA_DEF_SHARPNESS;
-int32_t ev_num = 0;
-uint8_t ezTune = FALSE;
-int pmemThumbnailfd = 0;
-int pmemSnapshotfd = 0;
-int pmemRawSnapshotfd = 0;
-int fdSnapshot = 0;
-int fdThumbnail = 0;
-char snapshotBuf[256] = { 0};
-char thumbnailBuf[256] = { 0};
-uint32_t snapshot_buff_size = 0;
-uint32_t raw_snapshot_buffer_size = 0;
-static int thumbnailCntr = 0, snapshotCntr = 0;
-unsigned char *thumbnail_buf = NULL, *main_img_buf = NULL, *raw_img_buf = NULL;
-int32_t *sharpness_AF = NULL;
-struct crop_info cropInfo;
-common_crop_t cropInfo_s;
-
-interface_ctrl_t intrfcCtrl;
-config3a_wb_t autoWB = CAMERA_WB_AUTO;
-isp3a_af_mode_t af_mode = AF_MODE_AUTO;
-cam_af_focusrect_t afFocusRect = AUTO;
-
-cam_af_ctrl_t af_ctrl;
-camera_iso_mode_type iso = CAMERA_ISO_AUTO;
-camera_antibanding_type antibanding = CAMERA_ANTIBANDING_OFF;
-camera_auto_exposure_mode_type aec_mode = CAMERA_AEC_CENTER_WEIGHTED;
-led_mode_t led_mode = LED_MODE_OFF;
-motion_iso_t motion_iso = MOTION_ISO_OFF;
-int32_t hue = CAMERA_DEF_HUE;
-fps_mode_t fps_mode = FPS_MODE_AUTO;
-
-struct v4l2_cropcap cropcap;
-struct v4l2_queryctrl zoom_queryctrl;
-struct v4l2_queryctrl sharpness_queryctrl;
-int zoom_level;
-
-Camera_Resolution Resolution;
-//int32_t g_camParmInfo_current_value = 0;
-//extern unsigned long preview_frames_buf;
-//extern void test_app_mmcamera_videoframe_callback(struct msm_frame *frame); // video_cam.c
-
-/* To flush free video buffers queue */
-//void (*LINK_cam_frame_flush_free_video)(void);
-static int submain();
-
-//struct v4l2_frame_buffer frames[PREVIEW_FRAMES_NUM];
-//struct v4l2_frame_buffer video_frames[VIDEO_FRAMES_NUM];
-
-//pthread_t frame_thread;
-
-void test_app_camframe_timeout_callback(void)
-{
- camframe_status = -1;
-}
-
-/*===========================================================================
- * FUNCTION - keypress_to_event -
- *
- * DESCRIPTION:
- *==========================================================================*/
-int keypress_to_event(char keypress)
-{
- char out_buf = INVALID_KEY_PRESS;
- if ((keypress >= 'A' && keypress <= 'Z') ||
- (keypress >= 'a' && keypress <= 'z')) {
- out_buf = tolower(keypress);
- out_buf = out_buf - 'a' + 1;
- } else if (keypress >= '1' && keypress <= '9') {
- out_buf = keypress;
- out_buf = keypress - '1' + BASE_OFFSET_NUM;
- }
- return out_buf;
-}
-
-int next_menu(menu_id_change_t current_menu_id, char keypress, camera_action_t * action_id_ptr, int * action_param)
-{
- int output_to_event;
- menu_id_change_t next_menu_id = MENU_ID_INVALID;
- * action_id_ptr = ACTION_NO_ACTION;
-
- output_to_event = keypress_to_event(keypress);
- CDBG("current_menu_id=%d\n",current_menu_id);
- CDBG("output_to_event=%d\n",output_to_event);
- switch(current_menu_id) {
- case MENU_ID_MAIN:
- switch(output_to_event) {
- case STOP_CAMERA:
- * action_id_ptr = ACTION_STOP_CAMERA;
- CDBG("STOP_CAMERA\n");
- break;
-
- case PREVIEW_VIDEO_RESOLUTION:
- next_menu_id = MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE;
- CDBG("next_menu_id = MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE = %d\n", next_menu_id);
- break;
-#if 0
- case SET_WHITE_BALANCE:
- next_menu_id = MENU_ID_WHITEBALANCECHANGE;
- CDBG("next_menu_id = MENU_ID_WHITEBALANCECHANGE = %d\n", next_menu_id);
- break;
-
- case SET_EXP_METERING:
- next_menu_id = MENU_ID_EXPMETERINGCHANGE;
- CDBG("next_menu_id = MENU_ID_EXPMETERINGCHANGE = %d\n", next_menu_id);
- break;
-
- case GET_CTRL_VALUE:
- next_menu_id = MENU_ID_GET_CTRL_VALUE;
- CDBG("next_menu_id = MENU_ID_GET_CTRL_VALUE = %d\n", next_menu_id);
- break;
-
- case BRIGHTNESS_GOTO_SUBMENU:
- next_menu_id = MENU_ID_BRIGHTNESSCHANGE;
- CDBG("next_menu_id = MENU_ID_BRIGHTNESSCHANGE = %d\n", next_menu_id);
- break;
-
- case CONTRAST_GOTO_SUBMENU:
- next_menu_id = MENU_ID_CONTRASTCHANGE;
- break;
-
- case EV_GOTO_SUBMENU:
- next_menu_id = MENU_ID_EVCHANGE;
- break;
-
- case SATURATION_GOTO_SUBMENU:
- next_menu_id = MENU_ID_SATURATIONCHANGE;
- break;
-
- case TOGGLE_AFR:
- * action_id_ptr = ACTION_TOGGLE_AFR;
- CDBG("next_menu_id = MENU_ID_TOGGLEAFR = %d\n", next_menu_id);
- break;
-
- case SET_ISO:
- next_menu_id = MENU_ID_ISOCHANGE;
- CDBG("next_menu_id = MENU_ID_ISOCHANGE = %d\n", next_menu_id);
- break;
-
- case SET_ZOOM:
- next_menu_id = MENU_ID_ZOOMCHANGE;
- CDBG("next_menu_id = MENU_ID_ZOOMCHANGE = %d\n", next_menu_id);
- break;
-
- case SET_SHARPNESS:
- next_menu_id = MENU_ID_SHARPNESSCHANGE;
- CDBG("next_menu_id = MENU_ID_SHARPNESSCHANGE = %d\n", next_menu_id);
- break;
-#endif
- case TAKE_YUV_SNAPSHOT:
- * action_id_ptr = ACTION_TAKE_YUV_SNAPSHOT;
- CDBG("Taking YUV snapshot\n");
- break;
-
- case TAKE_RAW_SNAPSHOT:
- * action_id_ptr = ACTION_TAKE_RAW_SNAPSHOT;
- CDBG("Taking RAW snapshot\n");
- break;
- case START_RECORDING:
- *action_id_ptr = ACTION_START_RECORDING;
- next_menu_id = MENU_ID_RECORD;
- CDBG("Start recording\n");
- break;
- /*case STOP_RECORDING:
- * action_id_ptr = ACTION_STOP_RECORDING;
- CDBG("Stop recording\n");
- break;*/
- case SWITCH_CAMERA:
- next_menu_id = MENU_ID_SWITCHCAMERA;
- CDBG("SWitch Camera\n");
- break;
- case TAKE_ZSL_SNAPSHOT:
- * action_id_ptr = ACTION_TAKE_ZSL_SNAPSHOT;
- CDBG("Taking ZSL snapshot\n");
- break;
- case START_RDI:
- * action_id_ptr = ACTION_START_RDI;
- break;
- case STOP_RDI:
- * action_id_ptr = ACTION_STOP_RDI;
- break;
- default:
- next_menu_id = MENU_ID_MAIN;
- CDBG("next_menu_id = MENU_ID_MAIN = %d\n", next_menu_id);
- break;
- }
- break;
-
- case MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE:
- printf("MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE\n");
- * action_id_ptr = ACTION_PREVIEW_VIDEO_RESOLUTION;
- if (output_to_event > RESOLUTION_PREVIEW_VIDEO_MAX ||
- output_to_event < RESOLUTION_MIN) {
- next_menu_id = current_menu_id;
- }
- else {
- next_menu_id = MENU_ID_MAIN;
- * action_param = output_to_event;
- }
- break;
-
- case MENU_ID_WHITEBALANCECHANGE:
- printf("MENU_ID_WHITEBALANCECHANGE\n");
- * action_id_ptr = ACTION_SET_WHITE_BALANCE;
- if (output_to_event > 0 &&
- output_to_event <= sizeof(white_balance_tbl)/sizeof(white_balance_tbl[0])) {
- next_menu_id = MENU_ID_MAIN;
- * action_param = output_to_event;
- }
- else {
- next_menu_id = current_menu_id;
- }
- break;
-
- case MENU_ID_EXPMETERINGCHANGE:
- printf("MENU_ID_EXPMETERINGCHANGE\n");
- * action_id_ptr = ACTION_SET_EXP_METERING;
- if (output_to_event > 0 &&
- output_to_event <= sizeof(exp_metering_tbl)/sizeof(exp_metering_tbl[0])) {
- next_menu_id = MENU_ID_MAIN;
- * action_param = output_to_event;
- }
- else {
- next_menu_id = current_menu_id;
- }
- break;
-
- case MENU_ID_GET_CTRL_VALUE:
- printf("MENU_ID_GET_CTRL_VALUE\n");
- * action_id_ptr = ACTION_GET_CTRL_VALUE;
- if (output_to_event > 0 &&
- output_to_event <= sizeof(get_ctrl_tbl)/sizeof(get_ctrl_tbl[0])) {
- next_menu_id = MENU_ID_MAIN;
- * action_param = output_to_event;
- }
- else {
- next_menu_id = current_menu_id;
- }
- break;
-
- case MENU_ID_BRIGHTNESSCHANGE:
- switch (output_to_event) {
- case INC_BRIGHTNESS:
- * action_id_ptr = ACTION_BRIGHTNESS_INCREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
-
- case DEC_BRIGHTNESS:
- * action_id_ptr = ACTION_BRIGHTNESS_DECREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
-
- default:
- next_menu_id = MENU_ID_BRIGHTNESSCHANGE;
- break;
- }
- break;
-
- case MENU_ID_CONTRASTCHANGE:
- switch (output_to_event) {
- case INC_CONTRAST:
- * action_id_ptr = ACTION_CONTRAST_INCREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
-
- case DEC_CONTRAST:
- * action_id_ptr = ACTION_CONTRAST_DECREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
-
- default:
- next_menu_id = MENU_ID_CONTRASTCHANGE;
- break;
- }
- break;
-
- case MENU_ID_EVCHANGE:
- switch (output_to_event) {
- case INCREASE_EV:
- * action_id_ptr = ACTION_EV_INCREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
-
- case DECREASE_EV:
- * action_id_ptr = ACTION_EV_DECREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
-
- default:
- next_menu_id = MENU_ID_EVCHANGE;
- break;
- }
- break;
-
- case MENU_ID_SATURATIONCHANGE:
- switch (output_to_event) {
- case INC_SATURATION:
- * action_id_ptr = ACTION_SATURATION_INCREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
-
- case DEC_SATURATION:
- * action_id_ptr = ACTION_SATURATION_DECREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
-
- default:
- next_menu_id = MENU_ID_EVCHANGE;
- break;
- }
- break;
-
- case MENU_ID_ISOCHANGE:
- printf("MENU_ID_ISOCHANGE\n");
- * action_id_ptr = ACTION_SET_ISO;
- if (output_to_event > 0 &&
- output_to_event <= sizeof(iso_tbl)/sizeof(iso_tbl[0])) {
- next_menu_id = MENU_ID_MAIN;
- * action_param = output_to_event;
- } else {
- next_menu_id = current_menu_id;
- }
- break;
-
- case MENU_ID_ZOOMCHANGE:
- * action_id_ptr = ACTION_SET_ZOOM;
- if (output_to_event > 0 &&
- output_to_event <= sizeof(zoom_tbl)/sizeof(zoom_tbl[0])) {
- next_menu_id = MENU_ID_MAIN;
- * action_param = output_to_event;
- } else {
- next_menu_id = current_menu_id;
- }
- break;
-
- case MENU_ID_SHARPNESSCHANGE:
- switch (output_to_event) {
- case INC_SHARPNESS:
- * action_id_ptr = ACTION_SHARPNESS_INCREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
- case DEC_SHARPNESS:
- * action_id_ptr = ACTION_SHARPNESS_DECREASE;
- next_menu_id = MENU_ID_MAIN;
- break;
- default:
- next_menu_id = MENU_ID_SHARPNESSCHANGE;
- break;
- }
- break;
- case MENU_ID_SWITCHCAMERA:
- * action_id_ptr = ACTION_SWITCH_CAMERA;
- if (output_to_event >= 0 &&
- output_to_event <= sizeof(cam_tbl)/sizeof(cam_tbl[0])) {
- next_menu_id = MENU_ID_MAIN;
- * action_param = output_to_event;
- } else {
- next_menu_id = current_menu_id;
- }
- break;
- case MENU_ID_RECORD:
- switch (output_to_event) {
- case LIVE_SNAPSHOT_MENU:
- * action_id_ptr = ACTION_TAKE_LIVE_SNAPSHOT;
- next_menu_id = MENU_ID_RECORD;
- break;
-
- default:
- case STOP_RECORDING_MENU:
- * action_id_ptr = ACTION_STOP_RECORDING;
- next_menu_id = MENU_ID_MAIN;
- break;
- }
- default:
- CDBG("menu id is wrong: %d\n", current_menu_id);
- break;
- }
-
- return next_menu_id;
-}
-
-/*===========================================================================
- * FUNCTION - print_menu_preview_video -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-static void print_menu_preview_video(void) {
- unsigned int i;
-
- printf("\n");
- printf("===========================================\n");
- printf(" Camera is in preview/video mode now \n");
- printf("===========================================\n\n");
-
- char menuNum = 'A';
- for (i = 0; i < sizeof(camera_main_menu_tbl)/sizeof(camera_main_menu_tbl[0]); i++) {
- if (i == BASE_OFFSET) {
- menuNum = '1';
- }
-
- printf("%c. %s\n", menuNum, camera_main_menu_tbl[i].menu_name);
- menuNum++;
- }
-
- printf("\nPlease enter your choice: ");
-
- return;
-}
-
-static void camera_preview_video_resolution_change_tbl(void) {
- unsigned int i;
-
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in preview/video resolution mode \n");
- printf("==========================================================\n\n");
-
- char previewVideomenuNum = 'A';
- for (i = 0; i < sizeof(preview_video_dimension_tbl) /
- sizeof(preview_video_dimension_tbl[0]); i++) {
- printf("%c. %s\n", previewVideomenuNum,
- preview_video_dimension_tbl[i].str_name);
- previewVideomenuNum++;
- }
-
- printf("\nPlease enter your choice for Preview/Video Resolution: ");
- return;
-}
-
-static void camera_preview_video_wb_change_tbl(void) {
- unsigned int i;
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in white balance change mode \n");
- printf("==========================================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0 ; i < sizeof(white_balance_tbl) /
- sizeof(white_balance_tbl[0]); i++) {
- //printf("%c. %s\n", submenuNum, white_balance_tbl[i].wb_name);
- submenuNum++;
- }
- printf("\nPlease enter your choice for White Balance modes: ");
- return;
-}
-
-static void camera_preview_video_get_ctrl_value_tbl(void) {
- unsigned int i;
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in get control value mode \n");
- printf("==========================================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0 ; i < sizeof(get_ctrl_tbl) /
- sizeof(get_ctrl_tbl[0]); i++) {
- printf("%c. %s\n", submenuNum, get_ctrl_tbl[i].get_ctrl_name);
- submenuNum++;
- }
- printf("\nPlease enter your choice for control value you want to get: ");
- return;
-}
-
-static void camera_preview_video_exp_metering_change_tbl(void) {
- unsigned int i;
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in exposure metering change mode \n");
- printf("==========================================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0 ; i < sizeof(exp_metering_tbl) /
- sizeof(exp_metering_tbl[0]); i++) {
- printf("%c. %s\n", submenuNum, exp_metering_tbl[i].exp_metering_name);
- submenuNum++;
- }
- printf("\nPlease enter your choice for exposure metering modes: ");
- return;
-}
-
-static void camera_contrast_change_tbl(void) {
- unsigned int i;
-
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in change contrast resolution mode \n");
- printf("==========================================================\n\n");
-
- char contrastmenuNum = 'A';
- for (i = 0; i < sizeof(contrast_change_tbl) /
- sizeof(contrast_change_tbl[0]); i++) {
- printf("%c. %s\n", contrastmenuNum,
- contrast_change_tbl[i].contrast_name);
- contrastmenuNum++;
- }
-
- printf("\nPlease enter your choice for contrast Change: ");
- return;
-}
-
-static void camera_EV_change_tbl(void) {
- unsigned int i;
-
- printf("\n");
- printf("===========================================\n");
- printf(" Camera is in EV change mode now \n");
- printf("===========================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0; i < sizeof(camera_EV_tbl)/sizeof(camera_EV_tbl[0]); i++) {
- printf("%c. %s\n", submenuNum, camera_EV_tbl[i].EV_name);
- submenuNum++;
- }
-
- printf("\nPlease enter your choice for EV changes: ");
- return;
-}
-
-static void camera_preview_video_zoom_change_tbl(void) {
- unsigned int i;
- struct v4l2_control ctrl;
-
- memset(&ctrl, 0, sizeof(ctrl));
- ctrl.id = V4L2_CID_ZOOM_ABSOLUTE;
-#if 0 /* TBD */
- if (ioctl(camfd, VIDIOC_G_CTRL, &ctrl) >= 0) {
- zoom_level = ctrl.value;
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in zoom change mode: %d, [%d..%d] \n",
- ctrl.value, zoom_queryctrl.minimum, zoom_queryctrl.maximum);
- printf("==========================================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0 ; i < sizeof(zoom_tbl) /
- sizeof(zoom_tbl[0]); i++) {
- printf("%c. %s\n", submenuNum, zoom_tbl[i].zoom_direction_name);
- submenuNum++;
- }
- printf("\nPlease enter your choice for zoom change direction: ");
- } else {
- printf("\nVIDIOC_G_CTRL error: %d\n", errno);
- }
-#endif /* TBD */
- return;
-}
-
-static void camera_brightness_change_tbl(void) {
- unsigned int i;
-
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in change brightness mode \n");
- printf("==========================================================\n\n");
-
- char brightnessmenuNum = 'A';
- for (i = 0; i < sizeof(brightness_change_tbl) /
- sizeof(brightness_change_tbl[0]); i++) {
- printf("%c. %s\n", brightnessmenuNum,
- brightness_change_tbl[i].brightness_name);
- brightnessmenuNum++;
- }
-
- printf("\nPlease enter your choice for Brightness Change: ");
- return;
-}
-
-static void camera_saturation_change_tbl(void) {
- unsigned int i;
-
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in change saturation mode \n");
- printf("==========================================================\n\n");
-
- char saturationmenuNum = 'A';
- for (i = 0; i < sizeof(camera_saturation_tbl) /
- sizeof(camera_saturation_tbl[0]); i++) {
- printf("%c. %s\n", saturationmenuNum,
- camera_saturation_tbl[i].saturation_name);
- saturationmenuNum++;
- }
-
- printf("\nPlease enter your choice for Saturation Change: ");
- return;
-}
-
-char * set_preview_video_dimension_tbl(Camera_Resolution cs_id, uint16_t * width, uint16_t * height)
-{
- unsigned int i;
- char * ptr = NULL;
- for (i = 0; i < sizeof(preview_video_dimension_tbl) /
- sizeof(preview_video_dimension_tbl[0]); i++) {
- if (cs_id == preview_video_dimension_tbl[i].cs_id) {
- *width = preview_video_dimension_tbl[i].width;
- *height = preview_video_dimension_tbl[i].height;
- ptr = preview_video_dimension_tbl[i].name;
- break;
- }
- }
- return ptr;
-}
-
-static void camera_preview_video_iso_change_tbl(void) {
- unsigned int i;
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in ISO change mode \n");
- printf("==========================================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0 ; i < sizeof(iso_tbl) /
- sizeof(iso_tbl[0]); i++) {
- printf("%c. %s\n", submenuNum, iso_tbl[i].iso_modes_name);
- submenuNum++;
- }
- printf("\nPlease enter your choice for iso modes: ");
- return;
-}
-
-static void camera_preview_video_sharpness_change_tbl(void) {
- unsigned int i;
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in sharpness change mode \n");
- printf("==========================================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0 ; i < sizeof(camera_sharpness_tbl) /
- sizeof(camera_sharpness_tbl[0]); i++) {
- printf("%c. %s\n", submenuNum, camera_sharpness_tbl[i].sharpness_name);
- submenuNum++;
- }
- printf("\nPlease enter your choice for sharpness modes: ");
- return;
-}
-
-static void camera_record_tbl(void) {
- unsigned int i;
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in record mode \n");
- printf("==========================================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0 ; i < sizeof(record_tbl) /
- sizeof(record_tbl[0]); i++) {
- printf("%c. %s\n", submenuNum, record_tbl[i].act_name);
- submenuNum++;
- }
- printf("\nPlease enter your choice: ");
- return;
-}
-
-static void camera_switch_tbl(void) {
- unsigned int i;
- printf("\n");
- printf("==========================================================\n");
- printf(" Camera is in switch camera mode \n");
- printf("==========================================================\n\n");
-
- char submenuNum = 'A';
- for (i = 0 ; i < sizeof(cam_tbl) /
- sizeof(cam_tbl[0]); i++) {
- printf("%c. %s\n", submenuNum, cam_tbl[i].cam_name);
- submenuNum++;
- }
- printf("\nPlease enter your choice for camera modes: ");
- return;
-}
-/*===========================================================================
- * FUNCTION - increase_contrast -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_contrast (void) {
- ++contrast;
- if (contrast > CAMERA_MAX_CONTRAST) {
- contrast = CAMERA_MAX_CONTRAST;
- printf("Reached max CONTRAST. \n");
- } else
- printf("Increase CONTRAST to %d\n", contrast);
-
- /*intrfcCtrl.setContrast(camfd, contrast);*/
-
- struct v4l2_queryctrl queryctrl;
- struct v4l2_control control;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_CONTRAST;
-#if 0 /* TBD */
- if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
- if (errno != EINVAL) {
- perror ("VIDIOC_QUERYCTRL");
- exit (EXIT_FAILURE);
- } else {
- printf ("V4L2_CID_contrast is not supported\n");
- }
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- printf ("V4L2_CID_contrast is not supported\n");
- } else {
- memset (&control, 0, sizeof (control));
- control.id = V4L2_CID_CONTRAST;
- /* Decreasing the contrast */
- control.value = contrast;
-
- // if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- // perror ("VIDIOC_S_CTRL");
- // return -1;
- // }
- }
-#endif /* TBD */
- return 0;
-}
-
-/*===========================================================================
- * FUNCTION - decrease_contrast -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_contrast (void) {
- --contrast;
- if (contrast < CAMERA_MIN_CONTRAST) {
- contrast = CAMERA_MIN_CONTRAST;
- printf("Reached min CONTRAST. \n");
- } else
- printf("Decrease CONTRAST to %d\n", contrast);
-
- /*intrfcCtrl.setContrast(camfd, contrast);*/
- struct v4l2_queryctrl queryctrl;
- struct v4l2_control control;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_CONTRAST;
-#if 0 /* TBD */
- if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
- if (errno != EINVAL) {
- perror ("VIDIOC_QUERYCTRL");
- exit (EXIT_FAILURE);
- } else {
- printf ("V4L2_CID_contrast is not supported\n");
- }
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- printf ("V4L2_CID_contrast is not supported\n");
- } else {
- memset (&control, 0, sizeof (control));
- control.id = V4L2_CID_CONTRAST;
- /* Decreasing the contrast */
- control.value = contrast;
-
- // if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- // perror ("VIDIOC_S_CTRL");
- // return -1;
- // }
- }
-#endif /* TBD */
- return 0;
-}
-
-/*===========================================================================
- * FUNCTION - decrease_brightness -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_brightness (void) {
- brightness -= CAMERA_BRIGHTNESS_STEP;
- if (brightness < CAMERA_MIN_BRIGHTNESS) {
- brightness = CAMERA_MIN_BRIGHTNESS;
- printf("Reached min BRIGHTNESS. \n");
- } else
- printf("Decrease BRIGHTNESS to %d\n", brightness);
-
- struct v4l2_queryctrl queryctrl;
- struct v4l2_control control;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_BRIGHTNESS;
-#if 0 /* TBD */
- if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
- if (errno != EINVAL) {
- perror ("VIDIOC_QUERYCTRL");
- exit (EXIT_FAILURE);
- } else {
- printf ("V4L2_CID_BRIGHTNESS is not supported\n");
- }
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- printf ("V4L2_CID_BRIGHTNESS is not supported\n");
- } else {
- memset (&control, 0, sizeof (control));
- control.id = V4L2_CID_BRIGHTNESS;
- /* Decreasing the Brightness */
- control.value = brightness;
-
- if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- perror ("VIDIOC_S_CTRL");
- return -1;
- }
- }
-#endif /* TBD */
- return 0;
-}
-
-/*===========================================================================
- * FUNCTION - increase_brightness -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_brightness (void) {
- brightness += CAMERA_BRIGHTNESS_STEP;
- if (brightness > CAMERA_MAX_BRIGHTNESS) {
- brightness = CAMERA_MAX_BRIGHTNESS;
- printf("Reached max BRIGHTNESS. \n");
- } else
- printf("Increase BRIGHTNESS to %d\n", brightness);
-
- struct v4l2_queryctrl queryctrl;
- struct v4l2_control control;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_BRIGHTNESS;
-#if 0 /* TBD */
- if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
- if (errno != EINVAL) {
- perror ("VIDIOC_QUERYCTRL");
- exit (EXIT_FAILURE);
- } else {
- printf ("V4L2_CID_BRIGHTNESS is not supported\n");
- }
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- printf ("V4L2_CID_BRIGHTNESS is not supported\n");
- } else {
- memset (&control, 0, sizeof (control));
- control.id = V4L2_CID_BRIGHTNESS;
- /* Increasing the Brightness */
- control.value = brightness;
-
- if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- perror ("VIDIOC_S_CTRL");
- return -1;
- }
- }
-#endif /* TBD */
- return 0;
-}
-
-/*===========================================================================
- * FUNCTION - increase_EV -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_EV (void) {
- int32_t ev = 0;
- if (++ev_num <= 12) {
- ev = (ev_num << 16) | 6;
- printf("Increase EV to %d\n", ev_num);
- } else {
- printf("Reached max EV. \n");
- ev = ev_num;
- }
-
- struct v4l2_queryctrl queryctrl;
- struct v4l2_control control;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_EXPOSURE;
-#if 0 /* TBD */
- if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
- if (errno != EINVAL) {
- perror ("VIDIOC_QUERYCTRL");
- exit (EXIT_FAILURE);
- } else {
- printf ("V4L2_CID_EXPOSURE is not supported\n");
- }
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- printf ("V4L2_CID_EXPOSURE is not supported\n");
- } else {
- memset (&control, 0, sizeof (control));
- control.id = V4L2_CID_EXPOSURE;
- /* Increasing the EV*/
- control.value = ev;
-
- if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- perror ("VIDIOC_S_CTRL");
- return -1;
- }
- }
-#endif /* TBD */
- return 0;
-}
-
-/*===========================================================================
- * FUNCTION - decrease_EV -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_EV (void) {
- int32_t ev = 0;
- if (--ev_num > -12) {
- ev = (ev_num << 16) | 6;
- printf("Decrease EV to %d\n", ev_num);
- } else {
- printf("Reached min EV. \n");
- ev = ev_num;
- }
-
- struct v4l2_queryctrl queryctrl;
- struct v4l2_control control;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_EXPOSURE;
-#if 0 /* TBD */
- if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
- if (errno != EINVAL) {
- perror ("VIDIOC_QUERYCTRL");
- exit (EXIT_FAILURE);
- } else {
- printf ("V4L2_CID_EXPOSURE is not supported\n");
- }
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- printf ("V4L2_CID_EXPOSURE is not supported\n");
- } else {
- memset (&control, 0, sizeof (control));
- control.id = V4L2_CID_EXPOSURE;
- /* Increasing the EV*/
- control.value = ev;
-
- if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- perror ("VIDIOC_S_CTRL");
- return -1;
- }
- }
-#endif /* TBD */
- return 0;
-}
-
-/*===========================================================================
- * FUNCTION - increase_contrast -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_saturation (void) {
- ++saturation;
- if (saturation > CAMERA_MAX_SATURATION) {
- saturation = CAMERA_MAX_SATURATION;
- printf("Reached max saturation. \n");
- } else
- printf("Increase saturation to %d\n", saturation);
-
- /*intrfcCtrl.setContrast(camfd, contrast);*/
-
- struct v4l2_queryctrl queryctrl;
- struct v4l2_control control;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_SATURATION;
-#if 0 /* TBD */
- if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
- if (errno != EINVAL) {
- perror ("VIDIOC_QUERYCTRL");
- exit (EXIT_FAILURE);
- } else {
- printf ("V4L2_CID_saturation is not supported\n");
- }
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- printf ("V4L2_CID_saturation is not supported\n");
- } else {
- memset (&control, 0, sizeof (control));
- control.id = V4L2_CID_SATURATION;
- /* Decreasing the contrast */
- control.value = saturation;
-
- if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- perror ("VIDIOC_S_CTRL");
- return -1;
- }
- }
-#endif /* TBD */
- return 0;
-}
-
-/*===========================================================================
- * FUNCTION - decrease_saturation -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_saturation (void) {
- --saturation;
- if (saturation < CAMERA_MIN_SATURATION) {
- saturation = CAMERA_MIN_SATURATION;
- printf("Reached min saturation. \n");
- } else
- printf("Decrease saturation to %d\n", saturation);
-
- /*intrfcCtrl.setContrast(camfd, contrast);*/
- struct v4l2_queryctrl queryctrl;
- struct v4l2_control control;
-
- memset (&queryctrl, 0, sizeof (queryctrl));
- queryctrl.id = V4L2_CID_SATURATION;
-#if 0 /* TBD */
- if (-1 == ioctl (camfd, VIDIOC_QUERYCTRL, &queryctrl)) {
- if (errno != EINVAL) {
- perror ("VIDIOC_QUERYCTRL");
- exit (EXIT_FAILURE);
- } else {
- printf ("V4L2_CID_saturation is not supported\n");
- }
- } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
- printf ("V4L2_CID_saturation is not supported\n");
- } else {
- memset (&control, 0, sizeof (control));
- control.id = V4L2_CID_SATURATION;
- /* Decreasing the contrast */
- control.value = saturation;
-
- if (-1 == ioctl (camfd, VIDIOC_S_CTRL, &control)) {
- perror ("VIDIOC_S_CTRL");
- return -1;
- }
- }
-#endif /* TBD */
- return 0;
-}
-
-int takePicture_yuv(int cam_id)
-{
- int rc = 0;
- CDBG("%s:BEGIN\n", __func__);
- if(0 != (rc = mm_app_take_picture(cam_id))) {
- CDBG_ERROR("%s: mm_app_take_picture() err=%d\n", __func__, rc);
- }
- return rc;
-}
-
-int takePicture_zsl(int cam_id)
-{
- int rc = 0;
- CDBG("%s:BEGIN\n", __func__);
- if(0 != (rc = mm_app_take_zsl(cam_id))) {
- CDBG_ERROR("%s: mm_app_take_picture() err=%d\n", __func__, rc);
- }
- return rc;
-}
-
-int takePicture_live(int cam_id)
-{
- int rc = 0;
- CDBG("%s:BEGIN\n", __func__);
- if(0 != (rc = mm_app_take_live_snapshot(cam_id))) {
- CDBG_ERROR("%s: mm_app_take_picture() err=%d\n", __func__, rc);
- }
- return rc;
-}
-
-int takePicture_raw(int cam_id)
-{
- int rc = 0;
- CDBG("%s:BEGIN\n", __func__);
- if(0 != (rc = mm_app_take_raw(cam_id))) {
- CDBG("%s: mm_app_take_raw_picture() err=%d\n", __func__, rc);
- }
- return rc;
-}
-int system_dimension_set(int cam_id)
-{
- static cam_ctrl_dimension_t dim;
- int rc = 0;
-
- if (preview_video_resolution_flag == 0) {
- mm_app_set_dim_def(&dim);
- } else {
- dim.video_width = input_display.user_input_display_width;
- dim.video_width = CEILING32(dim.video_width);
- dim.video_height = input_display.user_input_display_height;
- dim.orig_video_width = dim.video_width;
- dim.orig_video_height = dim.video_height;
- dim.display_width = dim.video_width;
- dim.display_height = dim.video_height;
- }
- rc = mm_app_set_dim(cam_id, &dim);
- return rc;
-}
-
-/*int run_test_harness()
-{
- int good_test_cnt = 0;
-
- rc = run_test_1();
- if(rc < 0)
- CDBG_EROR("%s: run_test_1 err = %d", __func__, rc);
- rc = run_test_2();
-}*/
-/*===========================================================================
- * FUNCTION - main -
- *
- * DESCRIPTION:
- *==========================================================================*/
-int main(int argc, char **argv)
-{
- int keep_on_going = 1;
- int c, rc = 0, tmp_fd;
- int run_tc = 0;
- int run_dual_tc = 0;
- struct v4l2_capability v4l2_cap;
-
- /* get v4l2 params - memory type etc */
- while ((c = getopt(argc, argv, "tdh")) != -1) {
- //printf("usage: %s [-m] [-u] [-o]\n", argv[1]);
- switch (c) {
-#if 0
- case 'm':
- memoryType = V4L2_MEMORY_MMAP;
- break;
-
- case 'o':
- /*use_overlay_fb_display_driver();*/
- break;
- case 'u':
- memoryType = V4L2_MEMORY_USERPTR;
- break;
-#endif
- case 't':
- run_tc = 1;
- break;
- case 'd':
- run_dual_tc = 1;
- break;
- case 'h':
- default:
- printf("usage: %s [-m] [-u] [-o]\n", argv[0]);
- printf("-m: V4L2_MEMORY_MMAP. \n");
- printf("-o: use overlay fb display driver\n");
- printf("-u: V4L2_MEMORY_USERPTR\n");
- exit(0);
- }
- }
-
- CDBG("\nCamera Test Application\n");
-
- struct timeval tdBeforePreviewVideo, tdStopCamera;
- struct timezone tz;
-
- //return run_test_harness();
- if((rc = mm_app_load_hal())) {
- CDBG_ERROR("%s:mm_app_init err=%d\n", __func__, rc);
- exit(-1);
- }
- /* we must init mm_app first */
- if(mm_app_init() != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_init err=%d\n", __func__, rc);
- exit(-1);
- }
-
- if(run_tc) {
- printf("\tRunning unit test engine only\n");
- rc = mm_app_unit_test();
- printf("\tUnit test engine. EXIT(%d)!!!\n", rc);
- exit(rc);
- }
-
- if(run_dual_tc) {
- printf("\tRunning Dual camera test engine only\n");
- rc = mm_app_dual_test();
- printf("\t Dual camera engine. EXIT(%d)!!!\n", rc);
- exit(rc);
- }
-
- gettimeofday(&tdBeforePreviewVideo, &tz);
-
- CDBG("Profiling: Start Camera timestamp = %ld ms\n",
- (tdBeforePreviewVideo.tv_sec * 1000) + (tdBeforePreviewVideo.tv_usec/1000));
-
- /* launch the primary camera in default mode */
- if( mm_app_open(CAMERA_OPENED)) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- exit(-2);
- }
-
- /* main loop doing the work*/
- do {
- keep_on_going = submain();
- } while ( keep_on_going );
-
- /* Clean up and exit. */
- CDBG("Exiting the app\n");
-
-error_ionfd_open:
- mm_app_close(CAMERA_OPENED);
-
- gettimeofday(&tdStopCamera, &tz);
- CDBG("Exiting application\n");
- CDBG("Profiling: Stop camera end timestamp = %ld ms\n",
- (tdStopCamera.tv_sec * 1000) + (tdStopCamera.tv_usec/1000));
-
- return 0;
-}
-
-
-/*===========================================================================
- * FUNCTION - submain -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-static int submain()
-{
- int rc = 0;
- int back_mainflag = 0;
- char tc_buf[3];
- int stop_preview = 1;
- menu_id_change_t current_menu_id = MENU_ID_MAIN, next_menu_id;
- camera_action_t action_id;
- int action_param;
- int i;
- int cam_id;
-
- CDBG("%s:E", __func__);
- struct timeval tdStopCamera;
- struct timezone tz;
-
- cam_id = my_cam_app.cam_open;
-
- rc = system_dimension_set(cam_id);
- CDBG("Start Preview");
- if( 0 != (rc = startPreview(cam_id))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- return 0;
- }
-
- do {
- print_current_menu (current_menu_id);
- fgets(tc_buf, 3, stdin);
-
- next_menu_id = next_menu(current_menu_id, tc_buf[0], &action_id, &action_param);
-
- if (next_menu_id != MENU_ID_INVALID) {
- current_menu_id = next_menu_id;
- }
- if (action_id == ACTION_NO_ACTION) {
- continue;
- }
- if(camframe_status == -1) {
- printf("Preview/Video ERROR condition reported Closing Camera APP\n");
- break;
- }
-
- switch(action_id) {
- case ACTION_STOP_CAMERA:
- CDBG("ACTION_STOP_CAMERA \n");
- stopPreview(cam_id);
- break;
-
- case ACTION_PREVIEW_VIDEO_RESOLUTION:
- back_mainflag = 1;
- CDBG("Selection for the preview/video resolution change\n");
- switchRes(cam_id);
- preview_video_resolution (action_param);
- break;
- case ACTION_SET_WHITE_BALANCE:
- CDBG("Selection for the White Balance changes\n");
- set_whitebalance(action_param);
- break;
-
- case ACTION_SET_EXP_METERING:
- CDBG("Selection for the Exposure Metering changes\n");
- set_exp_metering(action_param);
- break;
-
- case ACTION_GET_CTRL_VALUE:
- CDBG("Selection for getting control value\n");
- get_ctrl_value(action_param);
- break;
-
- case ACTION_BRIGHTNESS_INCREASE:
- printf("Increase brightness\n");
- increase_brightness();
- break;
-
- case ACTION_BRIGHTNESS_DECREASE:
- printf("Decrease brightness\n");
- decrease_brightness();
- break;
-
- case ACTION_CONTRAST_INCREASE:
- CDBG("Selection for the contrast increase\n");
- increase_contrast ();
- break;
-
- case ACTION_CONTRAST_DECREASE:
- CDBG("Selection for the contrast decrease\n");
- decrease_contrast ();
- break;
-
- case ACTION_EV_INCREASE:
- CDBG("Selection for the EV increase\n");
- increase_EV ();
- break;
-
- case ACTION_EV_DECREASE:
- CDBG("Selection for the EV decrease\n");
- decrease_EV ();
- break;
-
- case ACTION_SATURATION_INCREASE:
- CDBG("Selection for the EV increase\n");
- increase_saturation ();
- break;
-
- case ACTION_SATURATION_DECREASE:
- CDBG("Selection for the EV decrease\n");
- decrease_saturation ();
- break;
-
- case ACTION_TOGGLE_AFR:
- CDBG("Select for auto frame rate toggling\n");
- toggle_afr();
- break;
-
- case ACTION_SET_ISO:
- CDBG("Select for ISO changes\n");
- set_iso(action_param);
- break;
-
- case ACTION_SET_ZOOM:
- CDBG("Selection for the zoom direction changes\n");
- set_zoom(action_param);
- break;
-
- case ACTION_SHARPNESS_INCREASE:
- CDBG("Selection for sharpness increase\n");
- increase_sharpness();
- break;
-
- case ACTION_SHARPNESS_DECREASE:
- CDBG("Selection for sharpness decrease\n");
- decrease_sharpness();
- break;
-
- case ACTION_TAKE_YUV_SNAPSHOT:
- CDBG("Take YUV snapshot\n");
- if (takePicture_yuv(cam_id) < 0)
- goto ERROR;
- break;
- case ACTION_TAKE_RAW_SNAPSHOT:
- CDBG("Take YUV snapshot\n");
- if (takePicture_raw(cam_id) < 0)
- goto ERROR;
- break;
- case ACTION_START_RECORDING:
- CDBG("Start recording action\n");
- if (startRecording(cam_id) < 0)
- goto ERROR;
- break;
- case ACTION_STOP_RECORDING:
- CDBG("Stop recording action\n");
- if (stopRecording(cam_id) < 0)
- goto ERROR;
- break;
- case ACTION_NO_ACTION:
- printf("Go back to main menu");
- break;
- case ACTION_SWITCH_CAMERA:
- CDBG("Toggle Camera action\n");
- back_mainflag = 1;
- switchCamera(action_param - 1);
- break;
-
- case ACTION_TAKE_ZSL_SNAPSHOT:
- CDBG("Take ZSL snapshot\n");
- if (takePicture_zsl(cam_id) < 0)
- {
- CDBG("Error");
- goto ERROR;
- }
- break;
- case ACTION_START_RDI:
- CDBG("Start RDI Stream\n");
- startRdi(cam_id);
- break;
- case ACTION_STOP_RDI:
- CDBG("Stop RDI Stream\n");
- stopRdi(cam_id);
- break;
- case ACTION_TAKE_LIVE_SNAPSHOT:
- CDBG("Take Live snapshot\n");
- if (takePicture_live(cam_id) < 0)
- {
- CDBG("Error");
- goto ERROR;
- }
- break;
-
- default:
- printf("\n\n!!!!!WRONG INPUT: %d!!!!\n", action_id);
- break;
- }
-
- usleep(1000 * 1000);
- CDBG("action_id = %d\n", action_id);
- camframe_status = 0;
-
- } while ((action_id != ACTION_STOP_CAMERA) &&
- (action_id != ACTION_PREVIEW_VIDEO_RESOLUTION) && (action_id !=ACTION_SWITCH_CAMERA));
- action_id = ACTION_NO_ACTION;
-
- //system_destroy();
-
-
- return back_mainflag;
-
-ERROR:
- back_mainflag = 0;
- return back_mainflag;
-}
-
-
-/*===========================================================================
- * FUNCTION - preview_resolution -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int preview_video_resolution (int preview_video_action_param) {
- char * resolution_name;
- CDBG("Selecting the action for preview/video resolution = %d \n", preview_video_action_param);
- resolution_name = set_preview_video_dimension_tbl(preview_video_action_param,
- & input_display.user_input_display_width,
- & input_display.user_input_display_height);
-
- CDBG("Selected preview/video resolution is %s\n", resolution_name);
-
- if (resolution_name == NULL) {
- CDBG("main:%d set_preview_dimension failed!\n", __LINE__);
- goto ERROR;
- }
-
- CDBG("Selected Preview Resolution: display_width = %d, display_height = %d\n",
- input_display.user_input_display_width, input_display.user_input_display_height);
-
- preview_video_resolution_flag = 1;
- return 0;
-
-ERROR:
- return -1;
-}
-
-/*===========================================================================
- * FUNCTION - set_whitebalance -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int set_whitebalance (int wb_action_param) {
-
- int rc = 0;
- struct v4l2_control ctrl_awb, ctrl_temperature;
-
- ctrl_awb.id = V4L2_CID_AUTO_WHITE_BALANCE;
- ctrl_awb.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
-
- switch (wb_action_param) {
- case CAMERA_WB_INCANDESCENT:
- ctrl_awb.value = FALSE;
- ctrl_temperature.value = 2800;
- break;
- case CAMERA_WB_DAYLIGHT:
- ctrl_awb.value = FALSE;
- ctrl_temperature.value = 6500;
- break;
- case CAMERA_WB_FLUORESCENT:
- ctrl_awb.value = FALSE;
- ctrl_temperature.value = 4200;
- break;
- case CAMERA_WB_CLOUDY_DAYLIGHT:
- ctrl_awb.value = FALSE;
- ctrl_temperature.value = 7500;
- break;
- case CAMERA_WB_AUTO:
- default:
- ctrl_awb.value = TRUE;
- break;
- }
-
-DONE:
- return rc;
-}
-
-
-/*===========================================================================
- * FUNCTION - set_exp_metering -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int set_exp_metering (int exp_metering_action_param) {
-
- int rc = 0;
- struct v4l2_control ctrl;
-
- ctrl.id = MSM_V4L2_PID_EXP_METERING;
- ctrl.value = exp_metering_action_param;
- // rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
- return rc;
-}
-
-int get_ctrl_value (int ctrl_value_mode_param){
-
- int rc = 0;
- struct v4l2_control ctrl;
-
- if (ctrl_value_mode_param == WHITE_BALANCE_STATE) {
- printf("You chose WHITE_BALANCE_STATE\n");
- ctrl.id = V4L2_CID_AUTO_WHITE_BALANCE;
- }
- else if (ctrl_value_mode_param == WHITE_BALANCE_TEMPERATURE) {
- printf("You chose WHITE_BALANCE_TEMPERATURE\n");
- ctrl.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
- }
- else if (ctrl_value_mode_param == BRIGHTNESS_CTRL) {
- printf("You chose brightness value\n");
- ctrl.id = V4L2_CID_BRIGHTNESS;
- }
- else if (ctrl_value_mode_param == EV) {
- printf("You chose exposure value\n");
- ctrl.id = V4L2_CID_EXPOSURE;
- }
- else if (ctrl_value_mode_param == CONTRAST_CTRL) {
- printf("You chose contrast value\n");
- ctrl.id = V4L2_CID_CONTRAST;
- }
- else if (ctrl_value_mode_param == SATURATION_CTRL) {
- printf("You chose saturation value\n");
- ctrl.id = V4L2_CID_SATURATION;
- } else if (ctrl_value_mode_param == SHARPNESS_CTRL) {
- printf("You chose sharpness value\n");
- ctrl.id = V4L2_CID_SHARPNESS;
- }
-
- // rc = ioctl(camfd, VIDIOC_G_CTRL, &ctrl);
-
- return rc;
-}
-
-/*===========================================================================
- * FUNCTION - toggle_afr -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int toggle_afr () {
- int rc = 0;
- struct v4l2_control ctrl;
-
- memset(&ctrl, 0, sizeof(ctrl));
- ctrl.id = V4L2_CID_EXPOSURE_AUTO;
-// rc = ioctl(camfd, VIDIOC_G_CTRL, &ctrl);
- if (rc == -1) {
- CDBG("%s: VIDIOC_G_CTRL V4L2_CID_EXPOSURE_AUTO failed: %s\n",
- __func__, strerror(errno));
- return rc;
- }
-
- /* V4L2_CID_EXPOSURE_AUTO needs to be AUTO or SHUTTER_PRIORITY */
- if (ctrl.value != V4L2_EXPOSURE_AUTO &&
- ctrl.value != V4L2_EXPOSURE_SHUTTER_PRIORITY) {
- CDBG("%s: V4L2_CID_EXPOSURE_AUTO needs to be AUTO/SHUTTER_PRIORITY\n",
- __func__);
- return -1;
- }
-
- /* Get V4L2_CID_EXPOSURE_AUTO_PRIORITY */
- memset(&ctrl, 0, sizeof(ctrl));
- ctrl.id = V4L2_CID_EXPOSURE_AUTO_PRIORITY;
- // rc = ioctl(camfd, VIDIOC_G_CTRL, &ctrl);
- if (rc == -1) {
- CDBG("%s: VIDIOC_G_CTRL V4L2_CID_EXPOSURE_AUTO_PRIORITY failed: %s\n",
- __func__, strerror(errno));
- return rc;
- }
-
- ctrl.value = !ctrl.value;
- printf("V4L2_CID_EXPOSURE_AUTO_PRIORITY changed to %d\n", ctrl.value);
- // rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
- if (rc == -1) {
- CDBG("%s: VIDIOC_S_CTRL V4L2_CID_EXPOSURE_AUTO_PRIORITY failed: %s\n",
- __func__, strerror(errno));
- }
- return rc;
-}
-
-int set_zoom (int zoom_action_param) {
- int rc = 0;
- struct v4l2_control ctrl;
-
- if (zoom_action_param == ZOOM_IN) {
- zoom_level += zoom_queryctrl.step;
- if (zoom_level > zoom_queryctrl.maximum)
- zoom_level = zoom_queryctrl.maximum;
- } else if (zoom_action_param == ZOOM_OUT) {
- zoom_level -= zoom_queryctrl.step;
- if (zoom_level < zoom_queryctrl.minimum)
- zoom_level = zoom_queryctrl.minimum;
- } else {
- CDBG("%s: Invalid zoom_action_param value\n", __func__);
- return -EINVAL;
- }
- ctrl.id = V4L2_CID_ZOOM_ABSOLUTE;
- ctrl.value = zoom_level;
- // rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
- return rc;
-}
-
-/*===========================================================================
- * FUNCTION - set_iso -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int set_iso (int iso_action_param) {
- int rc = 0;
- struct v4l2_control ctrl;
-
- ctrl.id = MSM_V4L2_PID_ISO;
- ctrl.value = iso_action_param - 1;
- // rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
- return rc;
-}
-
-/*===========================================================================
- * FUNCTION - increase_sharpness -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int increase_sharpness () {
- int rc = 0;
- struct v4l2_control ctrl;
-
- sharpness += sharpness_queryctrl.step;
- if (sharpness > sharpness_queryctrl.maximum)
- sharpness = sharpness_queryctrl.maximum;
-
- ctrl.id = V4L2_CID_SHARPNESS;
- ctrl.value = sharpness;
- // rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
- return rc;
-}
-
-/*===========================================================================
- * FUNCTION - decrease_sharpness -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int decrease_sharpness () {
- int rc = 0;
- struct v4l2_control ctrl;
-
- sharpness -= sharpness_queryctrl.step;
- if (sharpness < sharpness_queryctrl.minimum)
- sharpness = sharpness_queryctrl.minimum;
-
- ctrl.id = V4L2_CID_SHARPNESS;
- ctrl.value = sharpness;
- // rc = ioctl(camfd, VIDIOC_S_CTRL, &ctrl);
-
- return rc;
-}
-
-/*===========================================================================
- * FUNCTION - print_current_menu -
- *
- * DESCRIPTION:
- * ===========================================================================*/
-int print_current_menu (menu_id_change_t current_menu_id) {
- if (current_menu_id == MENU_ID_MAIN) {
- print_menu_preview_video ();
- } else if (current_menu_id == MENU_ID_PREVIEWVIDEORESOLUTIONCHANGE) {
- camera_preview_video_resolution_change_tbl ();
- }else if (current_menu_id == MENU_ID_WHITEBALANCECHANGE) {
- camera_preview_video_wb_change_tbl();
- } else if (current_menu_id == MENU_ID_EXPMETERINGCHANGE) {
- camera_preview_video_exp_metering_change_tbl();
- } else if (current_menu_id == MENU_ID_GET_CTRL_VALUE) {
- camera_preview_video_get_ctrl_value_tbl();
- } else if (current_menu_id == MENU_ID_ISOCHANGE) {
- camera_preview_video_iso_change_tbl();
- } else if (current_menu_id == MENU_ID_BRIGHTNESSCHANGE) {
- camera_brightness_change_tbl ();
- } else if (current_menu_id == MENU_ID_CONTRASTCHANGE) {
- camera_contrast_change_tbl ();
- } else if (current_menu_id == MENU_ID_EVCHANGE) {
- camera_EV_change_tbl ();
- } else if (current_menu_id == MENU_ID_SATURATIONCHANGE) {
- camera_saturation_change_tbl ();
- } else if (current_menu_id == MENU_ID_ZOOMCHANGE) {
- camera_preview_video_zoom_change_tbl();
- } else if (current_menu_id == MENU_ID_SHARPNESSCHANGE) {
- camera_preview_video_sharpness_change_tbl();
- }else if (current_menu_id == MENU_ID_SWITCHCAMERA) {
- camera_switch_tbl();
- }else if (current_menu_id == MENU_ID_RECORD) {
- camera_record_tbl();
- }
-
- return 0;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_pp.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_pp.c
deleted file mode 100755
index 5ed5053..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_pp.c
+++ /dev/null
@@ -1,963 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <linux/ion.h>
-#include "mm_qcamera_app.h"
-
-extern int system_dimension_set(int cam_id);
-extern void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h, char* name, int main_422);
-
-int32_t mm_qcamera_queue_init(mm_qcamera_queue_t* queue);
-int32_t mm_qcamera_queue_enq(mm_qcamera_queue_t* queue, void* data);
-void* mm_qcamera_queue_deq(mm_qcamera_queue_t* queue);
-void* mm_qcamera_queue_peek(mm_qcamera_queue_t* queue);
-int32_t mm_qcamera_queue_deinit(mm_qcamera_queue_t* queue);
-int32_t mm_qcamera_queue_flush(mm_qcamera_queue_t* queue);
-
-static void mm_app_preview_pp_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- repro_src_buf_info *buf_info = NULL;
-
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[0];
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n",
- __func__, frame->frame_len, frame->frame_idx);
-
- dumpFrameToFile(frame, pme->dim.display_width, pme->dim.display_height,"preview", 1);
-
- buf_info = (repro_src_buf_info *)mm_qcamera_queue_peek(&pme->repro_q);
- if (NULL != buf_info) {
- buf_info->ref_cnt--;
- if (0 == buf_info->ref_cnt) {
- mm_qcamera_queue_deq(&pme->repro_q);
- pme->cam->ops->qbuf(pme->cam->camera_handle, pme->ch_id, buf_info->frame);
- mm_stream_invalid_cache(pme, buf_info->frame);
- buf_info->frame = NULL;
- }
- }
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle, pme->ch_id, frame)) {
- CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- CDBG("%s: END\n", __func__);
-}
-
-static void mm_app_video_pp_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- repro_src_buf_info *buf_info = NULL;
-
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[0] ;
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n",
- __func__, frame->frame_len, frame->frame_idx);
-
- dumpFrameToFile(frame,pme->dim.orig_video_width,pme->dim.orig_video_height,"video", 1);
-
- buf_info = (repro_src_buf_info *)mm_qcamera_queue_peek(&pme->repro_q);
- if (NULL != buf_info) {
- buf_info->ref_cnt--;
- if (0 == buf_info->ref_cnt) {
- mm_qcamera_queue_deq(&pme->repro_q);
- pme->cam->ops->qbuf(pme->cam->camera_handle, pme->ch_id, buf_info->frame);
- mm_stream_invalid_cache(pme, buf_info->frame);
- buf_info->frame = NULL;
- }
- }
-
- if(MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle, pme->ch_id, frame))
- {
- CDBG_ERROR("%s: Failed in Snapshot Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- CDBG("%s: END\n", __func__);
-}
-
-static void mm_app_isp_pix_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- mm_camera_repro_data_t repro_data;
-
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[0] ;
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n",
- __func__, frame->frame_len, frame->frame_idx);
-
- pme->repro_buf_info[frame->buf_idx].frame = frame;
- pme->repro_buf_info[frame->buf_idx].ref_cnt = pme->repro_dest_num;
- mm_qcamera_queue_enq(&pme->repro_q,
- (void *)&pme->repro_buf_info[frame->buf_idx]);
-
- memset(&repro_data, 0, sizeof(mm_camera_repro_data_t));
- repro_data.src_frame = frame;
-
- rc = pme->cam->ops->reprocess(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- &repro_data);
- if (MM_CAMERA_OK != rc) {
- CDBG_ERROR("%s: reprocess error = %d", __func__, rc);
- }
-
- CDBG("%s: END\n", __func__);
-}
-
-int prepareReprocess(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int op_mode;
- mm_camera_repro_isp_config_t config;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: E",__func__);
- pme->mem_cam->get_buf = mm_stream_initbuf;
- pme->mem_cam->put_buf = mm_stream_deinitbuf;
- pme->mem_cam->user_data = pme;
-
- /* set mode */
- op_mode = MM_CAMERA_OP_MODE_VIDEO;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
- pme->cam->camera_handle,
- MM_CAMERA_PARM_OP_MODE,
- &op_mode))) {
- CDBG_ERROR("%s: Set preview op mode error", __func__);
- goto end;
- }
-
- /* init reprocess queue */
- mm_qcamera_queue_init(&pme->repro_q);
- memset(pme->repro_buf_info, 0, sizeof(pme->repro_buf_info));
-
- /* add isp pix output1 stream */
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = pme->cam->ops->add_stream(
- pme->cam->camera_handle,
- pme->ch_id,
- mm_app_isp_pix_notify_cb,
- pme,
- MM_CAMERA_ISP_PIX_OUTPUT1,
- 0);
-
- if (!pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id) {
- CDBG_ERROR("%s:Add isp_pix_output1 error\n", __func__);
- rc = -1;
- goto end;
- }
-
- /* add preview stream */
- pme->stream[MM_CAMERA_PREVIEW].id = pme->cam->ops->add_stream(
- pme->cam->camera_handle,
- pme->ch_id,
- mm_app_preview_pp_notify_cb,
- pme,
- MM_CAMERA_PREVIEW,
- 0);
-
- if (!pme->stream[MM_CAMERA_PREVIEW].id) {
- CDBG_ERROR("%s:Add stream preview error\n", __func__);
- rc = -1;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id);
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = 0;
- goto end;
- }
-
- /* add record stream */
- pme->stream[MM_CAMERA_VIDEO].id = pme->cam->ops->add_stream(
- pme->cam->camera_handle,
- pme->ch_id,
- mm_app_video_pp_notify_cb,
- pme,
- MM_CAMERA_VIDEO,
- 0);
-
- if (!pme->stream[MM_CAMERA_VIDEO].id) {
- CDBG_ERROR("%s:Add stream video error\n", __func__);
- rc = -1;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->stream[MM_CAMERA_PREVIEW].id = 0;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id);
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = 0;
- goto end;
- }
-
- /* open isp reprocess */
- pme->isp_repro_handle = pme->cam->ops->open_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- MM_CAMERA_REPRO_ISP_PIX);
-
- if (!pme->isp_repro_handle) {
- CDBG_ERROR("%s:open isp reprocess error\n", __func__);
- rc = -1;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_VIDEO].id);
- pme->stream[MM_CAMERA_VIDEO].id = 0;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->stream[MM_CAMERA_PREVIEW].id = 0;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id);
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = 0;
- goto end;
- }
-
- /* prepare repro isp config */
- memset(&pme->repro_config, 0, sizeof(mm_camera_repro_config_data_t));
- pme->repro_config.image_mode = MM_CAMERA_ISP_PIX_OUTPUT1;
- if (pme->dim.display_width * pme->dim.display_height >
- pme->dim.video_width * pme->dim.video_height) {
- /* preview size is larger than video, use preview config as repro isp config */
- pme->repro_config.format = pme->dim.prev_format;
- pme->repro_config.width = pme->dim.display_width;
- pme->repro_config.height = pme->dim.display_height;
- } else {
- pme->repro_config.format = pme->dim.enc_format;
- pme->repro_config.width = pme->dim.video_width;
- pme->repro_config.height = pme->dim.video_height;
- }
-
- /* config isp reprocess */
- memset(&config, 0, sizeof(mm_camera_repro_isp_config_t));
- config.src.format = pme->repro_config.format;
- config.src.image_mode = pme->repro_config.image_mode;
- config.src.width = pme->repro_config.width;
- config.src.height = pme->repro_config.height;
- config.src.inst_handle = pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id;
-
- pme->repro_dest_num = 0;
- config.num_dest = 2;
- config.dest[0].image_mode = MM_CAMERA_PREVIEW;
- config.dest[0].format = pme->dim.prev_format;
- config.dest[0].width = pme->dim.display_width;
- config.dest[0].height = pme->dim.display_height;
- config.dest[0].inst_handle = pme->stream[MM_CAMERA_PREVIEW].id;
- config.dest[1].image_mode = MM_CAMERA_VIDEO;
- config.dest[1].format = pme->dim.enc_format;
- config.dest[1].width = pme->dim.video_width;
- config.dest[1].height = pme->dim.video_height;
- config.dest[1].inst_handle = pme->stream[MM_CAMERA_VIDEO].id;
-
- rc = pme->cam->ops->config_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- &config);
-
- if (MM_CAMERA_OK != rc) {
- CDBG_ERROR("%s:config isp reprocess error = %d\n", __func__, rc);
- pme->cam->ops->close_repro_isp(pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle);
- pme->isp_repro_handle = 0;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_VIDEO].id);
- pme->stream[MM_CAMERA_VIDEO].id = 0;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->stream[MM_CAMERA_PREVIEW].id = 0;
- pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id);
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id = 0;
- }
-
-end:
- CDBG("%s: X rc = %d", __func__, rc);
- return rc;
-}
-
-int unprepareReprocess(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: E",__func__);
- rc = pme->cam->ops->close_repro_isp(pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle);
- pme->isp_repro_handle = 0;
- mm_qcamera_queue_deinit(&pme->repro_q);
-
- CDBG("%s: X rc = %d", __func__, rc);
- return rc;
-}
-
-int startPreviewPP(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[1];
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: E",__func__);
-
- /* attach preview stream to isp reprocess pipe */
- if (MM_CAMERA_OK != (rc = pme->cam->ops->attach_stream_to_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id))) {
- CDBG_ERROR("%s : Attach preview to reprocess error",__func__);
- goto end;
- }
-
- /* start isp reprocess pipe for preview */
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_repro_isp(pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id))) {
- CDBG_ERROR("%s : Start reprocess for preview error",__func__);
- pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- goto end;
- }
-
- /* increase actual reprocess dest num */
- pme->repro_dest_num++;
-
- /* start preview stream */
- pme->stream[MM_CAMERA_PREVIEW].str_config.fmt.meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- pme->stream[MM_CAMERA_PREVIEW].str_config.fmt.fmt = pme->dim.prev_format;
- pme->stream[MM_CAMERA_PREVIEW].str_config.fmt.width = pme->dim.display_width;
- pme->stream[MM_CAMERA_PREVIEW].str_config.fmt.height = pme->dim.display_height;
- pme->stream[MM_CAMERA_PREVIEW].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_PREVIEW].str_config.num_of_bufs = PREVIEW_BUF_NUM;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_PREVIEW].id,
- &pme->stream[MM_CAMERA_PREVIEW].str_config))) {
- CDBG_ERROR("%s:config preview err=%d\n", __func__, rc);
- pme->cam->ops->stop_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->repro_dest_num--;
- goto end;
- }
- stream[0] = pme->stream[MM_CAMERA_PREVIEW].id;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,
- pme->ch_id,
- 1,
- stream))) {
- CDBG_ERROR("%s : Preview Stream on Error",__func__);
- pme->cam->ops->stop_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->repro_dest_num--;
- goto end;
- }
-
- /* start isp pix output1 stream */
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.fmt.meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.fmt.fmt = pme->repro_config.format;
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.fmt.width = pme->repro_config.width;
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.fmt.height = pme->repro_config.height;
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config.num_of_bufs = ISP_PIX_BUF_NUM;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id,
- &pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].str_config))) {
- CDBG_ERROR("%s:config isp pix stream err=%d\n", __func__, rc);
- pme->cam->ops->stop_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->repro_dest_num--;
- }
- stream[0] = pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,
- pme->ch_id,
- 1,
- stream))) {
- CDBG_ERROR("%s : Preview Stream on Error",__func__);
- pme->cam->ops->stop_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id);
- pme->repro_dest_num--;
- goto end;
- }
-
-end:
- CDBG("%s: X rc=%d\n", __func__, rc);
- return rc;
-}
-
-int stopPreviewPP(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[1];
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: E",__func__);
-
- /* stop preview stream */
- stream[0] = pme->stream[MM_CAMERA_PREVIEW].id;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,
- pme->ch_id,
- 1,
- stream))) {
- CDBG_ERROR("%s : Preview Stream off Error",__func__);
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_PREVIEW].id))) {
- CDBG_ERROR("%s : Delete Stream Preview error",__func__);
- }
-
- /* stop isp reprocess pipe for preview */
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_repro_isp(pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id))) {
- CDBG_ERROR("%s : Stop reprocess for preview error",__func__);
- }
-
- /* decrease actual reprocess dest num */
- pme->repro_dest_num--;
-
- /* detach preview stream from isp reprocess pipe */
- if (MM_CAMERA_OK != (rc = pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_PREVIEW].id))) {
- CDBG_ERROR("%s : Detach preview from reprocess error",__func__);
- }
-
- /* stop isp pix output1 stream */
- stream[0] = pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,
- pme->ch_id,
- 1,
- stream))) {
- CDBG_ERROR("%s : ISP pix Stream off Error",__func__);
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_ISP_PIX_OUTPUT1].id))) {
- CDBG_ERROR("%s : Delete Stream isp pix error",__func__);
- }
-
-end:
- CDBG("%s: X rc=%d\n", __func__, rc);
- return rc;
-}
-
-int startRecordPP(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[1];
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: E",__func__);
-
- /* attach video stream to isp reprocess pipe */
- if (MM_CAMERA_OK != (rc = pme->cam->ops->attach_stream_to_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id))) {
- CDBG_ERROR("%s : Attach video to reprocess error",__func__);
- goto end;
- }
-
- /* start isp reprocess pipe for video */
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_repro_isp(pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id))) {
- CDBG_ERROR("%s : Start reprocess for video error",__func__);
- pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id);
- goto end;
- }
-
- /* increase actual reprocess dest num */
- pme->repro_dest_num++;
-
- /* start preview stream */
- pme->stream[MM_CAMERA_VIDEO].str_config.fmt.meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- pme->stream[MM_CAMERA_VIDEO].str_config.fmt.fmt = pme->dim.enc_format;
- pme->stream[MM_CAMERA_VIDEO].str_config.fmt.width = pme->dim.video_width;
- pme->stream[MM_CAMERA_VIDEO].str_config.fmt.height = pme->dim.video_height;
- pme->stream[MM_CAMERA_VIDEO].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_VIDEO].str_config.num_of_bufs = VIDEO_BUF_NUM;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_VIDEO].id,
- &pme->stream[MM_CAMERA_VIDEO].str_config))) {
- CDBG_ERROR("%s:config video err=%d\n", __func__, rc);
- pme->cam->ops->stop_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id);
- pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id);
- pme->repro_dest_num--;
- goto end;
- }
- stream[0] = pme->stream[MM_CAMERA_VIDEO].id;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,
- pme->ch_id,
- 1,
- stream))) {
- CDBG_ERROR("%s : Preview Stream on Error",__func__);
- pme->cam->ops->stop_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id);
- pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id);
- pme->repro_dest_num--;
- goto end;
- }
-
-end:
- CDBG("%s: X rc=%d\n", __func__, rc);
- return rc;
-}
-
-int stopRecordPP(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[1];
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: E",__func__);
-
- /* stop video stream */
- stream[0] = pme->stream[MM_CAMERA_VIDEO].id;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,
- pme->ch_id,
- 1,
- stream))) {
- CDBG_ERROR("%s : Video Stream off Error",__func__);
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_VIDEO].id))) {
- CDBG_ERROR("%s : Delete Stream Preview error",__func__);
- }
-
- /* stop isp reprocess pipe for video */
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_repro_isp(pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id))) {
- CDBG_ERROR("%s : Stop reprocess for video error",__func__);
- }
-
- /* decrease actual reprocess dest num */
- pme->repro_dest_num--;
-
- /* detach preview stream from isp reprocess pipe */
- if (MM_CAMERA_OK != (rc = pme->cam->ops->detach_stream_from_repro_isp(
- pme->cam->camera_handle,
- pme->ch_id,
- pme->isp_repro_handle,
- pme->stream[MM_CAMERA_VIDEO].id))) {
- CDBG_ERROR("%s : Detach video from reprocess error",__func__);
- }
-
- CDBG("%s: X rc=%d\n", __func__, rc);
- return rc;
-}
-
-int32_t mm_qcamera_queue_init(mm_qcamera_queue_t* queue)
-{
- pthread_mutex_init(&queue->lock, NULL);
- cam_list_init(&queue->head.list);
- queue->size = 0;
- return 0;
-}
-
-int32_t mm_qcamera_queue_enq(mm_qcamera_queue_t* queue, void* data)
-{
- mm_qcamera_q_node_t* node =
- (mm_qcamera_q_node_t *)malloc(sizeof(mm_qcamera_q_node_t));
- if (NULL == node) {
- CDBG_ERROR("%s: No memory for mm_camera_q_node_t", __func__);
- return -1;
- }
-
- memset(node, 0, sizeof(mm_qcamera_q_node_t));
- node->data = data;
-
- pthread_mutex_lock(&queue->lock);
- cam_list_add_tail_node(&node->list, &queue->head.list);
- queue->size++;
- pthread_mutex_unlock(&queue->lock);
-
- return 0;
-
-}
-
-void* mm_qcamera_queue_deq(mm_qcamera_queue_t* queue)
-{
- mm_qcamera_q_node_t* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
- if (pos != head) {
- node = member_of(pos, mm_qcamera_q_node_t, list);
- cam_list_del_node(&node->list);
- queue->size--;
- }
- pthread_mutex_unlock(&queue->lock);
-
- if (NULL != node) {
- data = node->data;
- free(node);
- }
-
- return data;
-}
-
-void* mm_qcamera_queue_peek(mm_qcamera_queue_t* queue)
-{
- mm_qcamera_q_node_t* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
- if (pos != head) {
- node = member_of(pos, mm_qcamera_q_node_t, list);
- }
- pthread_mutex_unlock(&queue->lock);
-
- if (NULL != node) {
- data = node->data;
- }
-
- return data;
-}
-
-int32_t mm_qcamera_queue_deinit(mm_qcamera_queue_t* queue)
-{
- mm_qcamera_queue_flush(queue);
- pthread_mutex_destroy(&queue->lock);
- return 0;
-}
-
-int32_t mm_qcamera_queue_flush(mm_qcamera_queue_t* queue)
-{
- mm_qcamera_q_node_t* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
-
- while(pos != head) {
- node = member_of(pos, mm_qcamera_q_node_t, list);
- pos = pos->next;
- cam_list_del_node(&node->list);
- queue->size--;
-
- /* TODO later to consider ptr inside data */
- /* for now we only assume there is no ptr inside data
- * so we free data directly */
- if (NULL != node->data) {
- free(node->data);
- }
- free(node);
-
- }
- queue->size = 0;
- pthread_mutex_unlock(&queue->lock);
- return 0;
-}
-
-/* re-processing test case for preview only */
-int mm_app_tc_reprocess_preview_only(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j,k;
- int result = 0;
-
- printf("\n Verifying reprocess for preview on front and back camera...\n");
- if (cam_apps->num_cameras == 0) {
- CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("Re-processing test case for preview");
- for (i = 1; i < cam_apps->num_cameras; i++) {
- CDBG_ERROR("Open camera %d", i);
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("Prepare re-process");
- if ( MM_CAMERA_OK != (rc = prepareReprocess(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: prepareReprocess() err=%d\n", __func__, rc);
- break;
- }
- result = 0;
- for (k = 0; k < MM_QCAMERA_APP_INTERATION; k++) {
- CDBG_ERROR("Start preview with pp");
- if ( MM_CAMERA_OK != (rc = startPreviewPP(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreviewPP() err=%d\n", __func__, rc);
- break;
- }
-
- CDBG_ERROR("Let preview run for 1s");
- /* sleep for 1s */
- usleep(1000*1000);
-
- CDBG_ERROR("Stop preview with pp");
- if ( MM_CAMERA_OK != (rc = stopPreviewPP(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: stopPreviewPP() err=%d\n", __func__, rc);
- break;
- }
- result++;
- usleep(10*1000);
- }
-
- CDBG_ERROR("Unprepare re-process");
- if ( MM_CAMERA_OK != (rc = unprepareReprocess(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: unprepareReprocess() err=%d\n", __func__, rc);
- }
-
- CDBG_ERROR("Close camera");
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: preview re-reprocess Fails for Camera %d", __func__, i);
- rc = -1;
- break;
- }
- }
-end:
- if (rc == 0) {
- printf("\nPassed\n");
- } else {
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-/* re-processing test case for preview and recording */
-int mm_app_tc_reprocess_preview_and_recording(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j,k;
- int result = 0;
-
- printf("\n Verifying reprocess for preview/recording on front and back camera...\n");
- if (cam_apps->num_cameras == 0) {
- CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("Re-processing test case for preview");
- for (i = 1; i < cam_apps->num_cameras; i++) {
- CDBG_ERROR("Open camera %d", i);
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("Prepare re-process");
- if ( MM_CAMERA_OK != (rc = prepareReprocess(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: prepareReprocess() err=%d\n", __func__, rc);
- break;
- }
- result = 0;
- for (k = 0; k < MM_QCAMERA_APP_INTERATION; k++) {
- CDBG_ERROR("Start preview with pp");
- if ( MM_CAMERA_OK != (rc = startPreviewPP(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreviewPP() err=%d\n", __func__, rc);
- break;
- }
-
- CDBG_ERROR("Let preview run for 1s");
- /* sleep for 1s */
- usleep(1000*1000);
-
- for (j = 0; j < 2; j++) {
- CDBG_ERROR("Start recording with pp");
- if ( MM_CAMERA_OK != (rc = startRecordPP(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startRecordPP() err=%d\n", __func__, rc);
- break;
- }
-
- CDBG_ERROR("Let recording run for 1s");
- /* sleep for 1s */
- usleep(1000*1000);
-
- CDBG_ERROR("Stop recording with pp");
- if ( MM_CAMERA_OK != (rc = stopRecordPP(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: stopRecordPP() err=%d\n", __func__, rc);
- break;
- }
- }
-
- CDBG_ERROR("Stop preview with pp");
- if ( MM_CAMERA_OK != (rc = stopPreviewPP(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: stopPreviewPP() err=%d\n", __func__, rc);
- break;
- }
- result++;
- usleep(10*1000);
- }
-
- CDBG_ERROR("Unprepare re-process");
- if ( MM_CAMERA_OK != (rc = unprepareReprocess(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: unprepareReprocess() err=%d\n", __func__, rc);
- }
-
- CDBG_ERROR("Close camera");
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: preview+recording re-reprocess Fails for Camera %d", __func__, i);
- rc = -1;
- break;
- }
- }
-end:
- if (rc == 0) {
- printf("\nPassed\n");
- } else {
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_preview.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_preview.c
deleted file mode 100755
index 045fa2b..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_preview.c
+++ /dev/null
@@ -1,1584 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <linux/msm_ion.h>
-#include "mm_qcamera_app.h"
-
-int mm_app_start_preview(int cam_id);
-int mm_app_start_preview_zsl(int cam_id);
-int mm_app_stop_preview_zsl(int cam_id);
-int mm_app_stop_preview_stats(int cam_id);
-int mm_app_start_preview_stats(int cam_id);
-
-extern int mm_stream_alloc_bufs(mm_camera_app_obj_t *pme,
- mm_camear_app_buf_t* app_bufs,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs);
-extern int mm_stream_release_bufs(mm_camera_app_obj_t *pme,
- mm_camear_app_buf_t* app_bufs);
-extern int mm_app_unprepare_video(int cam_id);
-extern int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,
- mm_camera_buf_def_t *frame);
-
-/*===========================================================================
- * FUNCTION - mm_camera_do_mmap_ion -
- *
- * DESCRIPTION:
- *==========================================================================*/
-uint8_t *mm_camera_do_mmap_ion(int ion_fd, struct ion_allocation_data *alloc,
- struct ion_fd_data *ion_info_fd, int *mapFd)
-{
- void *ret; /* returned virtual address */
- int rc = 0;
- struct ion_handle_data handle_data;
-
- /* to make it page size aligned */
- alloc->len = (alloc->len + 4095) & (~4095);
-
- rc = ioctl(ion_fd, ION_IOC_ALLOC, alloc);
- if (rc < 0) {
- CDBG_ERROR("ION allocation failed %s\n", strerror(errno));
- goto ION_ALLOC_FAILED;
- }
-
- ion_info_fd->handle = alloc->handle;
- rc = ioctl(ion_fd, ION_IOC_SHARE, ion_info_fd);
- if (rc < 0) {
- CDBG_ERROR("ION map failed %s\n", strerror(errno));
- goto ION_MAP_FAILED;
- }
- *mapFd = ion_info_fd->fd;
- ret = mmap(NULL,
- alloc->len,
- PROT_READ | PROT_WRITE,
- MAP_SHARED,
- *mapFd,
- 0);
-
- if (ret == MAP_FAILED) {
- CDBG_ERROR("ION_MMAP_FAILED: %s (%d)\n", strerror(errno), errno);
- goto ION_MAP_FAILED;
- }
-
- return ret;
-
- ION_MAP_FAILED:
- handle_data.handle = ion_info_fd->handle;
- ioctl(ion_fd, ION_IOC_FREE, &handle_data);
- ION_ALLOC_FAILED:
- return NULL;
-}
-
-/*===========================================================================
- * FUNCTION - mm_camera_do_munmap_ion -
- *
- * DESCRIPTION:
- *==========================================================================*/
-int mm_camera_do_munmap_ion (int ion_fd, struct ion_fd_data *ion_info_fd,
- void *addr, size_t size)
-{
- int rc = 0;
- rc = munmap(addr, size);
- close(ion_info_fd->fd);
-
- struct ion_handle_data handle_data;
- handle_data.handle = ion_info_fd->handle;
- ioctl(ion_fd, ION_IOC_FREE, &handle_data);
- return rc;
-}
-
-
-int mm_app_set_preview_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = pme->dim.prev_format;
- fmt->width = pme->dim.display_width;
- fmt->height = pme->dim.display_height;
- return rc;
-}
-
-int mm_app_set_aec_stats_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = CAMERA_SAEC;
- fmt->width = 1060; //hard code for testing
- fmt->height = 1;
- return rc;
-}
-
-int mm_app_set_awb_stats_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = CAMERA_SAWB;
- fmt->width = 1060; //hard code for testing
- fmt->height = 1;
- return rc;
-}
-
-int mm_app_set_af_stats_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = CAMERA_SAFC;
- fmt->width = 1060; //hard code for testing
- fmt->height = 1;
- return rc;
-}
-
-
-int mm_app_set_ihist_stats_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = CAMERA_SHST;
- fmt->width = 1060; //hard code for testing
- fmt->height = 1;
- return rc;
-}
-
-//void dumpFrameToFile(struct msm_frame* newFrame, int w, int h, char* name, int main_422)
-void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h, char* name, int main_422,char *ext)
-{
- char buf[50];
- int file_fd;
- int i;
- if ( newFrame != NULL) {
- char * str;
- snprintf(buf, sizeof(buf), "/data/%s.%s", name, ext);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- if (file_fd < 0) {
- CDBG_ERROR("%s: cannot open file %s \n", __func__, buf);
- } else {
- void* y_off = newFrame->buffer + newFrame->planes[0].data_offset;
- void* cbcr_off = newFrame->buffer + newFrame->planes[0].length;
-
- CDBG("%s: %s Y_off = %p cbcr_off = %p", __func__, name, y_off,cbcr_off);
- CDBG("%s: Y_off length = %d cbcr_off length = %d", __func__, newFrame->planes[0].length,newFrame->planes[1].length);
-
- write(file_fd, (const void *)(y_off), (w * h));
- if (newFrame->num_planes > 1)
- write(file_fd, (const void *)(cbcr_off), (w * h/2 * main_422));
-
- close(file_fd);
- CDBG("dump %s", buf);
- }
- }
-}
-
-int mm_app_open_camera(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int value = 0;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (pme->cam_mode == CAMERA_MODE) {
- return rc;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))) {
- CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
- goto end;
- }
-
- pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_RECORDING_HINT, &value);
-
- if (MM_CAMERA_OK != (rc = mm_app_start_preview(cam_id))) {
- CDBG_ERROR("%s:Start preview err=%d\n", __func__, rc);
- goto end;
- }
-
- pme->cam_mode = CAMERA_MODE;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_open_camera_stats(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int value = 0;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (pme->cam_mode == CAMERA_MODE) {
- return rc;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview_stats(cam_id))) {
- CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
- goto end;
- }
-
- pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_RECORDING_HINT, &value);
-
- if (MM_CAMERA_OK != (rc = mm_app_start_preview_stats(cam_id))) {
- CDBG_ERROR("%s:Start preview err=%d\n", __func__, rc);
- goto end;
- }
-
- pme->cam_mode = CAMERA_MODE;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_open_zsl(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int value = 0;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (pme->cam_mode == ZSL_MODE) {
- return rc;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))) {
- CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
- goto end;
- }
-
- pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_RECORDING_HINT, &value);
-
- if (MM_CAMERA_OK != (rc = mm_app_start_preview_zsl(cam_id))) {
- CDBG_ERROR("%s:stream on preview err=%d\n", __func__, rc);
- goto end;
- }
- pme->cam_mode = ZSL_MODE;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-#if 0
-int mm_stream_deinit_preview_buf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs)
-{
- int i, rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
- for (i = 0; i < num_bufs; i++) {
- rc = my_cam_app.hal_lib.mm_camera_do_munmap_ion (pme->ionfd, &(pme->preview_buf.frame[i].fd_data),
- (void *)pme->preview_buf.frame[i].buffer, bufs[i].frame_len);
- if (rc != MM_CAMERA_OK) {
- CDBG("%s: mm_camera_do_munmap err, pmem_fd = %d, rc = %d",
- __func__, bufs[i].fd, rc);
- }
- }
- close(pme->ionfd);
- return rc;
-}
-
-int mm_stream_init_preview_buf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- int i,j,num_planes, frame_len, y_off, cbcr_off;
- uint32_t planes[VIDEO_MAX_PLANES];
- uint32_t pmem_addr = 0;
-
- mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-
- num_planes = frame_offset_info->num_planes;
- for ( i = 0; i < num_planes; i++) {
- planes[i] = frame_offset_info->mp[i].len;
- }
-
- frame_len = frame_offset_info->frame_len;
- y_off = frame_offset_info->mp[0].offset;
- cbcr_off = frame_offset_info->mp[1].offset;
-
- CDBG("Allocating Preview Memory for %d buffers frame_len = %d",num_bufs,frame_offset_info->frame_len);
-
- for (i = 0; i < num_bufs ; i++) {
- int j;
- pme->preview_buf.reg[i] = 1;
- initial_reg_flag[i] = 1;
-
- pme->preview_buf.frame_len = frame_len;
- pme->preview_buf.frame[i].ion_alloc.len = pme->preview_buf.frame_len;
- pme->preview_buf.frame[i].ion_alloc.flags =
- (0x1 << CAMERA_ION_HEAP_ID | 0x1 << ION_IOMMU_HEAP_ID);
- pme->preview_buf.frame[i].ion_alloc.align = 4096;
-
- pmem_addr = (unsigned long) my_cam_app.hal_lib.mm_camera_do_mmap_ion(pme->ionfd,
- &(pme->preview_buf.frame[i].ion_alloc), &(pme->preview_buf.frame[i].fd_data),
- &pme->preview_buf.frame[i].fd);
-
- pme->preview_buf.frame[i].buffer = pmem_addr;
- pme->preview_buf.frame[i].path = OUTPUT_TYPE_P;
- pme->preview_buf.frame[i].y_off = 0;
- pme->preview_buf.frame[i].cbcr_off = planes[0];
- pme->preview_buf.frame[i].phy_offset = 0;
-
- CDBG("Buffer allocated Successfully fd = %d",pme->preview_buf.frame[i].fd);
-
- bufs[i].fd = pme->preview_buf.frame[i].fd;
- //bufs[i].buffer = pmem_addr;
- bufs[i].frame_len = pme->preview_buf.frame[i].ion_alloc.len;
- bufs[i].num_planes = num_planes;
-
- bufs[i].frame = &pme->preview_buf.frame[i];
-
- /* Plane 0 needs to be set seperately. Set other planes
- * in a loop. */
- bufs[i].planes[0].length = planes[0];
- bufs[i].planes[0].m.userptr = bufs[i].fd;
- bufs[i].planes[0].data_offset = y_off;
- bufs[i].planes[0].reserved[0] = 0;
- //buf_def->buf.mp[i].frame_offset;
- for (j = 1; j < num_planes; j++) {
- bufs[i].planes[j].length = planes[j];
- bufs[i].planes[j].m.userptr = bufs[i].fd;
- bufs[i].planes[j].data_offset = cbcr_off;
- bufs[i].planes[j].reserved[0] =
- bufs[i].planes[j-1].reserved[0] +
- bufs[i].planes[j-1].length;
- }
- }
- return MM_CAMERA_OK;
-}
-#endif
-
-int mm_stream_initbuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
- mm_camear_app_buf_t* app_bufs = NULL;
- int i, rc;
-
- if (MM_CAMERA_MAX_NUM_FRAMES < num_bufs) {
- CDBG_ERROR("%s: num_bufs (%d) exceeds max (%d)",
- __func__, num_bufs, MM_CAMERA_MAX_NUM_FRAMES);
- return -1;
- }
- for (i = 0; i < MM_QCAM_APP_MAX_STREAM_NUM; i++) {
- if (pme->stream[i].id == stream_id) {
- app_bufs = &pme->stream [i].app_bufs;
- break;
- }
- }
-
- if (app_bufs == NULL) {
- CDBG_ERROR("%s: no matching stream for stream_id %d", __func__, stream_id);
- return -1;
- }
-
- CDBG("%s: alloc buf for stream_id %d, len=%d",
- __func__, stream_id, frame_offset_info->frame_len);
- rc = mm_stream_alloc_bufs(pme,
- app_bufs,
- frame_offset_info,
- num_bufs);
-
- if (rc != 0) {
- CDBG_ERROR("%s: mm_stream_alloc_bufs err = %d", __func__, rc);
- return rc;
- }
-
- memcpy(bufs, app_bufs->bufs, sizeof(mm_camera_buf_def_t) * num_bufs);
- for (i = 0; i < num_bufs ; i++) {
- initial_reg_flag[i] = 1;
- }
-
- CDBG("%s: X",__func__);
- return MM_CAMERA_OK;
-}
-
-#if 0
-int mm_stream_initbuf_1(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- int i;
- int streamType = 0;
-
- mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s : E ", __FUNCTION__);
-
- for (i= 0; i < 5; i++) {
- if (pme->stream[i].id == stream_id) {
- CDBG("Allocate Memory for Stream %d",i);
- streamType = i;
- break;
- }
- }
-
- streamType = MM_CAMERA_PREVIEW;
- switch (streamType) {
- case MM_CAMERA_PREVIEW:
- mm_stream_init_preview_buf( camera_handle,
- ch_id, stream_id,
- user_data,
- frame_offset_info,
- num_bufs,
- initial_reg_flag,
- bufs);
- break;
- case MM_CAMERA_VIDEO:
- mm_stream_init_video_buf( camera_handle,
- ch_id, stream_id,
- user_data,
- frame_offset_info,
- num_bufs,
- initial_reg_flag,
- bufs);
- break;
- case MM_CAMERA_SNAPSHOT_MAIN:
- mm_stream_init_main_buf( camera_handle,
- ch_id, stream_id,
- user_data,
- frame_offset_info,
- num_bufs,
- initial_reg_flag,
- bufs);
- break;
- case MM_CAMERA_SNAPSHOT_THUMBNAIL:
- mm_stream_init_thumbnail_buf( camera_handle,
- ch_id, stream_id,
- user_data,
- frame_offset_info,
- num_bufs,
- initial_reg_flag,
- bufs);
- break;
- default:
- break;
- }
-
- CDBG(" %s : X ",__FUNCTION__);
- return MM_CAMERA_OK;
-}
-#endif
-int mm_stream_deinitbuf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs)
-{
- int i, rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
- mm_camear_app_buf_t* app_bufs = NULL;
-
- for (i = 0; i < MM_QCAM_APP_MAX_STREAM_NUM; i++) {
- if (pme->stream[i].id == stream_id) {
- app_bufs = &pme->stream [i].app_bufs;
- break;
- }
- }
-
- if (app_bufs == NULL) {
- CDBG_ERROR("%s: no matching stream for stream_id %d", __func__, stream_id);
- return -1;
- }
-
- rc = mm_stream_release_bufs(pme, app_bufs);
-
- if (rc != 0) {
- CDBG_ERROR("%s: mm_stream_release_bufs err = %d", __func__, rc);
- }
-
- return rc;
-}
-
-#if 0
-static int mm_stream_deinitbuf_1(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs)
-{
- int i, rc = MM_CAMERA_OK;
- int streamType = 0;
- mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
- CDBG("%s: BEGIN",__func__);
-
- for (i= 0; i < 5; i++) {
- if (pme->stream[i].id == stream_id) {
- CDBG("Allocate Memory for Stream %d",i);
- streamType = i;
- break;
- }
- }
- streamType = MM_CAMERA_PREVIEW;
- switch (streamType) {
- case MM_CAMERA_PREVIEW:
- mm_stream_deinit_preview_buf(camera_handle,
- ch_id, stream_id,
- user_data, num_bufs,
- bufs);
- break;
- case MM_CAMERA_VIDEO:
- mm_stream_deinit_video_buf(camera_handle,
- ch_id, stream_id,
- user_data, num_bufs,
- bufs);
- break;
- case MM_CAMERA_SNAPSHOT_MAIN:
- mm_stream_deinit_main_buf(camera_handle,
- ch_id, stream_id,
- user_data, num_bufs,
- bufs);
- break;
- case MM_CAMERA_SNAPSHOT_THUMBNAIL:
- mm_stream_deinit_thumbnail_buf(camera_handle,
- ch_id, stream_id,
- user_data, num_bufs,
- bufs);
- break;
- default:
- break;
- }
-
- /* zero out the buf stuct */
- CDBG("%s: END",__func__);
- return MM_CAMERA_OK;
-}
-#endif
-
-void preview_cb_signal(mm_camera_app_obj_t *pme)
-{
- if (pme->cam_state == CAMERA_STATE_PREVIEW && pme->cam_mode == CAMERA_MODE) {
- mm_camera_app_done();
- }
-}
-
-void previewzsl_cb_signal(mm_camera_app_obj_t *pme)
-{
- if (pme->cam_state == CAMERA_STATE_PREVIEW && pme->cam_mode == ZSL_MODE) {
- mm_camera_app_done();
- }
-}
-
-
-void mm_app_preview_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc, cam = 0;
- char buf[32];
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[MM_CAMERA_PREVIEW];
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
- snprintf(buf, sizeof(buf), "P_%dx%d_C%d", pme->dim.display_width,
- pme->dim.display_height, pme->cam->camera_info->camera_id);
-
- dumpFrameToFile(frame, pme->dim.display_width,
- pme->dim.display_height, buf, 1,"yuv");
-
- if (!my_cam_app.run_sanity) {
- if (0 != (rc = mm_app_dl_render(frame->fd, NULL))) {
- CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
- __func__, rc, frame->fd, frame->frame_idx);
- }
- }
-
- CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_PREVIEW],frame);
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
- CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- if (my_cam_app.run_sanity) {
- preview_cb_signal(pme);
- }
- CDBG("%s: END\n", __func__);
-
-}
-
-void mm_app_aec_stats_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[0];
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
- CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
- __func__, rc, frame->fd, frame->frame_idx);
- CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_SAEC],frame);
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
- CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- CDBG("%s: END\n", __func__);
-}
-
-void mm_app_awb_stats_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[0];
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
- CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
- __func__, rc, frame->fd, frame->frame_idx);
- CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_SAWB],frame);
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
- CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- CDBG("%s: END\n", __func__);
-}
-
-void mm_app_af_stats_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[0] ;
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
- CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
- __func__, rc, frame->fd, frame->frame_idx);
- CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_SAFC],frame);
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
- CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- CDBG("%s: END\n", __func__);
-}
-
-void mm_app_ihist_stats_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[0] ;
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
- CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
- __func__, rc, frame->fd, frame->frame_idx);
- CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_IHST],frame);
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame)) {
- CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- CDBG("%s: END\n", __func__);
-}
-
-static void mm_app_zsl_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- int i = 0;
- mm_camera_buf_def_t *preview_frame = NULL;
- mm_camera_buf_def_t *main_frame = NULL;
- mm_camera_buf_def_t *thumb_frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
-
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s : total streams = %d",__func__,bufs->num_bufs);
- preview_frame = bufs->bufs[0] ;
- main_frame = bufs->bufs[1];
- thumb_frame = bufs->bufs[0];
-
- //dumpFrameToFile(preview_frame->frame,pme->dim.display_width,pme->dim.display_height,"preview", 1);
- dumpFrameToFile(preview_frame,pme->dim.display_width,pme->dim.display_height,"zsl_preview", 1,"yuv");
- if (0 != (rc = mm_app_dl_render(preview_frame->fd, NULL))) {
- CDBG("%s:DL rendering err=%d, frame fd=%d,frame idx = %d\n",
- __func__, rc, preview_frame->fd, preview_frame->frame_idx);
- }
-
- if (bufs->num_bufs == 2 && main_frame != NULL) {
- CDBG("mainframe frame_idx = %d fd = %d frame length = %d",main_frame->frame_idx,main_frame->fd,main_frame->frame_len);
- CDBG("thumnail frame_idx = %d fd = %d frame length = %d",thumb_frame->frame_idx,thumb_frame->fd,thumb_frame->frame_len);
-
- //dumpFrameToFile(main_frame->frame,pme->dim.picture_width,pme->dim.picture_height,"main", 1);
- //dumpFrameToFile(thumb_frame->frame,pme->dim.thumbnail_width,pme->dim.thumbnail_height,"thumb", 1);
-
- dumpFrameToFile(main_frame,pme->dim.picture_width,pme->dim.picture_height,"zsl_main", 1,"yuv");
- dumpFrameToFile(thumb_frame,pme->dim.thumbnail_width,pme->dim.thumbnail_height,"zsl_thumb", 1,"yuv");
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,main_frame)) {
- CDBG_ERROR("%s: Failed in thumbnail Qbuf\n", __func__);
- }
- mm_stream_invalid_cache(pme,main_frame);
- }
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,preview_frame)) {
- CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
- }
- mm_stream_invalid_cache(pme,preview_frame);
- if (my_cam_app.run_sanity) {
- previewzsl_cb_signal(pme);
- }
- CDBG("%s: END\n", __func__);
-}
-
-int mm_app_prepare_stats(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int op_mode;
-
- CDBG("%s: E",__func__);
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- pme->mem_cam->get_buf = mm_stream_initbuf;
- pme->mem_cam->put_buf = mm_stream_deinitbuf;
- pme->mem_cam->user_data = pme;
- // AEC Stream
- pme->stream[MM_CAMERA_SAEC].id =
- pme->cam->ops->add_stream(pme->cam->camera_handle, pme->ch_id,
- mm_app_aec_stats_notify_cb, pme,
- MM_CAMERA_SAEC, 0);
- if (!pme->stream[MM_CAMERA_SAEC].id) {
- CDBG_ERROR("%s:Add MM_CAMERA_SAEC error =%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("%s :Add stream is successful stream ID = %d",__func__,pme->stream[MM_CAMERA_SAEC].id);
-
- mm_app_set_aec_stats_fmt(cam_id,&pme->stream[MM_CAMERA_SAEC].str_config.fmt);
- pme->stream[MM_CAMERA_SAEC].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_SAEC].str_config.num_of_bufs = STATS_BUF_NUM;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAEC].id,
- &pme->stream[MM_CAMERA_SAEC].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
- // AWB Stream
- pme->stream[MM_CAMERA_SAWB].id =
- pme->cam->ops->add_stream(pme->cam->camera_handle, pme->ch_id,
- mm_app_awb_stats_notify_cb, pme,
- MM_CAMERA_SAWB, 0);
- if (!pme->stream[MM_CAMERA_SAWB].id) {
- CDBG_ERROR("%s:Add MM_CAMERA_SAWB error =%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("%s :Add stream is successful stream ID = %d",__func__,pme->stream[MM_CAMERA_SAWB].id);
-
- mm_app_set_awb_stats_fmt(cam_id,&pme->stream[MM_CAMERA_SAWB].str_config.fmt);
- pme->stream[MM_CAMERA_SAWB].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_SAWB].str_config.num_of_bufs = STATS_BUF_NUM;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAWB].id,
- &pme->stream[MM_CAMERA_SAWB].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
-
- // AF Stream
- pme->stream[MM_CAMERA_SAFC].id =
- pme->cam->ops->add_stream(pme->cam->camera_handle, pme->ch_id,
- mm_app_af_stats_notify_cb, pme,
- MM_CAMERA_SAFC, 0);
- if (!pme->stream[MM_CAMERA_SAFC].id) {
- CDBG_ERROR("%s:Add MM_CAMERA_SAFC error =%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("%s :Add stream is successful stream ID = %d",__func__,pme->stream[MM_CAMERA_SAFC].id);
-
- mm_app_set_af_stats_fmt(cam_id,&pme->stream[MM_CAMERA_SAFC].str_config.fmt);
- pme->stream[MM_CAMERA_SAFC].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_SAFC].str_config.num_of_bufs = STATS_BUF_NUM;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAFC].id,
- &pme->stream[MM_CAMERA_SAFC].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
-
- // HIST Stream
- pme->stream[MM_CAMERA_IHST].id =
- pme->cam->ops->add_stream(pme->cam->camera_handle, pme->ch_id,
- mm_app_ihist_stats_notify_cb, pme,
- MM_CAMERA_IHST, 0);
- if (!pme->stream[MM_CAMERA_IHST].id) {
- CDBG_ERROR("%s:Add MM_CAMERA_IHST error =%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG_ERROR("%s :Add stream is successful stream ID = %d",__func__,pme->stream[MM_CAMERA_IHST].id);
-
- mm_app_set_ihist_stats_fmt(cam_id,&pme->stream[MM_CAMERA_IHST].str_config.fmt);
- pme->stream[MM_CAMERA_IHST].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_IHST].str_config.num_of_bufs = STATS_BUF_NUM;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_IHST].id,
- &pme->stream[MM_CAMERA_IHST].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
-
- end:
- return rc;
-}
-
-int mm_app_prepare_preview(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int op_mode;
-
- CDBG("%s: E",__func__);
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- pme->mem_cam->get_buf = mm_stream_initbuf;
- pme->mem_cam->put_buf = mm_stream_deinitbuf;
- pme->mem_cam->user_data = pme;
-
- op_mode = MM_CAMERA_OP_MODE_VIDEO;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
- pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode))) {
- CDBG_ERROR("%s: Set preview op mode error",__func__);
- goto end;
- }
-
- pme->stream[MM_CAMERA_PREVIEW].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
- mm_app_preview_notify_cb,pme,
- MM_CAMERA_PREVIEW, 0);
-
- if (!pme->stream[MM_CAMERA_PREVIEW].id) {
- CDBG_ERROR("%s:Add stream preview error =%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG("%s :Add stream is successfull stream ID = %d",__func__,pme->stream[MM_CAMERA_PREVIEW].id);
-
- mm_app_set_preview_fmt(cam_id,&pme->stream[MM_CAMERA_PREVIEW].str_config.fmt);
- pme->stream[MM_CAMERA_PREVIEW].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_PREVIEW].str_config.num_of_bufs = PREVIEW_BUF_NUM;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id,
- &pme->stream[MM_CAMERA_PREVIEW].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
- end:
- return rc;
-}
-
-int mm_app_unprepare_preview(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- return rc;
-}
-
-int mm_app_streamon_stats(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream_aec[2], stream_af[2], stream_awb[2], stream_ihist[2];
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- mm_camera_frame_len_offset frame_offset_info;
-
- stream_aec[0] = pme->stream[MM_CAMERA_SAEC].id;
- stream_aec[1] = 0;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,stream_aec))) {
- CDBG_ERROR("%s : Start Stats Stream Error",__func__);
- goto end;
- }
- stream_awb[0] = pme->stream[MM_CAMERA_SAWB].id;
- stream_awb[1] = 0;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,stream_awb))) {
- CDBG_ERROR("%s : Start Stats Stream Error",__func__);
- goto end;
- }
-
- stream_af[0] = pme->stream[MM_CAMERA_SAFC].id;
- stream_af[1] = 0;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,stream_af))) {
- CDBG_ERROR("%s : Start Stats Stream Error",__func__);
- goto end;
- }
-
- stream_ihist[0] = pme->stream[MM_CAMERA_IHST].id;
- stream_ihist[1] = 0;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,stream_ihist))) {
- CDBG_ERROR("%s : Start Stats Stream Error",__func__);
- goto end;
- }
-
- end:
- CDBG("%s: X rc = %d",__func__,rc);
- return rc;
-}
-
-
-int mm_app_streamon_preview(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- mm_camera_frame_len_offset frame_offset_info;
-
- stream = pme->stream[MM_CAMERA_PREVIEW].id;
-
- pme->cam->ops->get_stream_parm(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id,MM_CAMERA_STREAM_OFFSET,&frame_offset_info);
- ALOGE("DEBUG : length = %d",frame_offset_info.frame_len);
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,&stream))) {
- CDBG_ERROR("%s : Start Stream preview Error",__func__);
- goto end;
- }
- pme->cam_state = CAMERA_STATE_PREVIEW;
- end:
- CDBG("%s: X rc = %d",__func__,rc);
- return rc;
-}
-
-int mm_app_prepare_preview_zsl(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_bundle_attr_t attr;
- int stream[3];
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- int op_mode = 0;
-
- op_mode = MM_CAMERA_OP_MODE_ZSL;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
- pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode))) {
- CDBG_ERROR("%s: Set preview op mode error",__func__);
- goto end;
- }
-
- pme->stream[MM_CAMERA_PREVIEW].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
- mm_app_preview_notify_cb,pme,
- MM_CAMERA_PREVIEW, 0);
-
- if (!pme->stream[MM_CAMERA_PREVIEW].id) {
- CDBG_ERROR("%s:Add stream preview error =%d\n", __func__, rc);
- goto end;
- }
-
- CDBG("%s :Add stream is successfull stream ID = %d",__func__,pme->stream[MM_CAMERA_PREVIEW].id);
-
- mm_app_set_preview_fmt(cam_id,&pme->stream[MM_CAMERA_PREVIEW].str_config.fmt);
- pme->stream[MM_CAMERA_PREVIEW].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_PREVIEW].str_config.num_of_bufs = PREVIEW_BUF_NUM;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id,
- &pme->stream[MM_CAMERA_PREVIEW].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
-
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
- NULL,pme,
- MM_CAMERA_SNAPSHOT_MAIN, 0);
-
- CDBG("Add Snapshot main is successfull stream ID = %d",pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id);
- if (!pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.num_of_bufs = 7;
-
- mm_app_set_snapshot_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.fmt);
-
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
- &pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_streamon_preview_zsl(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_bundle_attr_t attr;
- uint32_t stream[2];
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- int op_mode = 0;
-
- stream[0] = pme->stream[MM_CAMERA_PREVIEW].id;
- stream[1] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-
- attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
- attr.burst_num = 1;
- attr.look_back = 2;
- attr.post_frame_skip = 0;
- attr.water_mark = 2;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->init_stream_bundle(
- pme->cam->camera_handle,pme->ch_id,mm_app_zsl_notify_cb,pme,&attr,2,stream))) {
- CDBG_ERROR("%s:init_stream_bundle err=%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,
- 2, stream))) {
- CDBG_ERROR("%s:start_streams err=%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
- pme->cam_state = CAMERA_STATE_PREVIEW;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-
-}
-
-int initDisplay()
-{
- int rc = MM_CAMERA_OK;
-
- use_overlay_fb_display_driver();
- if (launch_camframe_fb_thread()) {
- CDBG_ERROR("%s:launch_camframe_fb_thread failed!\n", __func__);
- //rc = -MM_CAMERA_E_GENERAL;
- }
- CDBG("%s: launch_camframe_fb_thread done\n", __func__);
- return rc;
-}
-
-int deinitDisplay()
-{
- /* stop the display thread */
- release_camframe_fb_thread();
- return MM_CAMERA_OK;
-}
-
-int mm_app_start_preview(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- int op_mode = 0;
-
- CDBG("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
- pme,pme->cam,pme->cam->camera_handle);
-
- if (pme->cam_state == CAMERA_STATE_PREVIEW) {
- return rc;
- }
-
- if (!my_cam_app.run_sanity) {
- if (MM_CAMERA_OK != initDisplay()) {
- CDBG_ERROR("%s : Could not initalize display",__func__);
- goto end;
- }
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_prepare_preview(cam_id))) {
- CDBG_ERROR("%s:Stream On Preview failed rc=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_streamon_preview(cam_id))) {
- CDBG_ERROR("%s:Stream On Preview failed rc=%d\n", __func__, rc);
- goto end;
- }
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_start_preview_stats(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- int op_mode = 0;
-
- CDBG("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
- pme,pme->cam,pme->cam->camera_handle);
-
- if (pme->cam_state == CAMERA_STATE_PREVIEW) {
- return rc;
- }
-
- if (!my_cam_app.run_sanity) {
- if (MM_CAMERA_OK != initDisplay()) {
- CDBG_ERROR("%s : Could not initalize display",__func__);
- goto end;
- }
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_prepare_stats(cam_id))) {
- CDBG_ERROR("%s:Prepare On Stats failed rc=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_prepare_preview(cam_id))) {
- CDBG_ERROR("%s:Stream On Preview failed rc=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_streamon_stats(cam_id))) {
- CDBG_ERROR("%s:Stream On Stats failed rc=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_streamon_preview(cam_id))) {
- CDBG_ERROR("%s:Stream On Preview failed rc=%d\n", __func__, rc);
- goto end;
- }
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-
-int mm_app_start_preview_zsl(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
- pme,pme->cam,pme->cam->camera_handle);
-
- if (!my_cam_app.run_sanity) {
- if (MM_CAMERA_OK != initDisplay()) {
- CDBG_ERROR("%s : Could not initalize display",__func__);
- goto end;
- }
- }
-
- pme->mem_cam->get_buf = mm_stream_initbuf;
- pme->mem_cam->put_buf = mm_stream_deinitbuf;
- pme->mem_cam->user_data = pme;
-
- if (MM_CAMERA_OK != (rc = mm_app_prepare_preview_zsl(cam_id))) {
- CDBG_ERROR("%s:Prepare preview err=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_streamon_preview_zsl(cam_id))) {
- CDBG_ERROR("%s:stream on preview err=%d\n", __func__, rc);
- goto end;
- }
-
- /*if(MM_CAMERA_OK != (rc = mm_app_bundle_zsl_stream(cam_id))){
- CDBG_ERROR("%s: bundle and start of ZSl err=%d\n", __func__, rc);
- goto end;
- }*/
-
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-static int mm_app_streamoff_stats(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream_aec[2], stream_af[2],stream_awb[2], stream_ihist[2];
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream_aec[0] = pme->stream[MM_CAMERA_SAEC].id;
- stream_aec[1] = 0;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream_aec))) {
- CDBG_ERROR("%s : Stats Stream off Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAEC].id))) {
- CDBG_ERROR("%s : Delete Stats Stream error",__func__);
- goto end;
- }
- CDBG("AEC: del_stream successfull");
- stream_awb[0] = pme->stream[MM_CAMERA_SAWB].id;
- stream_awb[1] = 0;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream_awb))) {
- CDBG_ERROR("%s : Stats Stream off Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAWB].id))) {
- CDBG_ERROR("%s : Delete Stats Stream error",__func__);
- goto end;
- }
- CDBG("AWB: del_stream successfull");
-
- stream_af[0] = pme->stream[MM_CAMERA_SAFC].id;
- stream_af[1] = 0;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1, stream_af))) {
- CDBG_ERROR("%s : Stats Stream off Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SAFC].id))) {
- CDBG_ERROR("%s : Delete Stats Stream error",__func__);
- goto end;
- }
- CDBG("AF: del_stream successfull");
-
-
- stream_ihist[0] = pme->stream[MM_CAMERA_IHST].id;
- stream_ihist[1] = 0;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream_ihist))) {
- CDBG_ERROR("%s : Stats Stream off Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_IHST].id))) {
- CDBG_ERROR("%s : Delete Stats Stream error",__func__);
- goto end;
- }
- CDBG("IHIST: del_stream successfull");
-
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
-
- return rc;
-}
-
-static int mm_app_streamoff_preview(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream = pme->stream[MM_CAMERA_PREVIEW].id;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,&stream))) {
- CDBG_ERROR("%s : Preview Stream off Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id))) {
- CDBG_ERROR("%s : Delete Stream Preview error",__func__);
- goto end;
- }
- CDBG("del_stream successfull");
- pme->cam_state = CAMERA_STATE_OPEN;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
-
- return rc;
-}
-
-static int mm_app_streamoff_preview_zsl(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[2];
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream[0] = pme->stream[MM_CAMERA_PREVIEW].id;
- stream[1] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,2,stream))) {
- CDBG_ERROR("%s : Preview Stream off Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->destroy_stream_bundle(pme->cam->camera_handle,pme->ch_id))) {
- CDBG_ERROR("%s : ZSL Snapshot destroy_stream_bundle Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id))) {
- CDBG_ERROR("%s : Delete Stream Preview error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id))) {
- CDBG_ERROR("%s : Delete Stream Preview error",__func__);
- goto end;
- }
- CDBG("del_stream successfull");
- pme->cam_state = CAMERA_STATE_OPEN;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
-
- return rc;
-}
-
-int startPreview(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: Start Preview",__func__);
-
- if (pme->cam_mode == ZSL_MODE || pme->cam_mode == RECORDER_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_RECORD:
- if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
- CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
- return -1;
- }
- case CAMERA_STATE_PREVIEW:
- if (MM_CAMERA_OK != mm_app_open_camera(cam_id)) {
- CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
- return -1;
- }
- break;
- case CAMERA_STATE_SNAPSHOT:
- default:
- break;
- }
- } else if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_OPEN) {
-
- if (MM_CAMERA_OK != (rc = mm_app_start_preview(cam_id))) {
- CDBG_ERROR("%s:preview streaming on err=%d\n", __func__, rc);
- return -1;
- }
- }
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int stopPreview(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s : pme->cam_mode = %d, pme->cam_state = %d",__func__,pme->cam_mode,pme->cam_state);
-
- if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))) {
- CDBG("%s:streamoff preview err=%d\n", __func__, rc);
- goto end;
- }
- } else if (pme->cam_mode == ZSL_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview_zsl(cam_id))) {
- CDBG("%s:streamoff preview err=%d\n", __func__, rc);
- goto end;
- }
- } else if (pme->cam_mode == RECORDER_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))) {
- CDBG("%s:streamoff preview err=%d\n", __func__, rc);
- goto end;
- }
- mm_app_unprepare_video(cam_id);
- }
- end:
- return rc;
-}
-
-int startStats(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: Start Preview",__func__);
-
- if (pme->cam_mode == ZSL_MODE || pme->cam_mode == RECORDER_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_RECORD:
- if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
- CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
- return -1;
- }
- case CAMERA_STATE_PREVIEW:
- if (MM_CAMERA_OK != mm_app_open_camera_stats(cam_id)) {
- CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
- return -1;
- }
- break;
- case CAMERA_STATE_SNAPSHOT:
- default:
- break;
- }
- } else if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_OPEN) {
-
- if (MM_CAMERA_OK != (rc = mm_app_start_preview_stats(cam_id))) {
- CDBG_ERROR("%s:preview streaming on err=%d\n", __func__, rc);
- return -1;
- }
- }
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int stopStats(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s : pme->cam_mode = %d, pme->cam_state = %d",__func__,pme->cam_mode,pme->cam_state);
-
- if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview_stats(cam_id))) {
- CDBG("%s:streamoff preview err=%d\n", __func__, rc);
- goto end;
- }
- } else if (pme->cam_mode == ZSL_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview_zsl(cam_id))) {
- CDBG("%s:streamoff preview err=%d\n", __func__, rc);
- goto end;
- }
- } else if (pme->cam_mode == RECORDER_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- if (MM_CAMERA_OK != (rc = mm_app_stop_preview_stats(cam_id))) {
- CDBG("%s:streamoff preview err=%d\n", __func__, rc);
- goto end;
- }
- mm_app_unprepare_video(cam_id);
- }
- end:
- return rc;
-}
-
-int mm_app_stop_preview(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (MM_CAMERA_OK != (rc = mm_app_streamoff_preview(cam_id))) {
- CDBG_ERROR("%s : Delete Stream Preview error",__func__);
- goto end;
- }
- CDBG("Stop Preview successfull");
-
- if (!my_cam_app.run_sanity) {
- deinitDisplay();
- }
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_stop_preview_stats(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (MM_CAMERA_OK != (rc = mm_app_streamoff_stats(cam_id))) {
- CDBG_ERROR("%s : Delete Stream Stats error",__func__);
- goto end;
- }
- if (MM_CAMERA_OK != (rc = mm_app_streamoff_preview(cam_id))) {
- CDBG_ERROR("%s : Delete Stream Preview error",__func__);
- goto end;
- }
- CDBG("Stop Preview successfull");
-
- if (!my_cam_app.run_sanity) {
- deinitDisplay();
- }
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_stop_preview_zsl(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (MM_CAMERA_OK != (rc = mm_app_streamoff_preview_zsl(cam_id))) {
- CDBG_ERROR("%s : Delete Stream Preview error",__func__);
- goto end;
- }
-
- CDBG("Stop Preview successfull");
- if (!my_cam_app.run_sanity) {
- deinitDisplay();
- }
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_rdi.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_rdi.c
deleted file mode 100755
index 6cfa9c6..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_rdi.c
+++ /dev/null
@@ -1,427 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <linux/msm_ion.h>
-#include "mm_qcamera_app.h"
-
-/*typedef enum {
- STREAM_IMAGE,
- STREAM_RAW,
- STREAM_IMAGE_AND_RAW,
- STREAM_RAW_AND_RAW,
- STREAM_MAX,
-} mm_camera_channel_stream_info_t;*/
-
-#define RDI_MASK STREAM_RAW
-mm_camera_channel_stream_info_t rdi_mode;
-static int rdi_op_mode;
-extern int stopPreview(int cam_id);
-extern void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h,
- char* name, int main_422,char *ext);
-extern int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,
- mm_camera_buf_def_t *frame);
-
-static int rdi_counter = 0;
-static void dumpRdi(mm_camera_buf_def_t* newFrame, int w, int h, char* name, int main_422)
-{
- char buf[32];
- int file_fd;
- int i;
- char *ext = "yuv";
- if ( newFrame != NULL) {
- char * str;
- snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name, rdi_counter, ext);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- if (file_fd < 0) {
- CDBG_ERROR("%s: cannot open file\n", __func__);
- } else {
- void *y_off = newFrame->buffer + newFrame->planes[0].data_offset;
- //int cbcr_off = newFrame->buffer + newFrame->planes[1].data_offset;//newFrame->buffer + newFrame->planes[0].length;
- void *cbcr_off = newFrame->buffer + newFrame->planes[0].length;
- CDBG("%s: Y_off = %p cbcr_off = %p", __func__, y_off,cbcr_off);
- CDBG("%s: Y_off length = %d cbcr_off length = %d", __func__, newFrame->planes[0].length,newFrame->planes[1].length);
-
- write(file_fd, (const void *)(y_off), newFrame->planes[0].length);
- write(file_fd, (const void *)(cbcr_off),
- (newFrame->planes[1].length * newFrame->num_planes));
- close(file_fd);
- CDBG("dump %s", buf);
- }
- }
-}
-
-static int mm_app_set_opmode(int cam_id, mm_camera_op_mode_type_t op_mode)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- CDBG_ERROR("%s: Set rdi op mode = %d",__func__, op_mode);
- if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
- pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode))) {
- CDBG_ERROR("%s: Set rdi op mode error mode = %d",__func__, op_mode);
- }
- return rc;
-}
-
-static int mm_app_set_rdi_fmt(int cam_id, mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- cam_ctrl_dimension_t dim;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- //pme->cam->ops->get_parm(pme->cam->camera_handle,MM_CAMERA_PARM_DIMENSION, &dim);
- fmt->fmt = pme->dim.rdi0_format;
- fmt->width = 0;
- fmt->height = 0;
- fmt->rotation = 0;
-
- CDBG("%s: RDI Dimensions = %d X %d", __func__, fmt->width, fmt->height);
- return rc;
-}
-
-int mm_app_open_rdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int value = RDI_MASK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (pme->cam_mode == RDI_MODE) {
- return rc;
- }
-
- if (MM_CAMERA_OK != (rc = stopPreview(cam_id))) {
- CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
- goto end;
- }
- pme->cam_mode = RDI_MODE;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-void rdi_cb_signal(mm_camera_app_obj_t *pme)
-{
- if (pme->cam_mode == RDI_MODE) {
- mm_camera_app_done();
- }
-}
-
-static void mm_app_rdi_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[0] ;
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
-
- if (rdi_op_mode == MM_CAMERA_OP_MODE_VIDEO)
- dumpFrameToFile(frame,pme->dim.rdi0_width,pme->dim.rdi0_height,"rdi_p", 1,"raw");
- else {
- rdi_counter++;
- if (rdi_counter <=5)
- dumpRdi(frame,pme->dim.rdi0_width,pme->dim.rdi0_height,"rdi_s", 1);
- }
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,
- pme->ch_id,
- frame)) {
- CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- if (my_cam_app.run_sanity) {
- mm_camera_app_done(pme);
- }
- CDBG("%s: END\n", __func__);
-
-}
-
-int mm_app_prepare_rdi(int cam_id, uint8_t num_buf)
-{
- int rc = MM_CAMERA_OK;
- int op_mode;
- int value = RDI_MASK;
-
- CDBG("%s: E",__func__);
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- pme->mem_cam->get_buf = mm_stream_initbuf;
- pme->mem_cam->put_buf = mm_stream_deinitbuf;
- pme->mem_cam->user_data = pme;
-
- //pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_CH_INTERFACE, &value);
- //pme->cam->ops->get_parm(pme->cam->camera_handle,MM_CAMERA_PARM_CH_INTERFACE, &rdi_mode);
-
- pme->stream[MM_CAMERA_RDI].id = pme->cam->ops->add_stream(pme->cam->camera_handle,
- pme->ch_id,
- mm_app_rdi_notify_cb,
- pme,
- MM_CAMERA_RDI,
- 0);
-
- if (!pme->stream[MM_CAMERA_RDI].id) {
- CDBG_ERROR("%s:Add RDI error =%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
- CDBG("%s :Add RDI stream is successfull stream ID = %d",__func__,pme->stream[MM_CAMERA_RDI].id);
-
- mm_app_set_rdi_fmt(cam_id,&pme->stream[MM_CAMERA_RDI].str_config.fmt);
- pme->stream[MM_CAMERA_RDI].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_RDI].str_config.num_of_bufs = num_buf;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_RDI].id,
- &pme->stream[MM_CAMERA_RDI].str_config))) {
- CDBG_ERROR("%s:RDI streaming err=%d\n", __func__, rc);
- goto end;
- }
- end:
- return rc;
-}
-
-int mm_app_unprepare_rdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- return rc;
-}
-
-int mm_app_streamon_rdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[2];
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- int num_of_streams;
-
- /*if(rdi_mode == STREAM_IMAGE_AND_RAW){
- num_of_streams = 2;
- stream[0] = pme->stream[MM_CAMERA_RDI].id;
- stream[1] = pme->stream[MM_CAMERA_PREVIEW].id;
- }else */{
- num_of_streams = 1;
- stream[0] = pme->stream[MM_CAMERA_RDI].id;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,
- pme->ch_id,
- num_of_streams,
- stream))) {
- CDBG_ERROR("%s : Start RDI Stream preview Error",__func__);
- goto end;
- }
- pme->cam_state = CAMERA_STATE_RDI;
- end:
- CDBG("%s: X rc = %d",__func__,rc);
- return rc;
-}
-
-int mm_app_start_rdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- int op_mode = 0;
-
- CDBG_ERROR("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
- pme,pme->cam,pme->cam->camera_handle);
-
- if (pme->cam_state == CAMERA_STATE_RDI) {
- return rc;
- }
-
- rdi_op_mode = MM_CAMERA_OP_MODE_VIDEO;
- mm_app_set_opmode(cam_id, MM_CAMERA_OP_MODE_VIDEO);
-
- if (MM_CAMERA_OK != (rc = mm_app_prepare_rdi(cam_id, 7))) {
- CDBG_ERROR("%s:Prepare RDI failed rc=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_streamon_rdi(cam_id))) {
- CDBG_ERROR("%s:Stream On RDI failed rc=%d\n", __func__, rc);
- goto end;
- }
-
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-static int mm_app_streamoff_rdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[2];
- int num_of_streams;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- /*if(rdi_mode == STREAM_IMAGE_AND_RAW){
- num_of_streams = 2;
- stream[0] = pme->stream[MM_CAMERA_RDI].id;
- stream[1] = pme->stream[MM_CAMERA_PREVIEW].id;
- }else*/{
- num_of_streams = 1;
- stream[0] = pme->stream[MM_CAMERA_RDI].id;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,
- pme->ch_id,
- num_of_streams,
- stream))) {
- CDBG_ERROR("%s : RDI Stream off Error",__func__);
- goto end;
- }
-
- /*if(rdi_mode == STREAM_IMAGE_AND_RAW) {
- if(MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_PREVIEW].id)))
- {
- CDBG_ERROR("%s : Delete Preview error",__func__);
- goto end;
- }
- }*/
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_RDI].id))) {
- CDBG_ERROR("%s : Delete Stream RDI error",__func__);
- goto end;
- }
- CDBG("del_stream successfull");
- pme->cam_state = CAMERA_STATE_OPEN;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
-
- return rc;
-}
-
-static int mm_app_streamdel_rdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int stream[2];
- int num_of_streams;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- /*if(rdi_mode == STREAM_IMAGE_AND_RAW){
- num_of_streams = 2;
- stream[0] = pme->stream[MM_CAMERA_RDI].id;
- stream[1] = pme->stream[MM_CAMERA_PREVIEW].id;
- }else*/{
- num_of_streams = 1;
- stream[0] = pme->stream[MM_CAMERA_RDI].id;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_RDI].id))) {
- CDBG_ERROR("%s : Delete Stream RDI error",__func__);
- goto end;
- }
- CDBG("del_stream successfull");
- pme->cam_state = CAMERA_STATE_OPEN;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
-
- return rc;
-}
-
-
-int startRdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: Start Preview",__func__);
-
- if (pme->cam_mode == ZSL_MODE || pme->cam_mode == RECORDER_MODE || pme->cam_mode == CAMERA_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_RECORD:
- if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
- CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
- return -1;
- }
- case CAMERA_STATE_PREVIEW:
- if (MM_CAMERA_OK != mm_app_open_rdi(cam_id)) {
- CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
- return -1;
- }
- case CAMERA_STATE_SNAPSHOT:
- default:
- break;
- }
- }
- mm_app_start_rdi(cam_id);
- return rc;
-}
-
-int stopRdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- rdi_counter = 0;
- mm_app_streamoff_rdi(cam_id);
-
- end:
- return rc;
-}
-
-int takePicture_rdi(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- mm_app_streamoff_rdi(cam_id);
- rdi_op_mode = MM_CAMERA_OP_MODE_CAPTURE;
- mm_app_set_opmode(cam_id, MM_CAMERA_OP_MODE_CAPTURE);
- if (MM_CAMERA_OK != (rc = mm_app_prepare_rdi(cam_id, 1))) {
- CDBG_ERROR("%s:Prepare RDI failed rc=%d\n", __func__, rc);
- goto end;
- }
- if (MM_CAMERA_OK != (rc = mm_app_streamon_rdi(cam_id))) {
- CDBG_ERROR("%s:Stream On RDI failed rc=%d\n", __func__, rc);
- goto end;
- }
- mm_camera_app_wait(cam_id);
- usleep(50*1000);
- mm_app_streamoff_rdi(cam_id);
- mm_app_start_rdi(cam_id);
-end:
- return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_snapshot.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_snapshot.c
deleted file mode 100755
index 5d27305..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_snapshot.c
+++ /dev/null
@@ -1,1220 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include "mm_camera_dbg.h"
-#include "mm_qcamera_app.h"
-
-#define BUFF_SIZE_128 128
-
-#ifdef TEST_ABORT_JPEG_ENCODE
-static uint8_t aborted_flag = 1;
-#endif
-
-//static mm_camera_ch_data_buf_t *mCurrentFrameEncoded;
-static int JpegOffset = 0;
-static int raw_snapshot_cnt = 0;
-static int snapshot_cnt = 0;
-static pthread_mutex_t g_s_mutex;
-static int g_status = 0;
-static pthread_cond_t g_s_cond_v;
-
-extern void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h, char* name, int main_422,char *ext);
-extern int mm_app_open_zsl(int cam_id);
-extern int mm_app_open_camera(int cam_id);
-extern int mm_app_start_preview(int cam_id);
-extern int mm_stream_alloc_bufs(mm_camera_app_obj_t *pme,
- mm_camear_app_buf_t* app_bufs,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs);
-extern int mm_stream_release_bufs(mm_camera_app_obj_t *pme,
- mm_camear_app_buf_t* app_bufs);
-extern int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,
- mm_camera_buf_def_t *frame);
-
-static void mm_app_snapshot_done()
-{
- pthread_mutex_lock(&g_s_mutex);
- g_status = TRUE;
- pthread_cond_signal(&g_s_cond_v);
- pthread_mutex_unlock(&g_s_mutex);
-}
-
-static int mm_app_dump_snapshot_frame(struct msm_frame *frame,
- uint32_t len, int is_main, int is_raw)
-{
- char bufp[BUFF_SIZE_128];
- int file_fdp;
- int rc = 0;
-
- if (is_raw) {
- snprintf(bufp, BUFF_SIZE_128, "/data/main_raw_%d.yuv", raw_snapshot_cnt);
- } else {
- if (is_main) {
- snprintf(bufp, BUFF_SIZE_128, "/data/main_%d.yuv", snapshot_cnt);
- } else {
- snprintf(bufp, BUFF_SIZE_128, "/data/thumb_%d.yuv", snapshot_cnt);
- }
- }
-
- file_fdp = open(bufp, O_RDWR | O_CREAT, 0777);
-
- if (file_fdp < 0) {
- CDBG("cannot open file %s\n", bufp);
- rc = -1;
- goto end;
- }
- CDBG("%s:dump snapshot frame to '%s'\n", __func__, bufp);
- write(file_fdp,
- (const void *)frame->buffer, len);
- close(file_fdp);
- end:
- return rc;
-}
-
-
-static void mm_app_dump_jpeg_frame(const void * data, uint32_t size, char* name, char* ext, int index)
-{
- char buf[32];
- int file_fd;
- if ( data != NULL) {
- char * str;
- snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name, index, ext);
- CDBG("%s: %s size =%d, jobId=%d", __func__, buf, size, index);
- file_fd = open(buf, O_RDWR | O_CREAT, 0777);
- write(file_fd, data, size);
- close(file_fd);
- }
-}
-
-static int mm_app_set_thumbnail_fmt(int cam_id, mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = pme->dim.thumb_format;
- fmt->width = pme->dim.thumbnail_width;
- fmt->height = pme->dim.thumbnail_height;
- if (cam_id == 0) {
- /* back camera, rotate 90 */
- fmt->rotation = 90;
- }
- CDBG("Thumbnail Dimension = %dX%d",fmt->width,fmt->height);
- return rc;
-}
-
-int mm_app_set_snapshot_fmt(int cam_id, mm_camera_image_fmt_t *fmt)
-{
-
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = pme->dim.main_img_format;
- fmt->width = pme->dim.picture_width;
- fmt->height = pme->dim.picture_height;
- if (cam_id == 0) {
- /* back camera, rotate 90 */
- fmt->rotation = 90;
- }
- CDBG("Snapshot Dimension = %dX%d",fmt->width,fmt->height);
- return rc;
-}
-
-int mm_app_set_live_snapshot_fmt(int cam_id, mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = pme->dim.enc_format;
- fmt->width = pme->dim.video_width;
- fmt->height = pme->dim.video_height;
- CDBG("Livesnapshot Dimension = %dX%d",fmt->width,fmt->height);
- return rc;
-}
-
-int mm_app_set_raw_snapshot_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = pme->dim.raw_img_format;
- fmt->width = pme->dim.raw_picture_width;
- fmt->height = pme->dim.raw_picture_height;
- if (cam_id == 0) {
- /* back camera, rotate 90 */
- fmt->rotation = 90;
- }
- CDBG("%s: Raw Snapshot Dimension = %d X %d",__func__,pme->dim.raw_picture_width,pme->dim.raw_picture_height);
- return rc;
-}
-
-/* This callback is received once the complete JPEG encoding is done */
-static void jpeg_encode_cb(jpeg_job_status_t status,
- uint8_t thumbnailDroppedFlag,
- uint32_t client_hdl,
- uint32_t jobId,
- uint8_t* out_data,
- uint32_t data_size,
- void *userData)
-{
- int rc;
- int i = 0;
- mm_camera_buf_def_t *main_frame = NULL;
- mm_camera_buf_def_t *thumb_frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
-
- pme = (mm_camera_app_obj_t *)userData;
- if (jobId != pme->current_job_id || !pme->current_job_frames) {
- CDBG_ERROR("%s: NULL current job frames or not matching job ID (%d, %d)",
- __func__, jobId, pme->current_job_id);
- return;
- }
-
- /* dump jpeg img */
- CDBG_ERROR("%s: job %d, status=%d, thumbnail_dropped=%d",
- __func__, jobId, status, thumbnailDroppedFlag);
- if (status == JPEG_JOB_STATUS_DONE) {
- mm_app_dump_jpeg_frame(out_data, data_size, "jpeg_dump", "jpg", pme->my_id);
- }
-
- /* buf done current encoding frames */
- pme->current_job_id = 0;
- for (i=0; i<pme->current_job_frames->num_bufs; i++) {
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->current_job_frames->camera_handle,
- pme->current_job_frames->ch_id,
- pme->current_job_frames->bufs[i])) {
- CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
- }
- }
- free(pme->current_job_frames);
- pme->current_job_frames = NULL;
-
- /* signal snapshot is done */
- mm_app_snapshot_done();
-}
-
-static int encodeData(mm_camera_app_obj_t *pme,
- mm_camera_super_buf_t* recvd_frame)
-{
- int rc = -1;
- int i,index = -1;
- mm_jpeg_job job;
- mm_camera_buf_def_t *main_frame = NULL;
- mm_camera_buf_def_t *thumb_frame = NULL;
- src_image_buffer_info* main_buf_info = NULL;
- src_image_buffer_info* thumb_buf_info = NULL;
- mm_camera_frame_len_offset main_offset;
- mm_camera_frame_len_offset thumb_offset;
-
- /* dump raw img for debug purpose */
- CDBG("%s : total streams = %d",__func__,recvd_frame->num_bufs);
- for (i=0; i<recvd_frame->num_bufs; i++) {
- if (pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id == recvd_frame->bufs[i]->stream_id) {
- main_frame = recvd_frame->bufs[i];
- CDBG("mainframe frame_idx = %d fd = %d frame length = %d",main_frame->frame_idx,main_frame->fd,main_frame->frame_len);
- dumpFrameToFile(main_frame,pme->dim.picture_width,pme->dim.picture_height,"main", 1,"yuv");
- } else if (pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id == recvd_frame->bufs[i]->stream_id){
- thumb_frame = recvd_frame->bufs[1];
- CDBG("thumnail frame_idx = %d fd = %d frame length = %d",thumb_frame->frame_idx,thumb_frame->fd,thumb_frame->frame_len);
- dumpFrameToFile(thumb_frame,pme->dim.thumbnail_width,pme->dim.thumbnail_height,"thumb", 1,"yuv");
- }
- }
-
- if (main_frame == NULL) {
- CDBG_ERROR("%s: Main frame is NULL", __func__);
- return rc;
- }
-
- /* remember current frames being encoded */
- pme->current_job_frames =
- (mm_camera_super_buf_t *)malloc(sizeof(mm_camera_super_buf_t));
- if (!pme->current_job_frames) {
- CDBG_ERROR("%s: No memory for current_job_frames", __func__);
- return rc;
- }
- memcpy(pme->current_job_frames, recvd_frame, sizeof(mm_camera_super_buf_t));
-
- memset(&job, 0, sizeof(job));
- job.job_type = JPEG_JOB_TYPE_ENCODE;
- job.encode_job.jpeg_cb = jpeg_encode_cb;
- job.encode_job.userdata = (void*)pme;
- job.encode_job.encode_parm.exif_data = NULL;
- job.encode_job.encode_parm.exif_numEntries = 0;
- job.encode_job.encode_parm.rotation = 0;
- job.encode_job.encode_parm.buf_info.src_imgs.src_img_num = recvd_frame->num_bufs;
- job.encode_job.encode_parm.rotation = 0;
- if (pme->my_id == 0) {
- /* back camera, rotate 90 */
- job.encode_job.encode_parm.rotation = 90;
- }
-
- /* fill in main src img encode param */
- main_buf_info = &job.encode_job.encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN];
- main_buf_info->type = JPEG_SRC_IMAGE_TYPE_MAIN;
- main_buf_info->color_format = MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2; //TODO
- main_buf_info->quality = 85;
- main_buf_info->src_dim.width = pme->dim.picture_width;
- main_buf_info->src_dim.height = pme->dim.picture_height;
- main_buf_info->out_dim.width = pme->dim.picture_width;
- main_buf_info->out_dim.height = pme->dim.picture_height;
- main_buf_info->crop.width = pme->dim.picture_width;
- main_buf_info->crop.height = pme->dim.picture_height;
- main_buf_info->crop.offset_x = 0;
- main_buf_info->crop.offset_y = 0;
- main_buf_info->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
- main_buf_info->num_bufs = 1;
- main_buf_info->src_image[0].fd = main_frame->fd;
- main_buf_info->src_image[0].buf_vaddr = main_frame->buffer;
- pme->cam->ops->get_stream_parm(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
- MM_CAMERA_STREAM_OFFSET,
- &main_buf_info->src_image[0].offset);
- CDBG("%s: main offset: num_planes=%d, frame length=%d, y_offset=%d, cbcr_offset=%d",
- __func__, main_buf_info->src_image[0].offset.num_planes,
- main_buf_info->src_image[0].offset.frame_len,
- main_buf_info->src_image[0].offset.mp[0].offset,
- main_buf_info->src_image[0].offset.mp[1].offset);
-
- mm_stream_clear_invalid_cache(pme,main_frame);
-
- if (thumb_frame) {
- /* fill in thumbnail src img encode param */
- thumb_buf_info = &job.encode_job.encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB];
- thumb_buf_info->type = JPEG_SRC_IMAGE_TYPE_THUMB;
- thumb_buf_info->color_format = MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2; //TODO
- thumb_buf_info->quality = 85;
- thumb_buf_info->src_dim.width = pme->dim.thumbnail_width;
- thumb_buf_info->src_dim.height = pme->dim.thumbnail_height;
- thumb_buf_info->out_dim.width = pme->dim.thumbnail_width;
- thumb_buf_info->out_dim.height = pme->dim.thumbnail_height;
- thumb_buf_info->crop.width = pme->dim.thumbnail_width;
- thumb_buf_info->crop.height = pme->dim.thumbnail_height;
- thumb_buf_info->crop.offset_x = 0;
- thumb_buf_info->crop.offset_y = 0;
- thumb_buf_info->img_fmt = JPEG_SRC_IMAGE_FMT_YUV;
- thumb_buf_info->num_bufs = 1;
- thumb_buf_info->src_image[0].fd = thumb_frame->fd;
- thumb_buf_info->src_image[0].buf_vaddr = thumb_frame->buffer;
- pme->cam->ops->get_stream_parm(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id,
- MM_CAMERA_STREAM_OFFSET,
- &thumb_buf_info->src_image[0].offset);
- }
-
- /* fill in sink img param */
- job.encode_job.encode_parm.buf_info.sink_img.buf_len = pme->jpeg_buf.bufs[0].frame_len;
- job.encode_job.encode_parm.buf_info.sink_img.buf_vaddr = pme->jpeg_buf.bufs[0].buffer;
- job.encode_job.encode_parm.buf_info.sink_img.fd = pme->jpeg_buf.bufs[0].fd;
-
- mm_stream_clear_invalid_cache(pme,thumb_frame);
-
- rc = pme->jpeg_ops.start_job(pme->jpeg_hdl, &job, &pme->current_job_id);
- if ( 0 != rc ) {
- free(pme->current_job_frames);
- pme->current_job_frames = NULL;
- }
-
- return rc;
-}
-
-static void snapshot_yuv_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
-
- int rc;
- int i = 0;
- mm_camera_buf_def_t *main_frame = NULL;
- mm_camera_buf_def_t *thumb_frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- char* cmd = "This is a private cmd from test app";
-
- CDBG("%s: BEGIN\n", __func__);
-
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: send private ioctl here", __func__);
- pme->cam->ops->send_command(bufs->camera_handle,
- MM_CAMERA_CMD_TYPE_PRIVATE,
- 0,
- strlen(cmd) + 1,
- (void *)cmd);
-
- /* start jpeg encoding job */
- rc = encodeData(pme, bufs);
-
- /* buf done rcvd frames in error case */
- if ( 0 != rc ) {
- for (i=0; i<bufs->num_bufs; i++) {
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
- bufs->ch_id,
- bufs->bufs[i])) {
- CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
- }
- mm_stream_invalid_cache(pme,bufs->bufs[i]);
- }
- }
-#ifdef TEST_ABORT_JPEG_ENCODE
- else {
- if (aborted_flag) {
- aborted_flag = 0;
- /* abort the job */
- CDBG("%s: abort jpeg encode job here", __func__);
- rc = pme->jpeg_ops.abort_job(pme->jpeg_hdl, pme->current_job_id);
- if (NULL != pme->current_job_frames) {
- free(pme->current_job_frames);
- pme->current_job_frames = NULL;
- }
- CDBG("%s: abort jpeg encode job returns %d", __func__, rc);
- for (i=0; i<bufs->num_bufs; i++) {
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
- bufs->ch_id,
- bufs->bufs[i])) {
- CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
- }
- mm_stream_invalid_cache(pme,bufs->bufs[i]);
- }
-
- /* signal snapshot is done */
- mm_app_snapshot_done();
- }
- }
-#endif
-
- CDBG("%s: END\n", __func__);
-}
-
-static void snapshot_raw_cb(mm_camera_super_buf_t *recvd_frame,
- void *user_data)
-{
- int rc;
- int i = 0;
- mm_camera_buf_def_t *main_frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
-
- CDBG("%s: BEGIN\n", __func__);
-
- pme = (mm_camera_app_obj_t *)user_data;
-
- if (pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id == recvd_frame->bufs[i]->stream_id) {
- main_frame = recvd_frame->bufs[i];
- CDBG("mainframe frame_idx = %d fd = %d frame length = %d",main_frame->frame_idx,main_frame->fd,main_frame->frame_len);
- dumpFrameToFile(main_frame,pme->dim.raw_picture_width,pme->dim.raw_picture_height,"raw_main", 1,"raw");
- }
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,
- main_frame)) {
- CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
- }
-
- mm_app_snapshot_done();
-}
-
-static int encodeDisplayAndSave(mm_camera_super_buf_t* recvd_frame,
- int enqueued, mm_camera_app_obj_t *pme)
-{
- int ret = -1;
-#if 0
-
-
- CDBG("%s: Send frame for encoding", __func__);
- ret = encodeData(recvd_frame, pme->snapshot_buf.frame_len,
- enqueued, pme);
- if (!ret) {
- CDBG_ERROR("%s: Failure configuring JPEG encoder", __func__);
- }
-
- LOGD("%s: X", __func__);
-#endif
- return ret;
-}
-
-int mm_app_add_snapshot_stream(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
- NULL,pme,
- MM_CAMERA_SNAPSHOT_MAIN, 0);
-
- CDBG("Add Snapshot main is successfull stream ID = %d",pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id);
- if (!pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id) {
- CDBG_ERROR("%s:snapshot main streaming err=%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
- NULL,pme,
- MM_CAMERA_SNAPSHOT_THUMBNAIL, 0);
- if (!pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id) {
- CDBG_ERROR("%s:snapshot thumbnail streaming err=%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-void mm_app_set_snapshot_mode(int cam_id,int op_mode)
-{
- denoise_param_t wnr;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode);
-
- /* set wnr enabled */
- memset(&wnr, 0, sizeof(denoise_param_t));
- wnr.denoise_enable = 0;
- wnr.process_plates = 0;
- // pme->cam->ops->set_parm(pme->cam->camera_handle, MM_CAMERA_PARM_WAVELET_DENOISE, &wnr);
-}
-
-int mm_app_config_raw_format(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- mm_camera_image_fmt_t *m_fmt = NULL;
- mm_camera_image_fmt_t *t_fmt = NULL;
-
- mm_app_set_raw_snapshot_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.fmt);
-
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.num_of_bufs = 1;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
- &pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
-
-end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-
-}
-
-int mm_app_config_snapshot_format(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- mm_app_set_snapshot_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.fmt);
-
- mm_app_set_thumbnail_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].str_config.fmt);
-
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.num_of_bufs = 1;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
- &pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
-
- pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].str_config.num_of_bufs = 1;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id,
- &pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-
-}
-
-int mm_app_streamon_snapshot(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[2];
- mm_camera_bundle_attr_t attr;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
- stream[1] = pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id;
-
- attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
- attr.burst_num = 1;
- attr.look_back = 2;
- attr.post_frame_skip = 0;
- attr.water_mark = 2;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->init_stream_bundle(
- pme->cam->camera_handle,pme->ch_id,snapshot_yuv_cb,pme,&attr,2,stream))) {
- CDBG_ERROR("%s:init_stream_bundle err=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,
- 2, stream))) {
- CDBG_ERROR("%s:start_streams err=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc =pme->cam->ops->request_super_buf(pme->cam->camera_handle,pme->ch_id, attr.burst_num))) {
- CDBG_ERROR("%s:request_super_buf err=%d\n", __func__, rc);
- goto end;
- }
- pme->cam_state = CAMERA_STATE_SNAPSHOT;
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_streamon_raw(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[2];
- mm_camera_bundle_attr_t attr;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-
- attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
- attr.burst_num = 1;
- attr.look_back = 2;
- attr.post_frame_skip = 0;
- attr.water_mark = 2;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->init_stream_bundle(
- pme->cam->camera_handle,pme->ch_id,snapshot_raw_cb,pme,&attr,1,stream))) {
- CDBG_ERROR("%s:init_stream_bundle err=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,
- 1, stream))) {
- CDBG_ERROR("%s:start_streams err=%d\n", __func__, rc);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc =pme->cam->ops->request_super_buf(pme->cam->camera_handle,pme->ch_id, attr.burst_num))) {
- CDBG_ERROR("%s:request_super_buf err=%d\n", __func__, rc);
- goto end;
- }
- pme->cam_state = CAMERA_STATE_SNAPSHOT;
-end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_streamoff_snapshot(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- uint32_t stream[2];
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
- stream[1] = pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,2,stream))) {
- CDBG_ERROR("%s : Snapshot Stream off Error",__func__);
- goto end;
- }
- CDBG("Stop snapshot main successfull");
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->destroy_stream_bundle(pme->cam->camera_handle,pme->ch_id))) {
- CDBG_ERROR("%s : Snapshot destroy_stream_bundle Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id))) {
- CDBG_ERROR("%s : Snapshot main image del_stream Error",__func__);
- goto end;
- }
- CDBG("del_stream successfull");
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_THUMBNAIL].id))) {
- CDBG_ERROR("%s : Snapshot thumnail image del_stream Error",__func__);
- goto end;
- }
- CDBG("del_stream successfull");
-
- end:
- return rc;
-}
-
-int mm_app_start_snapshot(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int stream[2];
- int op_mode = 0;
- uint8_t initial_reg_flag;
- mm_camera_frame_len_offset frame_offset_info;
-
- mm_camera_bundle_attr_t attr;
-
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (MM_CAMERA_OK != mm_app_stop_preview(cam_id)) {
- CDBG_ERROR("%s: Stop preview Failed cam_id=%d\n",__func__,cam_id);
- return -1;
- }
- op_mode = MM_CAMERA_OP_MODE_CAPTURE;
- mm_app_set_snapshot_mode(cam_id,op_mode);
- usleep(20*1000);
-// pme->cam->ops->prepare_snapshot(pme->cam->camera_handle,pme->ch_id,0);
-
- if (MM_CAMERA_OK != (rc = mm_app_add_snapshot_stream(cam_id))) {
- CDBG_ERROR("%s : Add Snapshot stream err",__func__);
- return rc;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_config_snapshot_format(cam_id))) {
- CDBG_ERROR("%s : Config Snapshot stream err",__func__);
- return rc;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_streamon_snapshot(cam_id))) {
- CDBG_ERROR("%s : Stream on Snapshot stream err",__func__);
- return rc;
- }
-
- /* init jpeg buf */
- pme->cam->ops->get_stream_parm(pme->cam->camera_handle,
- pme->ch_id,
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
- MM_CAMERA_STREAM_OFFSET,
- &frame_offset_info);
- CDBG_ERROR("%s : alloc jpeg buf (len=%d)",__func__, frame_offset_info.frame_len);
- rc = mm_stream_alloc_bufs(pme,
- &pme->jpeg_buf,
- &frame_offset_info,
- 1);
- if (0 != rc) {
- CDBG_ERROR("%s : mm_stream_alloc_bufs err",__func__);
- return rc;
- }
-
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_start_raw(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int op_mode = 0;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (MM_CAMERA_OK != mm_app_stop_preview(cam_id)) {
- CDBG_ERROR("%s: Stop preview Failed cam_id=%d\n",__func__,cam_id);
- return -1;
- }
- op_mode = MM_CAMERA_OP_MODE_RAW;
- pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_OP_MODE, &op_mode);
- usleep(20*1000);
-
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
- NULL,pme,
- MM_CAMERA_SNAPSHOT_MAIN, 0);
-
- CDBG("Add RAW main is successfull stream ID = %d",pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id);
- if (!pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id) {
- CDBG_ERROR("%s:Raw main streaming err=%d\n", __func__, rc);
- rc = -1;
- return rc;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_config_raw_format(cam_id))) {
- CDBG_ERROR("%s : Config Raw Snapshot stream err",__func__);
- return rc;
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_streamon_raw(cam_id))) {
- CDBG_ERROR("%s : Stream on Raw Snapshot stream err",__func__);
- return rc;
- }
-
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_stop_snapshot(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int i;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if (pme->current_job_id) {
- /* have current jpeg encoding running, abort the job */
- if (pme->jpeg_ops.abort_job) {
- pme->jpeg_ops.abort_job(pme->jpeg_hdl, pme->current_job_id);
- pme->current_job_id = 0;
- }
-
- if (pme->current_job_frames) {
- for (i=0; i<pme->current_job_frames->num_bufs; i++) {
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->current_job_frames->camera_handle,
- pme->current_job_frames->ch_id,
- pme->current_job_frames->bufs[i])) {
- CDBG_ERROR("%s: Failed in Qbuf\n", __func__);
- }
- mm_stream_invalid_cache(pme,pme->current_job_frames->bufs[i]);
- }
- free(pme->current_job_frames);
- pme->current_job_frames = NULL;
- }
- }
-
- if (MM_CAMERA_OK != (rc = mm_app_streamoff_snapshot(cam_id))) {
- CDBG_ERROR("%s : Stream off Snapshot stream err",__func__);
- }
- pme->cam_state = CAMERA_STATE_OPEN;
-
- /* deinit jpeg buf */
- rc = mm_stream_release_bufs(pme,
- &pme->jpeg_buf);
-end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
-
- return rc;
-}
-
-int mm_app_stop_raw(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int i;
- uint32_t stream[1];
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream))) {
- CDBG_ERROR("%s : Snapshot Stream off Error",__func__);
- goto end;
- }
- CDBG("Stop snapshot main successfull");
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->destroy_stream_bundle(pme->cam->camera_handle,pme->ch_id))) {
- CDBG_ERROR("%s : Snapshot destroy_stream_bundle Error",__func__);
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id))) {
- CDBG_ERROR("%s : Snapshot main image del_stream Error",__func__);
- goto end;
- }
- CDBG("del_stream successfull");
-
- pme->cam_state = CAMERA_STATE_OPEN;
-end:
- return rc;
-}
-
-static void mm_app_snapshot_wait(int cam_id)
-{
- pthread_mutex_lock(&g_s_mutex);
- if (FALSE == g_status) {
- pthread_cond_wait(&g_s_cond_v, &g_s_mutex);
- g_status = FALSE;
- }
- pthread_mutex_unlock(&g_s_mutex);
-}
-
-static void mm_app_live_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
-
- int rc;
- int i = 0;
- mm_camera_buf_def_t *main_frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
-
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s : total streams = %d",__func__,bufs->num_bufs);
- main_frame = bufs->bufs[0];
- //thumb_frame = bufs->bufs[1];
-
- CDBG("mainframe frame_idx = %d fd = %d frame length = %d",main_frame->frame_idx,main_frame->fd,main_frame->frame_len);
- //CDBG("thumnail frame_idx = %d fd = %d frame length = %d",thumb_frame->frame_idx,thumb_frame->fd,thumb_frame->frame_len);
-
- //dumpFrameToFile(main_frame->frame,pme->dim.picture_width,pme->dim.picture_height,"main", 1);
-
- dumpFrameToFile(main_frame,pme->dim.picture_width,pme->dim.picture_height,"liveshot_main", 1,"yuv");
-
- if (MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,main_frame)) {
- CDBG_ERROR("%s: Failed in thumbnail Qbuf\n", __func__);
- }
- mm_stream_invalid_cache(pme,main_frame);
- /*if(MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,thumb_frame))
- {
- CDBG_ERROR("%s: Failed in thumbnail Qbuf\n", __func__);
- }*/
-
- mm_app_snapshot_done();
- CDBG("%s: END\n", __func__);
-
-
-}
-
-int mm_app_prepare_live_snapshot(int cam_id)
-{
- int rc = 0;
- uint32_t stream[1];
- mm_camera_bundle_attr_t attr;
- int value = 0;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
- stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
- //stream[1] = pme->stream[MM_CAMERA_PREVIEW].id; //Need to clarify
-
- attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_BURST;
- attr.burst_num = 1;
- attr.look_back = 2;
- attr.post_frame_skip = 0;
- attr.water_mark = 2;
-
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->set_parm(
- pme->cam->camera_handle,MM_CAMERA_PARM_FULL_LIVESHOT, (void *)&value))) {
- CDBG_ERROR("%s: set dimension err=%d\n", __func__, rc);
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->init_stream_bundle(
- pme->cam->camera_handle,pme->ch_id,mm_app_live_notify_cb,pme,&attr,1,stream))) {
- CDBG_ERROR("%s:init_stream_bundle err=%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,
- 1, stream))) {
- CDBG_ERROR("%s:start_streams err=%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
-
- end:
- CDBG("%s:END, cam_id=%d\n",__func__,cam_id);
- return rc;
-}
-
-int mm_app_unprepare_live_snapshot(int cam_id)
-{
- int rc = 0;
- uint32_t stream[2];
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
- CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
- stream[0] = pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id;
- if (MM_CAMERA_OK != (rc = pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,stream))) {
- CDBG_ERROR("%s : Snapshot Stream off Error",__func__);
- return -1;
- }
-
- if (MM_CAMERA_OK != (rc = pme->cam->ops->destroy_stream_bundle(pme->cam->camera_handle,pme->ch_id))) {
- CDBG_ERROR("%s : Snapshot destroy_stream_bundle Error",__func__);
- return -1;
- }
- CDBG("%s:END, cam_id=%d\n",__func__,cam_id);
- return rc;
-}
-
-int mm_app_take_live_snapshot(int cam_id)
-{
- int rc = 0;
- int stream[3];
- mm_camera_bundle_attr_t attr;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
- if (pme->cam_mode == RECORDER_MODE &&
- pme->cam_state == CAMERA_STATE_RECORD) {
- //Code to get live shot
- if (mm_app_prepare_live_snapshot(cam_id) != MM_CAMERA_OK) {
- CDBG_ERROR("%s: Failed prepare liveshot",__func__);
- return -1;
- }
- if (MM_CAMERA_OK != (rc =pme->cam->ops->request_super_buf(pme->cam->camera_handle,pme->ch_id, 1))) {
- CDBG_ERROR("%s:request_super_buf err=%d\n", __func__, rc);
- return -1;
- }
- CDBG("%s:waiting images\n",__func__);
- mm_app_snapshot_wait(cam_id);
-
- if (MM_CAMERA_OK !=mm_app_unprepare_live_snapshot(cam_id)) {
- CDBG_ERROR("%s: Snapshot Stop error",__func__);
- }
-
- } else {
- CDBG_ERROR("%s: Should not come here for liveshot",__func__);
- }
- return rc;
-}
-
-int mm_app_take_picture_raw(int cam_id)
-{
-
- int rc;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
- if (MM_CAMERA_OK != mm_app_start_raw(cam_id)) {
- CDBG_ERROR("%s: cam_id=%d\n",__func__,cam_id);
- rc = -1;
- goto end;
- }
-
- CDBG("%s:waiting images\n",__func__);
- mm_app_snapshot_wait(cam_id);
-
- if (MM_CAMERA_OK !=mm_app_stop_raw(cam_id)) {
- CDBG_ERROR("%s: Snapshot Stop error",__func__);
- }
-
-preview:
- if (MM_CAMERA_OK != (rc = mm_app_start_preview(cam_id))) {
- CDBG("%s:preview start stream err=%d\n", __func__, rc);
- }
- end:
- CDBG("%s:END, cam_id=%d\n",__func__,cam_id);
- return rc;
-}
-
-int mm_app_take_picture_zsl(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int value = 1;
- int op_mode;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: Take picture ZSL",__func__);
-
- if (MM_CAMERA_OK != (rc =pme->cam->ops->request_super_buf(pme->cam->camera_handle,pme->ch_id, 1))) {
- CDBG_ERROR("%s:request_super_buf err=%d\n", __func__, rc);
- goto end;
- }
-
- CDBG("%s: Start ZSL Preview",__func__);
-
- end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_take_picture_yuv(int cam_id)
-{
- int rc;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
- if (MM_CAMERA_OK != mm_app_start_snapshot(cam_id)) {
- CDBG_ERROR("%s: cam_id=%d\n",__func__,cam_id);
- rc = -1;
- goto end;
- }
-
- CDBG("%s:waiting images\n",__func__);
- mm_app_snapshot_wait(cam_id);
-
- if (MM_CAMERA_OK !=mm_app_stop_snapshot(cam_id)) {
- CDBG_ERROR("%s: Snapshot Stop error",__func__);
- }
-
- preview:
- if (MM_CAMERA_OK != (rc = mm_app_start_preview(cam_id))) {
- CDBG("%s:preview start stream err=%d\n", __func__, rc);
- }
- end:
- CDBG("%s:END, cam_id=%d\n",__func__,cam_id);
- return rc;
-}
-
-int mm_app_take_zsl(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
- if (pme->cam_mode == RECORDER_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_RECORD:
- if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
- CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
- return -1;
- }
- case CAMERA_STATE_PREVIEW:
- if (MM_CAMERA_OK != mm_app_open_zsl(cam_id)) {
- CDBG_ERROR("%s: Cannot switch to camera mode\n", __func__);
- return -1;
- }
- break;
- case CAMERA_STATE_SNAPSHOT:
- default:
- CDBG("%s: Cannot normal pciture in record mode\n", __func__);
- break;
- }
- } else if (pme->cam_mode == CAMERA_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_PREVIEW:
- mm_app_open_zsl(cam_id);
- break;
-
- case CAMERA_STATE_SNAPSHOT:
- case CAMERA_STATE_RECORD:
- default:
- CDBG("%s: Cannot normal pciture in record mode\n", __func__);
- break;
- }
- }
-
- if (pme->cam_mode == ZSL_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- mm_app_take_picture_zsl(cam_id);
- }
- return rc;
-}
-
-int mm_app_take_picture(int cam_id)
-{
- int rc = 0;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
- if (pme->cam_mode == RECORDER_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_RECORD:
- if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
- CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
- return -1;
- }
- case CAMERA_STATE_PREVIEW:
- if (MM_CAMERA_OK != mm_app_open_camera(cam_id)) {
- CDBG_ERROR("%s: Cannot switch to camera mode=%d\n", __func__,rc);
- return -1;
- }
- break;
- case CAMERA_STATE_SNAPSHOT:
- default:
- CDBG("%s: Cannot normal pciture in record mode\n", __func__);
- break;
- }
- } else if (pme->cam_mode == ZSL_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_PREVIEW:
- mm_app_open_camera(cam_id);
- break;
-
- case CAMERA_STATE_SNAPSHOT:
- case CAMERA_STATE_RECORD:
- default:
- CDBG("%s: Cannot normal pciture in record mode\n", __func__);
- break;
- }
- }
-
- CDBG("%s : Takepicture : mode = %d state = %d, rc = %d",__func__,pme->cam_mode,pme->cam_state,rc);
- if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- mm_app_take_picture_yuv(cam_id);
- }
- return rc;
-}
-
-
-int mm_app_take_raw(int cam_id)
-{
- int rc = 0;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s:BEGIN, cam_id=%d\n",__func__,cam_id);
-
- if (pme->cam_mode == RECORDER_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_RECORD:
- if (MM_CAMERA_OK != mm_app_stop_video(cam_id)) {
- CDBG_ERROR("%s:Cannot stop video err=%d\n", __func__, rc);
- return -1;
- }
- case CAMERA_STATE_PREVIEW:
- if (MM_CAMERA_OK != mm_app_open_camera(cam_id)) {
- CDBG_ERROR("%s: Cannot switch to camera mode=%d\n", __func__,rc);
- return -1;
- }
- break;
- case CAMERA_STATE_SNAPSHOT:
- default:
- CDBG("%s: Cannot normal pciture in record mode\n", __func__);
- break;
- }
- } else if (pme->cam_mode == ZSL_MODE) {
- switch (pme->cam_state) {
- case CAMERA_STATE_PREVIEW:
- mm_app_open_camera(cam_id);
- break;
-
- case CAMERA_STATE_SNAPSHOT:
- case CAMERA_STATE_RECORD:
- default:
- CDBG("%s: Cannot normal pciture in record mode\n", __func__);
- break;
- }
- }
-
- CDBG("%s : Takepicture RAW: mode = %d state = %d, rc = %d",__func__,pme->cam_mode,pme->cam_state,rc);
- if (pme->cam_mode == CAMERA_MODE && pme->cam_state == CAMERA_STATE_PREVIEW) {
- mm_app_take_picture_raw(cam_id);
- }
- return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_unit_test.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_unit_test.c
deleted file mode 100755
index c1f0eba..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_unit_test.c
+++ /dev/null
@@ -1,757 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include "mm_qcamera_unit_test.h"
-
-#define MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP 4
-#define MM_QCAM_APP_TEST_NUM 128
-
-static mm_app_tc_t mm_app_tc[MM_QCAM_APP_TEST_NUM];
-static int num_test_cases = 0;
-static mm_jpeg_ops_t jpeg_ops;
-
-extern int system_dimension_set(int cam_id);
-extern int stopPreview(int cam_id);
-extern int takePicture_yuv(int cam_id);
-extern int startRdi(int cam_id);
-extern int stopRdi(int cam_id);
-extern int startStats(int cam_id);
-extern int stopStats(int cam_id);
-extern int takePicture_zsl(int cam_id);
-extern int takePicture_rdi(int cam_id);
-extern int mm_app_tc_reprocess_preview_only(mm_camera_app_t *cam_apps);
-extern int takePicture_raw(int cam_id);
-
-int mm_app_tc_0(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying Preview on front and back camera...\n");
- if (cam_apps->num_cameras == 0) {
- CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
- rc = -1;
- goto end;
- }
- for (i = 0; i < cam_apps->num_cameras; i++) {
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Preview Callback not received in time or qbuf failed\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- result++;
- }
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if (result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Preview Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
- end:
- if (rc == 0) {
- printf("\nPassed\n");
- } else {
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_1(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying Snapshot on front and back camera...\n");
- for (i = 0; i < cam_apps->num_cameras; i++) {
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if ( MM_CAMERA_OK != (rc = takePicture_yuv(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
- break;
- }
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Snapshot/Preview Callback not received in time or qbuf Faile\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- result++;
- }
- if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Snapshot Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
- end:
- if (rc == 0) {
- printf("\t***Passed***\n");
- } else {
- printf("\t***Failed***\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_2(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying Video on front and back camera...\n");
- for (i = 0; i < cam_apps->num_cameras; i++) {
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if ( MM_CAMERA_OK != (rc = startRecording(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
- break;
- }
-
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Video Callback not received in time\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- usleep(10*1000);
- if ( MM_CAMERA_OK != (rc = stopRecording(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
- break;
- }
- result++;
- }
- if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
- end:
- if (rc == 0) {
- printf("\nPassed\n");
- } else {
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_3(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying RDI Stream on front and back camera...\n");
- if (cam_apps->num_cameras == 0) {
- CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("SINGLE open RDI ");
- for (i = 1; i < cam_apps->num_cameras; i++) {
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("SINGLE start RDI case");
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if ( MM_CAMERA_OK != (rc = startRdi(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
- break;
- }
-
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Video Callback not received in time\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- usleep(10*1000);
- CDBG_ERROR("SINGLE stop RDI");
- if ( MM_CAMERA_OK != (rc = stopRdi(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
- break;
- }
- result++;
- }
- CDBG_ERROR("SINGLE close RDI");
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
- end:
- if (rc == 0) {
- printf("\nPassed\n");
- } else {
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_4(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying ZSL Snapshot on front and back camera...\n");
- for (i = 0; i < cam_apps->num_cameras; i++) {
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if ( MM_CAMERA_OK != (rc = takePicture_zsl(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: TakePicture() ZSL err=%d\n", __func__, rc);
- break;
- }
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Snapshot/Preview Callback not received in time or qbuf Faile\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- result++;
- }
- if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Snapshot ZSL Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
- end:
- if (rc == 0) {
- printf("\t***Passed***\n");
- } else {
- printf("\t***Failed***\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-
-
-int mm_app_tc_5(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i;
- printf("Running %s - open/close ,video0, open/close snapshot channel only\n", __func__);
-#if 0
- for (i = 0; i < MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP; i++) {
- if ( 0 != (rc = mm_app_open(cam_id, MM_CAMERA_OP_MODE_NOTUSED))) {
- CDBG("%s: open cam %d at opmode = %d err, loop=%d, rc=%d\n",
- __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
- goto end;
- }
- if (0 != (rc = mm_app_open_snapshot(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_close_snapshot(cam_id))) {
- goto end;
- }
- if ( 0 != (rc = mm_app_close(cam_id))) {
- CDBG("%s: close cam %d at opmode = %d err,loop=%d, rc=%d\n",
- __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
- goto end;
- }
- }
- end:
-#endif
- CDBG("%s:END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_6(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i;
- printf("Running %s - simple preview \n", __func__);
-#if 0
- if ( 0 != (rc = mm_app_open(cam_id, MM_CAMERA_OP_MODE_NOTUSED))) {
- CDBG("%s: open cam %d at opmode = %d err, loop=%d, rc=%d\n",
- __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
- goto end;
- }
-
- for (i = 0; i < MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP; i++) {
- if (0 != (rc = mm_app_init_preview(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_start_preview(cam_id))) {
- goto end;
- }
- /* sleep 8 seconds */
- usleep(8000000);
- if (0 != (rc = mm_app_stop_preview(cam_id))) {
- goto end;
- }
- if (0 != (rc=mm_app_deinit_preview(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_close_preview(cam_id))) {
- goto end;
- }
- }
- if ( 0 != (rc = mm_app_close(cam_id))) {
- CDBG("%s: close cam %d at opmode = %d err,loop=%d, rc=%d\n",
- __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
- goto end;
- }
-end:
-#endif
- CDBG("%s:END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_7(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i;
- printf("Running %s - simple preview and recording \n", __func__);
-#if 0
- if ( 0 != (rc = mm_app_open(cam_id, MM_CAMERA_OP_MODE_NOTUSED))) {
- CDBG("%s: open cam %d at opmode = %d err, loop=%d, rc=%d\n",
- __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
- goto end;
- }
-
- for (i = 0; i < MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP; i++) {
- if (0 != (rc = mm_app_init_preview(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_start_preview(cam_id))) {
- goto end;
- }
- /* sleep 8 seconds */
- usleep(8000000);
- if (0 != (rc = mm_app_start_recording(cam_id))) {
- goto end;
- }
- usleep(1000000);
- if (0 != (rc = mm_app_stop_recording(cam_id))) {
- goto end;
- }
- usleep(8000000);
- if (0 != (rc = mm_app_stop_preview(cam_id))) {
- goto end;
- }
- if (0 != (rc=mm_app_deinit_preview(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_close_preview(cam_id))) {
- goto end;
- }
- }
- if ( 0 != (rc = mm_app_close(cam_id))) {
- CDBG("%s: close cam %d at opmode = %d err,loop=%d, rc=%d\n",
- __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
- goto end;
- }
-end:
-#endif
- CDBG("%s:END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_8(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i;
- printf("Running %s - preview, recording, and snapshot, then preview again \n", __func__);
-#if 0
- if ( 0 != (rc = mm_app_open(cam_id, MM_CAMERA_OP_MODE_NOTUSED))) {
- CDBG("%s: open cam %d at opmode = %d err, loop=%d, rc=%d\n",
- __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
- goto end;
- }
-
- for (i = 0; i < MM_QCAMERA_APP_UTEST_MAX_MAIN_LOOP; i++) {
- if (0 != (rc = mm_app_init_preview(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_start_preview(cam_id))) {
- goto end;
- }
- /* sleep 8 seconds */
- usleep(8000000);
- if (0 != (rc = mm_app_start_recording(cam_id))) {
- goto end;
- }
- usleep(1000000);
- if (0 != (rc = mm_app_stop_recording(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_stop_preview(cam_id))) {
- goto end;
- }
- if (0!=(rc=mm_app_init_snapshot(cam_id))) {
- goto end;
- }
- if (0 != (rc=mm_app_take_picture(cam_id))) {
- goto end;
- }
- if ( 0 != (rc = mm_app_deinit_snahspot(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_start_preview(cam_id))) {
- goto end;
- }
- usleep(8000000);
- if (0 != (rc=mm_app_deinit_preview(cam_id))) {
- goto end;
- }
- if (0 != (rc = mm_app_close_preview(cam_id))) {
- goto end;
- }
- }
- if ( 0 != (rc = mm_app_close(cam_id))) {
- CDBG("%s: close cam %d at opmode = %d err,loop=%d, rc=%d\n",
- __func__, cam_id, MM_CAMERA_OP_MODE_NOTUSED, i, rc);
- goto end;
- }
-end:
-#endif
- CDBG("%s:END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_9(mm_camera_app_t *cam_apps) /*RDI snapshot*/
-{
- int rc = MM_CAMERA_OK;
- int i,j,k;
- int result = 0;
-
- printf("\n Verifying RDI Stream on front and back camera...\n");
- if (cam_apps->num_cameras == 0) {
- CDBG_ERROR("%s:Query Failed: Num of cameras = %d\n",__func__, cam_apps->num_cameras);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("SINGLE open RDI snapshot test case");
- for (i = 1; i < cam_apps->num_cameras; i++) {
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- CDBG_ERROR("SINGLE start RDI case");
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if ( MM_CAMERA_OK != (rc = startRdi(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: StartVideorecording() err=%d\n", __func__, rc);
- break;
- }
- usleep(10*1000);
- CDBG_ERROR("SINGLE start RDI snapshot");
- for (k = 0; k < MM_QCAMERA_APP_INTERATION; k++) {
- if ( MM_CAMERA_OK != (rc = takePicture_rdi(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
- break;
- }
- usleep(10*1000);
- mm_camera_app_wait();
- result++;
- }
- CDBG_ERROR("SINGLE stop RDI");
- if ( MM_CAMERA_OK != (rc = stopRdi(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: Stopvideorecording() err=%d\n", __func__, rc);
- break;
- }
- }
- CDBG_ERROR("SINGLE close RDI");
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (result != (MM_QCAMERA_APP_INTERATION * MM_QCAMERA_APP_INTERATION)) {
- printf("%s: Video Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
- end:
- if (rc == 0) {
- printf("\nPassed\n");
- } else {
- printf("\nFailed\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_tc_10(mm_camera_app_t *cam_apps)
-{
- int rc = MM_CAMERA_OK;
- int i,j;
- int result = 0;
-
- printf("\n Verifying RAW Snapshot on front and back camera...\n");
- for (i = 0; i < cam_apps->num_cameras; i++) {
- if ( mm_app_open(i) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_open() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (system_dimension_set(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:system_dimension_set() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
-
- if ( MM_CAMERA_OK != (rc = startPreview(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- for (j = 0; j < MM_QCAMERA_APP_INTERATION; j++) {
- if ( MM_CAMERA_OK != (rc = takePicture_raw(my_cam_app.cam_open))) {
- CDBG_ERROR("%s: TakePicture() err=%d\n", __func__, rc);
- break;
- }
- /*if(mm_camera_app_timedwait() == ETIMEDOUT) {
- CDBG_ERROR("%s: Snapshot/Preview Callback not received in time or qbuf Faile\n", __func__);
- break;
- }*/
- mm_camera_app_wait();
- result++;
- }
- if ( MM_CAMERA_OK != (rc = stopPreview(my_cam_app.cam_open))) {
- CDBG("%s: startPreview() err=%d\n", __func__, rc);
- break;
- }
- if ( mm_app_close(my_cam_app.cam_open) != MM_CAMERA_OK) {
- CDBG_ERROR("%s:mm_app_close() err=%d\n",__func__, rc);
- rc = -1;
- goto end;
- }
- if (result != MM_QCAMERA_APP_INTERATION) {
- printf("%s: Snapshot Start/Stop Fails for Camera %d in %d iteration", __func__, i,j);
- rc = -1;
- break;
- }
-
- result = 0;
- }
- end:
- if (rc == 0) {
- printf("\t***Passed***\n");
- } else {
- printf("\t***Failed***\n");
- }
- CDBG("%s:END, rc = %d\n", __func__, rc);
- return rc;
-}
-
-int mm_app_gen_test_cases()
-{
- int tc = 0;
- memset(mm_app_tc, 0, sizeof(mm_app_tc));
- if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_0;
- if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_1;
- if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_2;
- //if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_3; /*Enable only when RDI enabled for front camera*/
- //if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_4;
- /*if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_5;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_6;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_7;
- if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_8;*/
- //if(tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_9; /*Enable only when rdi enabled for front camera*/
- if (tc < MM_QCAM_APP_TEST_NUM) mm_app_tc[tc++].f = mm_app_tc_10;
-
- /* test case for reprocess with preview only */
- /*
- if (tc < MM_QCAM_APP_TEST_NUM) {
- mm_app_tc[tc++].f = mm_app_tc_reprocess_preview_only;
- }
- */
- /* test case for reprocess with preview and recording */
- /*
- if (tc < MM_QCAM_APP_TEST_NUM) {
- mm_app_tc[tc++].f = mm_app_tc_reprocess_preview_and_recording;
- }
- */
-
- return tc;
-}
-
-int mm_app_unit_test_entry(mm_camera_app_t *cam_app)
-{
- int rc = MM_CAMERA_OK;
- int i, tc = 0;
- int cam_id = 0;
-
- tc = mm_app_gen_test_cases();
- CDBG("Running %d test cases\n",tc);
- for (i = 0; i < tc; i++) {
- mm_app_tc[i].r = mm_app_tc[i].f(cam_app);
- if (mm_app_tc[i].r != MM_CAMERA_OK) {
- printf("%s: test case %d error = %d, abort unit testing engine!!!!\n",
- __func__, i, mm_app_tc[i].r);
- rc = mm_app_tc[i].r;
- goto end;
- }
- }
- end:
- printf("nTOTAL_TSET_CASE = %d, NUM_TEST_RAN = %d, rc=%d\n", tc, i, rc);
- return rc;
-}
-
-
-
-
diff --git a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_video.c b/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_video.c
deleted file mode 100755
index f19b82e..0000000
--- a/camera/QCamera/stack/mm-camera-test/src/mm_qcamera_video.c
+++ /dev/null
@@ -1,500 +0,0 @@
-/*
-Copyright (c) 2011-2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include "mm_camera_dbg.h"
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include "mm_qcamera_app.h"
-
-#define BUFF_SIZE_128 128
-static int num_run = 0;
-
-extern int mm_app_set_live_snapshot_fmt(int cam_id,mm_camera_image_fmt_t *fmt);
-extern void dumpFrameToFile(mm_camera_buf_def_t* newFrame, int w, int h,
- char* name, int main_422,char *ext);
-extern int initDisplay();
-extern int mm_app_prepare_preview(int cam_id);
-extern int mm_stream_invalid_cache(mm_camera_app_obj_t *pme,
- mm_camera_buf_def_t *frame);
-
-static int mm_app_dump_video_frame(struct msm_frame *frame,
- uint32_t len)
-{
- static int v_cnt = 0;
- char bufp[BUFF_SIZE_128];
- int file_fdp;
- int rc = 0;
-
- return rc; /* disable dump */
-
- v_cnt++;
- if(0 == (v_cnt % 10))
- snprintf(bufp, BUFF_SIZE_128, "/data/v_%d.yuv", v_cnt);
- else
- return 0;
-
- file_fdp = open(bufp, O_RDWR | O_CREAT, 0777);
-
- if (file_fdp < 0) {
- CDBG("cannot open file %s\n", bufp);
- rc = -1;
- goto end;
- }
- CDBG("%s:dump frame to '%s'\n", __func__, bufp);
- write(file_fdp,
- (const void *)frame->buffer, len);
- close(file_fdp);
-end:
- return rc;
-}
-
-static int mm_app_set_video_fmt(int cam_id,mm_camera_image_fmt_t *fmt)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- fmt->meta_header = MM_CAMEAR_META_DATA_TYPE_DEF;
- fmt->fmt = pme->dim.enc_format;
- fmt->width = pme->dim.video_width;
- fmt->height = pme->dim.video_height;
- return rc;
-}
-
-#if 0
-int mm_stream_deinit_video_buf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data, uint8_t num_bufs,
- mm_camera_buf_def_t *bufs)
-{
- int i, rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-
- for(i = 0; i < num_bufs; i++) {
- rc = my_cam_app.hal_lib.mm_camera_do_munmap_ion (pme->ionfd, &(pme->video_buf.frame[i].fd_data),
- (void *)pme->video_buf.frame[i].buffer, pme->video_buf.frame_len);
- if(rc != MM_CAMERA_OK) {
- CDBG_ERROR("%s: mm_camera_do_munmap err, pmem_fd = %d, rc = %d",
- __func__, bufs[i].fd, rc);
- }
- }
- return rc;
-}
-
-int mm_stream_init_video_buf(uint32_t camera_handle,
- uint32_t ch_id, uint32_t stream_id,
- void *user_data,
- mm_camera_frame_len_offset *frame_offset_info,
- uint8_t num_bufs,
- uint8_t *initial_reg_flag,
- mm_camera_buf_def_t *bufs)
-{
- int i,j,num_planes, frame_len, y_off, cbcr_off;
- uint32_t planes[VIDEO_MAX_PLANES];
- uint32_t pmem_addr = 0;
-
- mm_camera_app_obj_t *pme = (mm_camera_app_obj_t *)user_data;
-
- num_planes = frame_offset_info->num_planes;
- for ( i = 0; i < num_planes; i++) {
- planes[i] = frame_offset_info->mp[i].len;
- }
-
- frame_len = frame_offset_info->frame_len;
- y_off = frame_offset_info->mp[0].offset;
- cbcr_off = frame_offset_info->mp[1].offset;
-
- CDBG("Allocating video Memory for %d buffers frame_len = %d",num_bufs,frame_offset_info->frame_len);
-
- for (i = 0; i < num_bufs ; i++) {
- int j;
- pme->video_buf.reg[i] = 1;
- initial_reg_flag[i] = 1;
-
- pme->video_buf.frame_len = frame_len;
- pme->video_buf.frame[i].ion_alloc.len = pme->video_buf.frame_len;
- pme->video_buf.frame[i].ion_alloc.flags =
- (0x1 << CAMERA_ION_HEAP_ID | 0x1 << ION_IOMMU_HEAP_ID);
- pme->video_buf.frame[i].ion_alloc.align = 4096;
-
- pmem_addr = (unsigned long) my_cam_app.hal_lib.mm_camera_do_mmap_ion(pme->ionfd,
- &(pme->video_buf.frame[i].ion_alloc), &(pme->video_buf.frame[i].fd_data),
- &pme->video_buf.frame[i].fd);
-
- pme->video_buf.frame[i].buffer = pmem_addr;
- pme->video_buf.frame[i].path = OUTPUT_TYPE_V;
- pme->video_buf.frame[i].y_off = 0;
- pme->video_buf.frame[i].cbcr_off = planes[0];
- pme->video_buf.frame[i].phy_offset = 0;
-
- CDBG("Buffer allocated Successfully fd = %d",pme->video_buf.frame[i].fd);
-
- bufs[i].fd = pme->video_buf.frame[i].fd;
- //bufs[i].buffer = pmem_addr;
- bufs[i].frame_len = pme->video_buf.frame[i].ion_alloc.len;
- bufs[i].num_planes = num_planes;
-
- bufs[i].frame = &pme->video_buf.frame[i];
-
- /* Plane 0 needs to be set seperately. Set other planes
- * in a loop. */
- bufs[i].planes[0].length = planes[0];
- bufs[i].planes[0].m.userptr = bufs[i].fd;
- bufs[i].planes[0].data_offset = y_off;
- bufs[i].planes[0].reserved[0] = 0;
- //buf_def->buf.mp[i].frame_offset;
- for (j = 1; j < num_planes; j++) {
- bufs[i].planes[j].length = planes[j];
- bufs[i].planes[j].m.userptr = bufs[i].fd;
- bufs[i].planes[j].data_offset = cbcr_off;
- bufs[i].planes[j].reserved[0] =
- bufs[i].planes[j-1].reserved[0] +
- bufs[i].planes[j-1].length;
- }
- }
- return MM_CAMERA_OK;
-}
-#endif
-
-void video_cb_signal(mm_camera_app_obj_t *pme)
-{
- if(pme->cam_state == CAMERA_STATE_RECORD) {
- mm_camera_app_done();
- }
-}
-
-static void mm_app_video_notify_cb(mm_camera_super_buf_t *bufs,
- void *user_data)
-{
- int rc;
- char buf[32];
- mm_camera_buf_def_t *frame = NULL;
- mm_camera_app_obj_t *pme = NULL;
- CDBG("%s: BEGIN\n", __func__);
- frame = bufs->bufs[MM_CAMERA_PREVIEW] ;
- pme = (mm_camera_app_obj_t *)user_data;
-
- CDBG("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx);
- //Need to code to Send to Encoder .. Simulat
- CDBG("In CB function i/p = %p o/p = %p",bufs->bufs[MM_CAMERA_PREVIEW],frame);
-
- snprintf(buf, sizeof(buf), "V_%dx%d_C%d", pme->dim.orig_video_width,
- pme->dim.orig_video_height, pme->cam->camera_info->camera_id);
-
- dumpFrameToFile(frame, pme->dim.orig_video_width,
- pme->dim.orig_video_height, buf, 1,"yuv");
-
- if(MM_CAMERA_OK != pme->cam->ops->qbuf(pme->cam->camera_handle,pme->ch_id,frame))
- {
- CDBG_ERROR("%s: Failed in Snapshot Qbuf\n", __func__);
- return;
- }
- mm_stream_invalid_cache(pme,frame);
- video_cb_signal(pme);
- CDBG("%s: END\n", __func__);
-
-}
-
-int mm_app_config_video(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- mm_app_set_video_fmt(cam_id,&pme->stream[MM_CAMERA_VIDEO].str_config.fmt);
- pme->stream[MM_CAMERA_VIDEO].str_config.need_stream_on = 1;
- pme->stream[MM_CAMERA_VIDEO].str_config.num_of_bufs = VIDEO_BUF_NUM;
-
- if(MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_VIDEO].id,
- &pme->stream[MM_CAMERA_VIDEO].str_config))) {
- CDBG_ERROR("%s:MM_CAMERA_VIDEO config streaming err=%d\n", __func__, rc);
- goto end;
- }
-
- CDBG("config_stream stream is successfull");
-
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.need_stream_on = pme->fullSizeSnapshot;
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.num_of_bufs = 1;
-
- mm_app_set_live_snapshot_fmt(cam_id,&pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config.fmt);
-
- if(MM_CAMERA_OK != (rc = pme->cam->ops->config_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id,
- &pme->stream[MM_CAMERA_SNAPSHOT_MAIN].str_config))) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- goto end;
- }
-end:
- return rc;
-
-}
-
-int mm_app_prepare_video(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- pme->stream[MM_CAMERA_VIDEO].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
- mm_app_video_notify_cb,pme,
- MM_CAMERA_VIDEO, 0);
-
- if(!pme->stream[MM_CAMERA_VIDEO].id) {
- CDBG("%s:MM_CAMERA_VIDEO streaming err = %d\n", __func__, rc);
- rc = -1;
- goto end;
- }
-
- CDBG("Add stream is successfull stream ID = %d",pme->stream[MM_CAMERA_PREVIEW].id);
-
- /* Code to add live snapshot*/
- pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id = pme->cam->ops->add_stream(pme->cam->camera_handle,pme->ch_id,
- NULL,pme,
- MM_CAMERA_SNAPSHOT_MAIN, 0);
-
- CDBG("Add Snapshot main is successfull stream ID = %d",pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id);
- if(!pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id) {
- CDBG_ERROR("%s:preview streaming err=%d\n", __func__, rc);
- rc = -1;
- goto end;
- }
- /*if(mm_app_config_video(cam_id) != MM_CAMERA_OK)
- {
- CDBG_ERROR("%s:Video config err=%d\n", __func__, rc);
- }*/
-end:
- return rc;
-}
-
-int mm_app_unprepare_video(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if(MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_VIDEO].id))){
- CDBG_ERROR("%s : Delete Stream Video error",__func__);
- goto end;
- }
-
- if(MM_CAMERA_OK != (rc = pme->cam->ops->del_stream(pme->cam->camera_handle,pme->ch_id,pme->stream[MM_CAMERA_SNAPSHOT_MAIN].id))){
- CDBG_ERROR("%s : Delete Stream Video error",__func__);
- goto end;
- }
-end:
- CDBG("del_stream successfull");
- return rc;
-}
-
-static int mm_app_streamon_video(int cam_id)
-{
- uint32_t stream;
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if(mm_app_config_video(cam_id) != MM_CAMERA_OK)
- {
- CDBG_ERROR("%s:Video config err=%d\n", __func__, rc);
- }
-
- stream = pme->stream[MM_CAMERA_VIDEO].id;
- if(MM_CAMERA_OK != (rc = pme->cam->ops->start_streams(pme->cam->camera_handle,pme->ch_id,1,&stream)))
- {
- CDBG_ERROR("%s : Start Stream video Error",__func__);
- return -1;
- }
- CDBG("Start video stream is successfull");
- pme->cam_state = CAMERA_STATE_RECORD;
- return rc;
-}
-
-static int mm_app_streamoff_video(int cam_id)
-{
- uint32_t stream;
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream = pme->stream[MM_CAMERA_VIDEO].id;
-
- if(MM_CAMERA_OK != (rc =pme->cam->ops->stop_streams(pme->cam->camera_handle,pme->ch_id,1,&stream)))
- {
- CDBG_ERROR("%s : stop Stream video Error",__func__);
- goto end;
- }
- CDBG("stop video stream is successfull");
- pme->cam_state = CAMERA_STATE_PREVIEW;
-end:
- return rc;
-
-}
-int mm_app_stop_video(int cam_id)
-{
- int stream[2];
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- stream[0] = pme->stream[MM_CAMERA_VIDEO].id;
-
- if(MM_CAMERA_OK != (rc = mm_app_streamoff_video(cam_id))){
- CDBG_ERROR("%s : Video Stream off error",__func__);
- goto end;
- }
-end:
- return rc;
-}
-
-static int mm_app_start_video(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("pme = %p, pme->cam =%p, pme->ch = %d pme->cam->camera_handle = %d",
- pme,pme->cam,pme->ch_id,pme->cam->camera_handle);
-
- if(MM_CAMERA_OK != (rc = mm_app_prepare_video(cam_id))){
- CDBG_ERROR("%s:MM_CAMERA_VIDEO streaming err = %d\n", __func__, rc);
- goto end;
- }
- if(MM_CAMERA_OK != (rc = mm_app_streamon_video(cam_id))){
- CDBG_ERROR("%s:MM_CAMERA_VIDEO streaming err = %d\n", __func__, rc);
- goto end;
- }
-
-end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
-
- return rc;
-}
-
-int mm_app_open_recorder(int cam_id)
-{
- int rc = MM_CAMERA_OK;
- int value = 1;
- int powermode = 1;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: mm_app_open_recorder",__func__);
- if(pme->cam_mode == RECORDER_MODE) {
- CDBG("%s : Already in record mode",__func__);
- return rc;
- }
-
- if(MM_CAMERA_OK != (rc = mm_app_stop_preview(cam_id))){
- CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
- goto end;
- }
- usleep(10*1000);
-
- if(MM_CAMERA_OK != initDisplay())
- {
- CDBG_ERROR("%s : Could not initalize display",__func__);
- goto end;
- }
-
- pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_RECORDING_HINT, &value);
-
- pme->cam->ops->set_parm(pme->cam->camera_handle,MM_CAMERA_PARM_LOW_POWER_MODE, &powermode);
-
-
- if(MM_CAMERA_OK != (rc = mm_app_prepare_preview(cam_id))){
- CDBG_ERROR("%s:stream on preview err=%d\n", __func__, rc);
- goto end;
- }
-
- if(MM_CAMERA_OK != (rc = mm_app_prepare_video(cam_id))){
- CDBG_ERROR("%s:stream on video err=%d\n", __func__, rc);
- goto end;
- }
-
- if(MM_CAMERA_OK != (rc = mm_app_streamon_preview(cam_id))){
- CDBG_ERROR("%s:start preview err=%d\n", __func__, rc);
- goto end;
- }
- pme->cam_mode = RECORDER_MODE;
-end:
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int startRecording(int cam_id)
-{
- int rc = MM_CAMERA_OK;
-
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- CDBG("%s: Start Recording mode = %d state = %d",__func__,pme->cam_mode,pme->cam_state);
-
- if(pme->cam_mode == CAMERA_MODE || pme->cam_mode == ZSL_MODE) {
- switch(pme->cam_state) {
- case CAMERA_STATE_PREVIEW:
- if(MM_CAMERA_OK != mm_app_open_recorder(cam_id)){
- CDBG_ERROR("%s: Open Record Failed \n", __func__);
- return -1;
- }
- break;
- case CAMERA_STATE_RECORD:
- case CAMERA_STATE_SNAPSHOT:
- default:
- break;
- }
- }/*else{
- mm_app_prepare_video(cam_id);
- }*/
- CDBG("%s : startRecording : mode = %d state = %d",__func__,pme->cam_mode,pme->cam_state);
- if(pme->cam_mode == RECORDER_MODE && pme->cam_state == CAMERA_STATE_PREVIEW){
- if(MM_CAMERA_OK != mm_app_streamon_video(cam_id)){
- CDBG_ERROR("%s:start video err=%d\n", __func__, rc);
- return -1;
- }
- }
- CDBG("%s: END, rc=%d\n", __func__, rc);
- return rc;
-}
-
-int stopRecording(int cam_id)
-{
-
- int rc = MM_CAMERA_OK;
- mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
-
- if(pme->cam_mode != RECORDER_MODE || pme->cam_state != CAMERA_STATE_RECORD) {
- return rc;
- }
- if(MM_CAMERA_OK != mm_app_stop_video(cam_id)){
- CDBG_ERROR("%s:stop video err=%d\n", __func__, rc);
- return -1;
- }
- return rc;
-}
-
diff --git a/camera/QCamera/stack/mm-jpeg-interface/Android.mk b/camera/QCamera/stack/mm-jpeg-interface/Android.mk
deleted file mode 100755
index c7d151c..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/Android.mk
+++ /dev/null
@@ -1,38 +0,0 @@
-OLD_LOCAL_PATH := $(LOCAL_PATH)
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_CFLAGS+= -D_ANDROID_
-LOCAL_COPY_HEADERS_TO := mm-camera-interface
-LOCAL_COPY_HEADERS = inc/mm_jpeg_interface.h
-
-LOCAL_C_INCLUDES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include/media
-LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
-
-LOCAL_C_INCLUDES += \
- $(LOCAL_PATH)/inc \
- $(LOCAL_PATH)/../common \
- $(LOCAL_PATH)/../../../ \
- $(TARGET_OUT_HEADERS)/mm-still \
- $(TARGET_OUT_HEADERS)/mm-still/jpeg \
- $(TARGET_OUT_HEADERS)/mm-core/omxcore \
- $(TARGET_OUT_HEADERS)/mm-still/mm-omx
-
-ifeq ($(strip $(TARGET_USES_ION)),true)
- LOCAL_CFLAGS += -DUSE_ION
-endif
-
-LOCAL_SRC_FILES := \
- src/mm_jpeg_queue.c \
- src/mm_jpeg.c \
- src/mm_jpeg_interface.c
-
-LOCAL_MODULE := libmmjpeg_interface
-LOCAL_PRELINK_MODULE := false
-LOCAL_SHARED_LIBRARIES := libdl libcutils liblog libmmstillomx libimage-jpeg-enc-omx-comp
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_SHARED_LIBRARY)
-
-LOCAL_PATH := $(OLD_LOCAL_PATH)
diff --git a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg.h b/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg.h
deleted file mode 100755
index be08427..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg.h
+++ /dev/null
@@ -1,168 +0,0 @@
-
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
-
-#ifndef MM_JPEG_H_
-#define MM_JPEG_H_
-
-#include "mm_jpeg_interface.h"
-#include "cam_list.h"
-#include "OMX_Types.h"
-#include "OMX_Index.h"
-#include "OMX_Core.h"
-#include "OMX_Component.h"
-#include "omx_jpeg_ext.h"
-#include <semaphore.h>
-
-typedef struct {
- struct cam_list list;
- void* data;
-} mm_jpeg_q_node_t;
-
-typedef struct {
- mm_jpeg_q_node_t head; /* dummy head */
- uint32_t size;
- pthread_mutex_t lock;
-} mm_jpeg_queue_t;
-
-typedef enum
-{
- MM_JPEG_CMD_TYPE_JOB, /* job cmd */
- MM_JPEG_CMD_TYPE_EXIT, /* EXIT cmd for exiting jobMgr thread */
- MM_JPEG_CMD_TYPE_MAX
-} mm_jpeg_cmd_type_t;
-
-typedef struct {
- OMX_BUFFERHEADERTYPE* buf_header;
- uint32_t portIdx;
-} mm_jpeg_omx_buf_info;
-
-typedef struct {
- uint8_t num_bufs;
- mm_jpeg_omx_buf_info bufs[MAX_SRC_BUF_NUM];
-} mm_jpeg_omx_src_buf;
-
-typedef struct {
- uint32_t client_hdl; /* client handler */
- uint32_t jobId; /* job ID */
- mm_jpeg_job job; /* job description */
- pthread_t cb_pid; /* cb thread heandler*/
-
- void* jpeg_obj; /* ptr to mm_jpeg_obj */
- jpeg_job_status_t job_status; /* job status */
- uint8_t thumbnail_dropped; /* flag indicating if thumbnail is dropped */
- int32_t jpeg_size; /* the size of jpeg output after job is done */
-
- mm_jpeg_omx_src_buf src_bufs[JPEG_SRC_IMAGE_TYPE_MAX];
- mm_jpeg_omx_buf_info sink_buf;
-} mm_jpeg_job_entry;
-
-typedef struct {
- mm_jpeg_cmd_type_t type;
- union {
- mm_jpeg_job_entry entry;
- };
-} mm_jpeg_job_q_node_t;
-
-typedef struct {
- uint8_t is_used; /* flag: if is a valid client */
- uint32_t client_handle; /* client handle */
-} mm_jpeg_client_t;
-
-typedef struct {
- pthread_t pid; /* job cmd thread ID */
- sem_t job_sem; /* semaphore for job cmd thread */
- mm_jpeg_queue_t job_queue; /* queue for job to do */
-} mm_jpeg_job_cmd_thread_t;
-
-typedef enum {
- MM_JPEG_EVENT_MASK_JPEG_DONE = 0x00000001, /* jpeg job is done */
- MM_JPEG_EVENT_MASK_JPEG_ABORT = 0x00000002, /* jpeg job is aborted */
- MM_JPEG_EVENT_MASK_JPEG_ERROR = 0x00000004, /* jpeg job has error */
- MM_JPEG_EVENT_MASK_CMD_COMPLETE = 0x00000100 /* omx cmd complete evt */
-} mm_jpeg_event_mask_t;
-
-typedef struct {
- uint32_t evt;
- int omx_value1; /* only valid when evt_mask == MM_JPEG_EVENT_MASK_CMD_COMPLETE */
- int omx_value2; /* only valid when evt_mask == MM_JPEG_EVENT_MASK_CMD_COMPLETE */
-} mm_jpeg_evt_t;
-
-#define MAX_JPEG_CLIENT_NUM 8
-typedef struct mm_jpeg_obj_t {
- /* ClientMgr */
- int num_clients; /* num of clients */
- mm_jpeg_client_t clnt_mgr[MAX_JPEG_CLIENT_NUM]; /* client manager */
-
- /* JobMkr */
- pthread_mutex_t job_lock; /* job lock */
- mm_jpeg_job_cmd_thread_t job_mgr; /* job mgr thread including todo_q*/
- mm_jpeg_queue_t ongoing_job_q; /* queue for ongoing jobs */
-
- /* Notifier */
- mm_jpeg_queue_t cb_q; /* queue for CB threads */
-
- /* OMX related */
- OMX_HANDLETYPE omx_handle; /* handle to omx engine */
- OMX_CALLBACKTYPE omx_callbacks; /* callbacks to omx engine */
-
- pthread_mutex_t omx_evt_lock;
- pthread_cond_t omx_evt_cond;
- mm_jpeg_evt_t omx_evt_rcvd;
-} mm_jpeg_obj;
-
-extern int32_t mm_jpeg_init(mm_jpeg_obj *my_obj);
-extern int32_t mm_jpeg_deinit(mm_jpeg_obj *my_obj);
-extern uint32_t mm_jpeg_new_client(mm_jpeg_obj *my_obj);
-extern int32_t mm_jpeg_start_job(mm_jpeg_obj *my_obj,
- uint32_t client_hdl,
- mm_jpeg_job* job,
- uint32_t* jobId);
-extern int32_t mm_jpeg_abort_job(mm_jpeg_obj *my_obj,
- uint32_t client_hdl,
- uint32_t jobId);
-extern int32_t mm_jpeg_close(mm_jpeg_obj *my_obj,
- uint32_t client_hdl);
-
-/* utiltity fucntion declared in mm-camera-inteface2.c
- * and need be used by mm-camera and below*/
-uint32_t mm_jpeg_util_generate_handler(uint8_t index);
-uint8_t mm_jpeg_util_get_index_by_handler(uint32_t handler);
-
-/* basic queue functions */
-extern int32_t mm_jpeg_queue_init(mm_jpeg_queue_t* queue);
-extern int32_t mm_jpeg_queue_enq(mm_jpeg_queue_t* queue, void* node);
-extern void* mm_jpeg_queue_peek(mm_jpeg_queue_t* queue);
-extern void* mm_jpeg_queue_deq(mm_jpeg_queue_t* queue);
-extern int32_t mm_jpeg_queue_deinit(mm_jpeg_queue_t* queue);
-extern int32_t mm_jpeg_queue_flush(mm_jpeg_queue_t* queue);
-extern uint32_t mm_jpeg_queue_get_size(mm_jpeg_queue_t* queue);
-
-#endif /* MM_JPEG_H_ */
-
-
diff --git a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h b/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h
deleted file mode 100755
index 775d32a..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#ifndef __MM_JPEG_DBG_H__
-#define __MM_JPEG_DBG_H__
-
-//#define LOG_DEBUG 0
-
-#ifndef LOG_DEBUG
- #ifdef _ANDROID_
- #undef LOG_NIDEBUG
- #undef LOG_TAG
- #define LOG_NIDEBUG 0
- #define LOG_TAG "mm-jpeg-intf"
- #include <utils/Log.h>
- #else
- #include <stdio.h>
- #define ALOGE CDBG
- #endif
- #undef CDBG
- #define CDBG(fmt, args...) do{}while(0)
-#else
- #ifdef _ANDROID_
- #undef LOG_NIDEBUG
- #undef LOG_TAG
- #define LOG_NIDEBUG 0
- #define LOG_TAG "mm-jpeg-intf"
- #include <utils/Log.h>
- #define CDBG(fmt, args...) ALOGE(fmt, ##args)
- #else
- #include <stdio.h>
- #define CDBG(fmt, args...) fprintf(stderr, fmt, ##args)
- #define ALOGE(fmt, args...) fprintf(stderr, fmt, ##args)
- #endif
-#endif
-
-#ifdef _ANDROID_
- #define CDBG_HIGH(fmt, args...) ALOGE(fmt, ##args)
- #define CDBG_ERROR(fmt, args...) ALOGE(fmt, ##args)
-#else
- #define CDBG_HIGH(fmt, args...) fprintf(stderr, fmt, ##args)
- #define CDBG_ERROR(fmt, args...) fprintf(stderr, fmt, ##args)
-#endif
-#endif /* __MM_JPEG_DBG_H__ */
diff --git a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_interface.h b/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_interface.h
deleted file mode 100755
index cd1c9c8..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/inc/mm_jpeg_interface.h
+++ /dev/null
@@ -1,217 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * 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.
- */
-
-#ifndef MM_JPEG_INTERFACE_H_
-#define MM_JPEG_INTERFACE_H_
-#include "QCamera_Intf.h"
-
-typedef struct {
- int width;
- int height;
-} image_resolution;
-
-typedef enum {
- JPEG_SRC_IMAGE_FMT_YUV,
- JPEG_SRC_IMAGE_FMT_BITSTREAM
-} jpeg_enc_src_img_fmt_t;
-
-typedef enum {
- JPEG_SRC_IMAGE_TYPE_MAIN,
- JPEG_SRC_IMAGE_TYPE_THUMB,
- JPEG_SRC_IMAGE_TYPE_MAX
-} jpeg_enc_src_img_type_t;
-
-typedef struct {
- int32_t offset_x;
- int32_t offset_y;
- int32_t width;
- int32_t height;
-} image_crop_t;
-
-typedef struct {
- uint8_t sequence; /*for jpeg bit streams, assembling is based on sequence. sequence starts from 0*/
- uint8_t *buf_vaddr; /*ptr to buf*/
- int fd; /*fd of buf*/
- uint32_t buf_size; /* total size of buf (header + image) */
- uint32_t data_offset; /*data offset*/
-} src_bitstream_buffer_t;
-
-typedef struct {
- uint8_t *buf_vaddr; /*ptr to buf*/
- int fd; /*fd of buf*/
- cam_frame_len_offset_t offset; /*alway use multi-planar, offset is used to skip the metadata header*/
-} src_image_buffer_t;
-
-typedef enum {
- MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2,
- MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2,
- MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1,
- MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1,
- MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2,
- MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2,
- MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1,
- MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1,
- MM_JPEG_COLOR_FORMAT_RGB565,
- MM_JPEG_COLOR_FORMAT_RGB888,
- MM_JPEG_COLOR_FORMAT_RGBa,
- MM_JPEG_COLOR_FORMAT_BITSTREAM,
- MM_JPEG_COLOR_FORMAT_MAX
-} mm_jpeg_color_format;
-
-#define MAX_SRC_BUF_NUM 2
-typedef struct {
- /* src img format: YUV, Bitstream */
- jpeg_enc_src_img_fmt_t img_fmt;
-
- /* num of buf in src img */
- uint8_t num_bufs;
-
- /* src img bufs */
- union {
- src_bitstream_buffer_t bit_stream[MAX_SRC_BUF_NUM];
- src_image_buffer_t src_image[MAX_SRC_BUF_NUM];
- };
-
- /* src img type: main or thumbnail */
- jpeg_enc_src_img_type_t type;
-
- /* color format */
- mm_jpeg_color_format color_format;
-
- /* src img dimension */
- image_resolution src_dim;
-
- /* jpeg output dimension */
- image_resolution out_dim;
-
- /* crop information */
- image_crop_t crop;
-
- /* jpeg quality: range 0~100 */
- uint32_t quality;
-} src_image_buffer_info;
-
-typedef struct {
- uint8_t *buf_vaddr; /*ptr to buf*/
- int fd; /*fd of buf*/
- int buf_len;
-} out_image_buffer_info;
-
-typedef struct {
- /* num of src imgs: e.g. main/thumbnail img
- * if main img only: src_img_num = 1;
- * if main+thumbnail: src_img_num = 2;
- * No support for thumbnail only case */
- uint8_t src_img_num;
-
- /* index 0 is always for main image
- * if thumbnail presented, it will be in index 1 */
- src_image_buffer_info src_img[JPEG_SRC_IMAGE_TYPE_MAX];
-
- /* flag indicating if buffer is from video stream (special case for video-sized live snapshot) */
- uint8_t is_video_frame;
-} src_image_buffer_config;
-
-typedef struct {
- src_image_buffer_config src_imgs;
- out_image_buffer_info sink_img;
-} jpeg_image_buffer_config;
-
-typedef struct {
- /* config for scr images */
- jpeg_image_buffer_config buf_info;
-
- /* rotation informaiton */
- int rotation;
-
- /* num of exif entries */
- int exif_numEntries;
-
- /* buf to exif entries, caller needs to
- * take care of the memory manage with insider ptr */
- exif_tags_info_t *exif_data;
-
- /*for mobicat support*/
- const uint8_t * mobicat_data;
- int32_t mobicat_data_length;
- int hasmobicat;
-} mm_jpeg_encode_params;
-
-typedef enum {
- JPEG_JOB_STATUS_DONE = 0,
- JPEG_JOB_STATUS_ERROR
-} jpeg_job_status_t;
-
-typedef void (*jpeg_encode_callback_t)(jpeg_job_status_t status,
- uint8_t thumbnailDroppedFlag,
- uint32_t client_hdl,
- uint32_t jobId,
- uint8_t* out_data,
- uint32_t data_size,
- void *userData);
-
-typedef struct {
- mm_jpeg_encode_params encode_parm;
- jpeg_encode_callback_t jpeg_cb;
- void* userdata;
-} mm_jpeg_encode_job;
-
-typedef enum {
- JPEG_JOB_TYPE_ENCODE,
- //JPEG_JOB_TYPE_DECODE, /*enable decode later*/
- JPEG_JOB_TYPE_MAX
-} mm_jpeg_job_type_t;
-
-typedef struct {
- mm_jpeg_job_type_t job_type;
- union {
- mm_jpeg_encode_job encode_job;
- };
-} mm_jpeg_job;
-
-typedef struct {
- /* start a job -- async call
- * the result of job (DONE/ERROR) will rcvd through CB */
- int32_t (* start_job) (uint32_t client_hdl, mm_jpeg_job* job, uint32_t* jobId);
-
- /* abort a job -- sync call */
- int32_t (* abort_job) (uint32_t client_hdl, uint32_t jobId);
-
- /* close a jpeg client -- sync call */
- int32_t (* close) (uint32_t clientHdl);
-} mm_jpeg_ops_t;
-
-/* open a jpeg client -- sync call
- * returns client_handle.
- * failed if client_handle=0
- * jpeg ops tbl will be filled in if open succeeds */
-uint32_t jpeg_open(mm_jpeg_ops_t *ops);
-
-#endif /* MM_JPEG_INTERFACE_H_ */
-
-
diff --git a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg.c b/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg.c
deleted file mode 100755
index 442ecb9..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg.c
+++ /dev/null
@@ -1,1417 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <semaphore.h>
-
-#include "mm_jpeg_dbg.h"
-#include "mm_jpeg_interface.h"
-#include "mm_jpeg.h"
-
-/* define max num of supported concurrent jpeg jobs by OMX engine.
- * Current, only one per time */
-#define NUM_MAX_JPEG_CNCURRENT_JOBS 1
-
-#define INPUT_PORT_MAIN 0
-#define INPUT_PORT_THUMBNAIL 2
-#define OUTPUT_PORT 1
-
-void mm_jpeg_job_wait_for_event(mm_jpeg_obj *my_obj, uint32_t evt_mask);
-void mm_jpeg_job_wait_for_cmd_complete(mm_jpeg_obj *my_obj,
- int cmd,
- int status);
-OMX_ERRORTYPE mm_jpeg_etbdone(OMX_HANDLETYPE hComponent,
- OMX_PTR pAppData,
- OMX_BUFFERHEADERTYPE* pBuffer);
-OMX_ERRORTYPE mm_jpeg_ftbdone(OMX_HANDLETYPE hComponent,
- OMX_PTR pAppData,
- OMX_BUFFERHEADERTYPE* pBuffer);
-OMX_ERRORTYPE mm_jpeg_handle_omx_event(OMX_HANDLETYPE hComponent,
- OMX_PTR pAppData,
- OMX_EVENTTYPE eEvent,
- OMX_U32 nData1,
- OMX_U32 nData2,
- OMX_PTR pEventData);
-/* special queue functions for job queue */
-int32_t mm_jpeg_queue_update_flag(mm_jpeg_queue_t* queue, uint32_t job_id, uint8_t flag);
-mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_client_id(mm_jpeg_queue_t* queue, uint32_t client_hdl);
-mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_job_id(mm_jpeg_queue_t* queue, uint32_t job_id);
-
-static OMX_INDEXTYPE mobicat_data;
-static omx_jpeg_mobicat mobicat_d;
-
-int32_t mm_jpeg_omx_load(mm_jpeg_obj* my_obj)
-{
- int32_t rc = 0;
-
- my_obj->omx_callbacks.EmptyBufferDone = mm_jpeg_etbdone;
- my_obj->omx_callbacks.FillBufferDone = mm_jpeg_ftbdone;
- my_obj->omx_callbacks.EventHandler = mm_jpeg_handle_omx_event;
- rc = OMX_GetHandle(&my_obj->omx_handle,
- "OMX.qcom.image.jpeg.encoder",
- (void*)my_obj,
- &my_obj->omx_callbacks);
-
- if (0 != rc) {
- CDBG_ERROR("%s : OMX_GetHandle failed (%d)",__func__, rc);
- return rc;
- }
-
- rc = OMX_Init();
- if (0 != rc) {
- CDBG_ERROR("%s : OMX_Init failed (%d)",__func__, rc);
- }
-
- return rc;
-}
-
-int32_t mm_jpeg_omx_unload(mm_jpeg_obj *my_obj)
-{
- int32_t rc = 0;
- rc = OMX_Deinit();
- return rc;
-}
-
-int32_t mm_jpeg_clean_omx_job(mm_jpeg_obj *my_obj, mm_jpeg_job_entry* job_entry)
-{
- int32_t rc = 0;
- uint8_t i, j;
-
- OMX_SendCommand(my_obj->omx_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
- OMX_SendCommand(my_obj->omx_handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
-
- /* free buffers used in OMX processing */
- for (i = 0; i < JPEG_SRC_IMAGE_TYPE_MAX; i++) {
- for (j = 0; j < job_entry->src_bufs[i].num_bufs; j++) {
- if (NULL != job_entry->src_bufs[i].bufs[j].buf_header) {
- OMX_FreeBuffer(my_obj->omx_handle,
- job_entry->src_bufs[i].bufs[j].portIdx,
- job_entry->src_bufs[i].bufs[j].buf_header);
- }
- }
- }
- OMX_FreeBuffer(my_obj->omx_handle,
- job_entry->sink_buf.portIdx,
- job_entry->sink_buf.buf_header);
-
- return rc;
-}
-
-int32_t mm_jpeg_omx_abort_job(mm_jpeg_obj *my_obj, mm_jpeg_job_entry* job_entry)
-{
- int32_t rc = 0;
-
- OMX_SendCommand(my_obj->omx_handle, OMX_CommandFlush, 0, NULL);
- mm_jpeg_job_wait_for_event(my_obj,
- MM_JPEG_EVENT_MASK_JPEG_DONE|MM_JPEG_EVENT_MASK_JPEG_ABORT|MM_JPEG_EVENT_MASK_JPEG_ERROR);
- CDBG("%s:waitForEvent: OMX_CommandFlush: DONE", __func__);
-
- /* clean omx job */
- mm_jpeg_clean_omx_job(my_obj, job_entry);
-
- return rc;
-}
-
-/* TODO: needs revisit after omx lib supports multi src buffers */
-int32_t mm_jpeg_omx_config_main_buffer_offset(mm_jpeg_obj* my_obj,
- src_image_buffer_info *src_buf,
- uint8_t is_video_frame)
-{
- int32_t rc = 0;
- uint8_t i;
- OMX_INDEXTYPE buf_offset_idx;
- omx_jpeg_buffer_offset buffer_offset;
-
- for (i = 0; i < src_buf->num_bufs; i++) {
- OMX_GetExtensionIndex(my_obj->omx_handle,
- "omx.qcom.jpeg.exttype.buffer_offset",
- &buf_offset_idx);
- memset(&buffer_offset, 0, sizeof(buffer_offset));
-
- switch (src_buf->img_fmt) {
- case JPEG_SRC_IMAGE_FMT_YUV:
- if (1 == src_buf->src_image[i].offset.num_planes) {
- buffer_offset.yOffset =
- src_buf->src_image[i].offset.sp.y_offset;
- buffer_offset.cbcrOffset =
- src_buf->src_image[i].offset.sp.cbcr_offset;
- buffer_offset.totalSize =
- src_buf->src_image[i].offset.sp.len;
- } else {
- buffer_offset.yOffset =
- src_buf->src_image[i].offset.mp[0].offset;
- buffer_offset.cbcrOffset =
- src_buf->src_image[i].offset.mp[1].offset;
- buffer_offset.totalSize =
- src_buf->src_image[i].offset.frame_len;
- }
- CDBG("%s: idx=%d, yOffset =%d, cbcrOffset =%d, totalSize = %d\n",
- __func__, i, buffer_offset.yOffset, buffer_offset.cbcrOffset, buffer_offset.totalSize);
- OMX_SetParameter(my_obj->omx_handle, buf_offset_idx, &buffer_offset);
-
- /* set acbcr (special case for video-sized live snapshot)*/
- if (is_video_frame) {
- CDBG("Using acbcroffset\n");
- memset(&buffer_offset, 0, sizeof(buffer_offset));
- buffer_offset.cbcrOffset = src_buf->src_image[i].offset.mp[0].offset +
- src_buf->src_image[i].offset.mp[0].len +
- src_buf->src_image[i].offset.mp[1].offset;;
- OMX_GetExtensionIndex(my_obj->omx_handle,"omx.qcom.jpeg.exttype.acbcr_offset",&buf_offset_idx);
- OMX_SetParameter(my_obj->omx_handle, buf_offset_idx, &buffer_offset);
- }
- break;
- case JPEG_SRC_IMAGE_FMT_BITSTREAM:
- /* TODO: need visit here when bit stream is supported */
- buffer_offset.yOffset =
- src_buf->bit_stream[i].data_offset;
- buffer_offset.totalSize =
- src_buf->bit_stream[i].buf_size;
- CDBG("%s: idx=%d, yOffset =%d, cbcrOffset =%d, totalSize = %d\n",
- __func__, i, buffer_offset.yOffset, buffer_offset.cbcrOffset, buffer_offset.totalSize);
- OMX_SetParameter(my_obj->omx_handle, buf_offset_idx, &buffer_offset);
- break;
- default:
- break;
- }
- }
-
- return rc;
-}
-
-/* TODO: needs revisit after omx lib supports multi src buffers */
-int32_t mm_jpeg_omx_config_port(mm_jpeg_obj* my_obj, src_image_buffer_info *src_buf, int port_idx)
-{
- int32_t rc = 0;
- uint8_t i;
- OMX_PARAM_PORTDEFINITIONTYPE input_port;
-
- for (i = 0; i < src_buf->num_bufs; i++) {
- memset(&input_port, 0, sizeof(input_port));
- input_port.nPortIndex = port_idx;
- OMX_GetParameter(my_obj->omx_handle, OMX_IndexParamPortDefinition, &input_port);
- input_port.format.image.nFrameWidth = src_buf->src_dim.width;
- input_port.format.image.nFrameHeight =src_buf->src_dim.height;
- input_port.format.image.nStride = src_buf->src_dim.width;
- input_port.format.image.nSliceHeight = src_buf->src_dim.height;
- switch (src_buf->img_fmt) {
- case JPEG_SRC_IMAGE_FMT_YUV:
- input_port.nBufferSize = src_buf->src_image[i].offset.frame_len;
- break;
- case JPEG_SRC_IMAGE_FMT_BITSTREAM:
- input_port.nBufferSize = src_buf->bit_stream[i].buf_size;
- break;
- }
-
- CDBG("%s: port_idx=%d, width =%d, height =%d, stride = %d, slice = %d, bufsize = %d\n",
- __func__, port_idx,
- input_port.format.image.nFrameWidth, input_port.format.image.nFrameHeight,
- input_port.format.image.nStride, input_port.format.image.nSliceHeight,
- input_port.nBufferSize);
- OMX_SetParameter(my_obj->omx_handle, OMX_IndexParamPortDefinition, &input_port);
- }
-
- return rc;
-}
-
-omx_jpeg_color_format map_jpeg_format(mm_jpeg_color_format color_fmt)
-{
- switch (color_fmt) {
- case MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2:
- return OMX_YCRCBLP_H2V2;
- case MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2:
- return OMX_YCBCRLP_H2V2;
- case MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1:
- return OMX_YCRCBLP_H2V1;
- case MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1:
- return OMX_YCBCRLP_H2V1;
- case MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2:
- return OMX_YCRCBLP_H1V2;
- case MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2:
- return OMX_YCBCRLP_H1V2;
- case MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1:
- return OMX_YCRCBLP_H1V1;
- case MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1:
- return OMX_YCBCRLP_H1V1;
- case MM_JPEG_COLOR_FORMAT_RGB565:
- return OMX_RGB565;
- case MM_JPEG_COLOR_FORMAT_RGB888:
- return OMX_RGB888;
- case MM_JPEG_COLOR_FORMAT_RGBa:
- return OMX_RGBa;
- case MM_JPEG_COLOR_FORMAT_BITSTREAM:
- /* TODO: need to change to new bitstream value once omx interface changes */
- return OMX_JPEG_BITSTREAM_H2V2;
- default:
- return OMX_JPEG_COLOR_FORMAT_MAX;
- }
-}
-
-int32_t mm_jpeg_omx_config_user_preference(mm_jpeg_obj* my_obj, mm_jpeg_encode_job* job)
-{
- int32_t rc = 0;
- OMX_INDEXTYPE user_pref_idx;
- omx_jpeg_user_preferences user_preferences;
-
- memset(&user_preferences, 0, sizeof(user_preferences));
- user_preferences.color_format =
- map_jpeg_format(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN].color_format);
- if (job->encode_parm.buf_info.src_imgs.src_img_num > 1) {
- user_preferences.thumbnail_color_format =
- map_jpeg_format(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB].color_format);
- }
- OMX_GetExtensionIndex(my_obj->omx_handle,
- "omx.qcom.jpeg.exttype.user_preferences",
- &user_pref_idx);
- CDBG("%s:User Preferences: color_format %d, thumbnail_color_format = %d",
- __func__, user_preferences.color_format, user_preferences.thumbnail_color_format);
-
- if (job->encode_parm.buf_info.src_imgs.is_video_frame != 0) {
- user_preferences.preference = OMX_JPEG_PREF_SOFTWARE_ONLY;
- } else {
- user_preferences.preference = OMX_JPEG_PREF_HW_ACCELERATED_PREFERRED;
- }
-
- OMX_SetParameter(my_obj->omx_handle, user_pref_idx, &user_preferences);
- return rc;
-}
-
-int32_t mm_jpeg_omx_config_thumbnail(mm_jpeg_obj* my_obj, mm_jpeg_encode_job* job)
-{
- int32_t rc = -1;
- OMX_INDEXTYPE thumb_idx, q_idx;
- omx_jpeg_thumbnail thumbnail;
- omx_jpeg_thumbnail_quality quality;
-
- if (job->encode_parm.buf_info.src_imgs.src_img_num < 2) {
- /*No thumbnail is required*/
- return 0;
- }
- src_image_buffer_info *src_buf =
- &(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB]);
-
- /* config port */
- CDBG("%s: config port", __func__);
- rc = mm_jpeg_omx_config_port(my_obj, src_buf, INPUT_PORT_THUMBNAIL);
- if (0 != rc) {
- CDBG_ERROR("%s: config port failed", __func__);
- return rc;
- }
-
- if ((src_buf->crop.width == 0) || (src_buf->crop.height == 0)) {
- src_buf->crop.width = src_buf->src_dim.width;
- src_buf->crop.height = src_buf->src_dim.height;
- }
-
- /* check crop boundary */
- if ((src_buf->crop.width + src_buf->crop.offset_x > src_buf->src_dim.width) ||
- (src_buf->crop.height + src_buf->crop.offset_y > src_buf->src_dim.height)) {
- CDBG_ERROR("%s: invalid crop boundary (%d, %d) offset (%d, %d) out of (%d, %d)",
- __func__,
- src_buf->crop.width,
- src_buf->crop.height,
- src_buf->crop.offset_x,
- src_buf->crop.offset_y,
- src_buf->src_dim.width,
- src_buf->src_dim.height);
- return -1;
- }
-
- memset(&thumbnail, 0, sizeof(thumbnail));
-
- /* thumbnail crop info */
- thumbnail.cropWidth = CEILING2(src_buf->crop.width);
- thumbnail.cropHeight = CEILING2(src_buf->crop.height);
- thumbnail.left = src_buf->crop.offset_x;
- thumbnail.top = src_buf->crop.offset_y;
-
- /* thumbnail output dimention */
- thumbnail.width = src_buf->out_dim.width;
- thumbnail.height = src_buf->out_dim.height;
-
- /* set scaling flag */
- if (thumbnail.left > 0 || thumbnail.top > 0 ||
- src_buf->crop.width != src_buf->src_dim.width ||
- src_buf->crop.height != src_buf->src_dim.height ||
- src_buf->src_dim.width != src_buf->out_dim.width ||
- src_buf->src_dim.height != src_buf->out_dim.height) {
- thumbnail.scaling = 1;
- }
-
- /* set omx thumbnail info */
- OMX_GetExtensionIndex(my_obj->omx_handle, "omx.qcom.jpeg.exttype.thumbnail", &thumb_idx);
- OMX_SetParameter(my_obj->omx_handle, thumb_idx, &thumbnail);
- CDBG("%s: set thumbnail info: crop_w=%d, crop_h=%d, l=%d, t=%d, w=%d, h=%d, scaling=%d",
- __func__, thumbnail.cropWidth, thumbnail.cropHeight,
- thumbnail.left, thumbnail.top, thumbnail.width, thumbnail.height,
- thumbnail.scaling);
-
- OMX_GetExtensionIndex(my_obj->omx_handle, "omx.qcom.jpeg.exttype.thumbnail_quality", &q_idx);
- OMX_GetParameter(my_obj->omx_handle, q_idx, &quality);
- quality.nQFactor = src_buf->quality;
- OMX_SetParameter(my_obj->omx_handle, q_idx, &quality);
- CDBG("%s: thumbnail_quality=%d", __func__, quality.nQFactor);
-
- rc = 0;
- return rc;
-}
-
-int32_t mm_jpeg_omx_config_main_crop(mm_jpeg_obj* my_obj, src_image_buffer_info *src_buf)
-{
- int32_t rc = 0;
- OMX_CONFIG_RECTTYPE rect_type_in, rect_type_out;
-
- if ((src_buf->crop.width == 0) || (src_buf->crop.height == 0)) {
- src_buf->crop.width = src_buf->src_dim.width;
- src_buf->crop.height = src_buf->src_dim.height;
- }
- /* error check first */
- if ((src_buf->crop.width + src_buf->crop.offset_x > src_buf->src_dim.width) ||
- (src_buf->crop.height + src_buf->crop.offset_y > src_buf->src_dim.height)) {
- CDBG_ERROR("%s: invalid crop boundary (%d, %d) out of (%d, %d)", __func__,
- src_buf->crop.width + src_buf->crop.offset_x,
- src_buf->crop.height + src_buf->crop.offset_y,
- src_buf->src_dim.width,
- src_buf->src_dim.height);
- return -1;
- }
-
- memset(&rect_type_in, 0, sizeof(rect_type_in));
- memset(&rect_type_out, 0, sizeof(rect_type_out));
- rect_type_in.nPortIndex = OUTPUT_PORT;
- rect_type_out.nPortIndex = OUTPUT_PORT;
-
- if ((src_buf->src_dim.width != src_buf->crop.width) ||
- (src_buf->src_dim.height != src_buf->crop.height) ||
- (src_buf->src_dim.width != src_buf->out_dim.width) ||
- (src_buf->src_dim.height != src_buf->out_dim.height)) {
- /* Scaler information */
- rect_type_in.nWidth = CEILING2(src_buf->crop.width);
- rect_type_in.nHeight = CEILING2(src_buf->crop.height);
- rect_type_in.nLeft = src_buf->crop.offset_x;
- rect_type_in.nTop = src_buf->crop.offset_y;
-
- if (src_buf->out_dim.width && src_buf->out_dim.height) {
- rect_type_out.nWidth = src_buf->out_dim.width;
- rect_type_out.nHeight = src_buf->out_dim.height;
- }
- }
-
- OMX_SetConfig(my_obj->omx_handle, OMX_IndexConfigCommonInputCrop, &rect_type_in);
- CDBG("%s: OMX_IndexConfigCommonInputCrop w=%d, h=%d, l=%d, t=%d, port_idx=%d", __func__,
- rect_type_in.nWidth, rect_type_in.nHeight,
- rect_type_in.nLeft, rect_type_in.nTop,
- rect_type_in.nPortIndex);
-
- OMX_SetConfig(my_obj->omx_handle, OMX_IndexConfigCommonOutputCrop, &rect_type_out);
- CDBG("%s: OMX_IndexConfigCommonOutputCrop w=%d, h=%d, port_idx=%d", __func__,
- rect_type_out.nWidth, rect_type_out.nHeight,
- rect_type_out.nPortIndex);
-
- return rc;
-}
-
-int32_t mm_jpeg_omx_config_main(mm_jpeg_obj* my_obj, mm_jpeg_encode_job* job)
-{
- int32_t rc = 0;
- src_image_buffer_info *src_buf =
- &(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN]);
- OMX_IMAGE_PARAM_QFACTORTYPE q_factor;
-
- /* config port */
- CDBG("%s: config port", __func__);
- rc = mm_jpeg_omx_config_port(my_obj, src_buf, INPUT_PORT_MAIN);
- if (0 != rc) {
- CDBG_ERROR("%s: config port failed", __func__);
- return rc;
- }
-
- /* config buffer offset */
- CDBG("%s: config main buf offset", __func__);
- rc = mm_jpeg_omx_config_main_buffer_offset(my_obj, src_buf, job->encode_parm.buf_info.src_imgs.is_video_frame);
- if (0 != rc) {
- CDBG_ERROR("%s: config buffer offset failed", __func__);
- return rc;
- }
-
- /* config crop */
- CDBG("%s: config main crop", __func__);
- rc = mm_jpeg_omx_config_main_crop(my_obj, src_buf);
- if (0 != rc) {
- CDBG_ERROR("%s: config crop failed", __func__);
- return rc;
- }
-
- /* set quality */
- memset(&q_factor, 0, sizeof(q_factor));
- q_factor.nPortIndex = INPUT_PORT_MAIN;
- OMX_GetParameter(my_obj->omx_handle, OMX_IndexParamQFactor, &q_factor);
- q_factor.nQFactor = src_buf->quality;
- OMX_SetParameter(my_obj->omx_handle, OMX_IndexParamQFactor, &q_factor);
- CDBG("%s: config QFactor: %d", __func__, q_factor.nQFactor);
-
- return rc;
-}
-
-int32_t mm_jpeg_omx_config_common(mm_jpeg_obj* my_obj, mm_jpeg_encode_job* job)
-{
- int32_t rc;
- int i;
- OMX_INDEXTYPE exif_idx;
- omx_jpeg_exif_info_tag tag;
- OMX_CONFIG_ROTATIONTYPE rotate;
-
- /* config user prefernces */
- CDBG("%s: config user preferences", __func__);
- rc = mm_jpeg_omx_config_user_preference(my_obj, job);
- if (0 != rc) {
- CDBG_ERROR("%s: config user preferences failed", __func__);
- return rc;
- }
-
- /* set rotation */
- memset(&rotate, 0, sizeof(rotate));
- rotate.nPortIndex = OUTPUT_PORT;
- rotate.nRotation = job->encode_parm.rotation;
- OMX_SetConfig(my_obj->omx_handle, OMX_IndexConfigCommonRotate, &rotate);
- CDBG("%s: Set rotation to %d at port_idx=%d", __func__,
- job->encode_parm.rotation, rotate.nPortIndex);
-
- /* set exif tags */
- CDBG("%s: Set rexif tags", __func__);
- OMX_GetExtensionIndex(my_obj->omx_handle, "omx.qcom.jpeg.exttype.exif", &exif_idx);
- for(i = 0; i < job->encode_parm.exif_numEntries; i++) {
- memcpy(&tag, job->encode_parm.exif_data + i, sizeof(omx_jpeg_exif_info_tag));
- OMX_SetParameter(my_obj->omx_handle, exif_idx, &tag);
- }
-
- /* set mobicat info */
- CDBG("%s: set Mobicat info", __func__);
- if(job->encode_parm.hasmobicat) {
- mobicat_d.mobicatData = job->encode_parm.mobicat_data;
- mobicat_d.mobicatDataLength = job->encode_parm.mobicat_data_length;
- OMX_GetExtensionIndex(my_obj->omx_handle, "omx.qcom.jpeg.exttype.mobicat", &mobicat_data);
- OMX_SetParameter(my_obj->omx_handle, mobicat_data, &mobicat_d);
- }
-
- return rc;
-}
-
-int32_t mm_jpeg_omx_use_buf(mm_jpeg_obj* my_obj,
- src_image_buffer_info *src_buf,
- mm_jpeg_omx_src_buf* omx_src_buf,
- int port_idx)
-{
- int32_t rc = 0;
- uint8_t i;
- omx_jpeg_pmem_info pmem_info;
-
- omx_src_buf->num_bufs = src_buf->num_bufs;
- for (i = 0; i < src_buf->num_bufs; i++) {
- memset(&pmem_info, 0, sizeof(pmem_info));
- switch (src_buf->img_fmt) {
- case JPEG_SRC_IMAGE_FMT_YUV:
- pmem_info.fd = src_buf->src_image[i].fd;
- pmem_info.offset = 0;
- omx_src_buf->bufs[i].portIdx = port_idx;
- OMX_UseBuffer(my_obj->omx_handle,
- &omx_src_buf->bufs[i].buf_header,
- port_idx,
- &pmem_info,
- src_buf->src_image[i].offset.frame_len,
- (void *)src_buf->src_image[i].buf_vaddr);
- CDBG("%s: port_idx=%d, fd=%d, offset=%d, len=%d, ptr=%p",
- __func__, port_idx, pmem_info.fd, pmem_info.offset,
- src_buf->src_image[i].offset.frame_len,
- src_buf->src_image[i].buf_vaddr);
- break;
- case JPEG_SRC_IMAGE_FMT_BITSTREAM:
- pmem_info.fd = src_buf->bit_stream[i].fd;
- pmem_info.offset = 0;
- omx_src_buf->bufs[i].portIdx = port_idx;
- OMX_UseBuffer(my_obj->omx_handle,
- &omx_src_buf->bufs[i].buf_header,
- port_idx,
- &pmem_info,
- src_buf->bit_stream[i].buf_size,
- (void *)src_buf->bit_stream[i].buf_vaddr);
- break;
- default:
- rc = -1;
- break;
- }
- }
-
- return rc;
-}
-
-int32_t mm_jpeg_omx_encode(mm_jpeg_obj* my_obj, mm_jpeg_job_entry* job_entry)
-{
- int32_t rc = 0;
- uint8_t i;
- mm_jpeg_encode_job* job = &job_entry->job.encode_job;
- uint8_t has_thumbnail = job->encode_parm.buf_info.src_imgs.src_img_num > 1? 1 : 0;
- src_image_buffer_info *src_buf[JPEG_SRC_IMAGE_TYPE_MAX];
- mm_jpeg_omx_src_buf *omx_src_buf[JPEG_SRC_IMAGE_TYPE_MAX];
-
- /* config main img */
- rc = mm_jpeg_omx_config_main(my_obj, job);
- if (0 != rc) {
- CDBG_ERROR("%s: config main img failed", __func__);
- return rc;
- }
-
- /* config thumbnail */
- if (has_thumbnail) {
- rc = mm_jpeg_omx_config_thumbnail(my_obj, job);
- if (0 != rc) {
- CDBG_ERROR("%s: config thumbnail img failed", __func__);
- return rc;
- }
- }
-
- /* common config */
- rc = mm_jpeg_omx_config_common(my_obj, job);
- if (0 != rc) {
- CDBG_ERROR("%s: config common failed", __func__);
- return rc;
- }
-
- /* config input omx buffer for main input */
- src_buf[JPEG_SRC_IMAGE_TYPE_MAIN] = &(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_MAIN]);
- omx_src_buf[JPEG_SRC_IMAGE_TYPE_MAIN] = &job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_MAIN];
- rc = mm_jpeg_omx_use_buf(my_obj,
- src_buf[JPEG_SRC_IMAGE_TYPE_MAIN],
- omx_src_buf[JPEG_SRC_IMAGE_TYPE_MAIN],
- INPUT_PORT_MAIN);
- if (0 != rc) {
- CDBG_ERROR("%s: config main input omx buffer failed", __func__);
- return rc;
- }
-
- /* config input omx buffer for thumbnail input if there is thumbnail */
- if (has_thumbnail) {
- src_buf[JPEG_SRC_IMAGE_TYPE_THUMB] = &(job->encode_parm.buf_info.src_imgs.src_img[JPEG_SRC_IMAGE_TYPE_THUMB]);
- omx_src_buf[JPEG_SRC_IMAGE_TYPE_THUMB] = &job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_THUMB];
- rc = mm_jpeg_omx_use_buf(my_obj,
- src_buf[JPEG_SRC_IMAGE_TYPE_THUMB],
- omx_src_buf[JPEG_SRC_IMAGE_TYPE_THUMB],
- INPUT_PORT_THUMBNAIL);
- if (0 != rc) {
- CDBG_ERROR("%s: config thumbnail input omx buffer failed", __func__);
- return rc;
- }
- }
-
- /* config output omx buffer */
- job_entry->sink_buf.portIdx = OUTPUT_PORT;
- OMX_UseBuffer(my_obj->omx_handle,
- &job_entry->sink_buf.buf_header,
- job_entry->sink_buf.portIdx,
- NULL,
- job->encode_parm.buf_info.sink_img.buf_len,
- (void *)job->encode_parm.buf_info.sink_img.buf_vaddr);
- CDBG("%s: Use output buf: port_idx=%d, len=%d, ptr=%p",
- __func__, job_entry->sink_buf.portIdx,
- job->encode_parm.buf_info.sink_img.buf_len,
- job->encode_parm.buf_info.sink_img.buf_vaddr);
-
- /* wait for OMX state ready */
- CDBG("%s: Wait for state change to idle \n", __func__);
- mm_jpeg_job_wait_for_cmd_complete(my_obj, OMX_CommandStateSet, OMX_StateIdle);
- CDBG("%s: State changed to OMX_StateIdle\n", __func__);
-
- /* start OMX encoding by sending executing cmd */
- CDBG("%s: Send command to executing\n", __func__);
- OMX_SendCommand(my_obj->omx_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
- mm_jpeg_job_wait_for_cmd_complete(my_obj, OMX_CommandStateSet, OMX_StateExecuting);
-
- /* start input feeding and output writing */
- CDBG("%s: start main input feeding\n", __func__);
- for (i = 0; i < job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_MAIN].num_bufs; i++) {
- OMX_EmptyThisBuffer(my_obj->omx_handle,
- job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_MAIN].bufs[i].buf_header);
- }
- if (has_thumbnail) {
- CDBG("%s: start thumbnail input feeding\n", __func__);
- for (i = 0; i < job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_THUMB].num_bufs; i++) {
- OMX_EmptyThisBuffer(my_obj->omx_handle,
- job_entry->src_bufs[JPEG_SRC_IMAGE_TYPE_THUMB].bufs[i].buf_header);
- }
- }
- CDBG("%s: start output writing\n", __func__);
- OMX_FillThisBuffer(my_obj->omx_handle, job_entry->sink_buf.buf_header);
- return rc;
-}
-
-static void *mm_jpeg_notify_thread(void *data)
-{
- mm_jpeg_job_q_node_t* job_node = (mm_jpeg_job_q_node_t *)data;
- mm_jpeg_job_entry * job_entry = &job_node->entry;
- mm_jpeg_obj* my_obj = (mm_jpeg_obj *)job_entry->jpeg_obj;
- void* node = NULL;
- int32_t rc = 0;
- uint32_t jobId = job_entry->jobId;
-
- if (NULL == my_obj) {
- CDBG_ERROR("%s: jpeg obj is NULL", __func__);
- return NULL;
- }
-
- /* call cb */
- if (NULL != job_entry->job.encode_job.jpeg_cb) {
- /* Add to cb queue */
- rc = mm_jpeg_queue_enq(&my_obj->cb_q, data);
- if (0 != rc) {
- CDBG_ERROR("%s: enqueue into cb_q failed", __func__);
- free(job_node);
- return NULL;
- }
-
- CDBG("%s: send jpeg callback", __func__);
- /* has callback, send CB */
- job_entry->job.encode_job.jpeg_cb(job_entry->job_status,
- job_entry->thumbnail_dropped,
- job_entry->client_hdl,
- job_entry->jobId,
- job_entry->job.encode_job.encode_parm.buf_info.sink_img.buf_vaddr,
- job_entry->jpeg_size,
- job_entry->job.encode_job.userdata);
-
- /* Remove from cb queue */
- CDBG_ERROR("%s: remove job %d from cb queue", __func__, jobId);
- node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->cb_q, jobId);
- if (NULL != node) {
- free(node);
- }
- } else {
- CDBG_ERROR("%s: no cb provided, no action", __func__);
- /* note here we are not freeing any internal memory */
- free(data);
- }
-
- return NULL;
-}
-
-/* process encoding job */
-int32_t mm_jpeg_process_encoding_job(mm_jpeg_obj *my_obj, mm_jpeg_job_q_node_t* job_node)
-{
- int32_t rc = 0;
- mm_jpeg_job_entry* job_entry = &job_node->entry;
-
- /* call OMX_Encode */
- rc = mm_jpeg_omx_encode(my_obj, job_entry);
- if (0 == rc) {
- /* sent encode cmd to OMX, queue job into ongoing queue */
- rc = mm_jpeg_queue_enq(&my_obj->ongoing_job_q, job_node);
- } else {
- /* OMX encode failed, notify error through callback */
- job_entry->job_status = JPEG_JOB_STATUS_ERROR;
- if (NULL != job_entry->job.encode_job.jpeg_cb) {
- /* has callback, create a thread to send CB */
- pthread_create(&job_entry->cb_pid,
- NULL,
- mm_jpeg_notify_thread,
- (void *)job_node);
-
- } else {
- CDBG_ERROR("%s: no cb provided, return here", __func__);
- free(job_node);
- }
- }
-
- return rc;
-}
-/* process job (encoding/decoding) */
-int32_t mm_jpeg_process_job(mm_jpeg_obj *my_obj, mm_jpeg_job_q_node_t* job_node)
-{
- int32_t rc = 0;
-
- switch (job_node->entry.job.job_type) {
- case JPEG_JOB_TYPE_ENCODE:
- rc = mm_jpeg_process_encoding_job(my_obj, job_node);
- break;
- default:
- CDBG_ERROR("%s: job type not supported (%d)",
- __func__, job_node->entry.job.job_type);
- free(job_node);
- rc = -1;
- break;
- }
-
- return rc;
-}
-
-static void *mm_jpeg_jobmgr_thread(void *data)
-{
- int rc = 0;
- int running = 1;
- uint32_t num_ongoing_jobs = 0;
- mm_jpeg_obj *my_obj = (mm_jpeg_obj*)data;
- mm_jpeg_job_cmd_thread_t *cmd_thread = &my_obj->job_mgr;
- mm_jpeg_job_q_node_t* node = NULL;
-
- do {
- do {
- rc = sem_wait(&cmd_thread->job_sem);
- if (rc != 0 && errno != EINVAL) {
- CDBG_ERROR("%s: sem_wait error (%s)",
- __func__, strerror(errno));
- return NULL;
- }
- } while (rc != 0);
-
- /* check ongoing q size */
- num_ongoing_jobs = mm_jpeg_queue_get_size(&my_obj->ongoing_job_q);
- if (num_ongoing_jobs >= NUM_MAX_JPEG_CNCURRENT_JOBS) {
- CDBG("%s: ongoing job already reach max %d", __func__, num_ongoing_jobs);
- continue;
- }
-
- pthread_mutex_lock(&my_obj->job_lock);
- /* can go ahead with new work */
- node = (mm_jpeg_job_q_node_t*)mm_jpeg_queue_deq(&cmd_thread->job_queue);
- if (node != NULL) {
- switch (node->type) {
- case MM_JPEG_CMD_TYPE_JOB:
- mm_jpeg_process_job(my_obj, node);
- break;
- case MM_JPEG_CMD_TYPE_EXIT:
- default:
- /* free node */
- free(node);
- /* set running flag to false */
- running = 0;
- break;
- }
- }
- pthread_mutex_unlock(&my_obj->job_lock);
-
- } while (running);
- return NULL;
-}
-
-int32_t mm_jpeg_jobmgr_thread_launch(mm_jpeg_obj * my_obj)
-{
- int32_t rc = 0;
- mm_jpeg_job_cmd_thread_t * job_mgr = &my_obj->job_mgr;
-
- sem_init(&job_mgr->job_sem, 0, 0);
- mm_jpeg_queue_init(&job_mgr->job_queue);
-
- /* launch the thread */
- pthread_create(&job_mgr->pid,
- NULL,
- mm_jpeg_jobmgr_thread,
- (void *)my_obj);
- return rc;
-}
-
-int32_t mm_jpeg_jobmgr_thread_release(mm_jpeg_obj * my_obj)
-{
- int32_t rc = 0;
- mm_jpeg_job_cmd_thread_t * cmd_thread = &my_obj->job_mgr;
- mm_jpeg_job_q_node_t* node =
- (mm_jpeg_job_q_node_t *)malloc(sizeof(mm_jpeg_job_q_node_t));
- if (NULL == node) {
- CDBG_ERROR("%s: No memory for mm_jpeg_job_q_node_t", __func__);
- return -1;
- }
-
- memset(node, 0, sizeof(mm_jpeg_job_q_node_t));
- node->type = MM_JPEG_CMD_TYPE_EXIT;
-
- mm_jpeg_queue_enq(&cmd_thread->job_queue, node);
- sem_post(&cmd_thread->job_sem);
-
- /* wait until cmd thread exits */
- if (pthread_join(cmd_thread->pid, NULL) != 0) {
- CDBG("%s: pthread dead already\n", __func__);
- }
- mm_jpeg_queue_deinit(&cmd_thread->job_queue);
-
- sem_destroy(&cmd_thread->job_sem);
- memset(cmd_thread, 0, sizeof(mm_jpeg_job_cmd_thread_t));
- return rc;
-}
-
-int32_t mm_jpeg_init(mm_jpeg_obj *my_obj)
-{
- int32_t rc = 0;
-
- /* init locks */
- pthread_mutex_init(&my_obj->job_lock, NULL);
- pthread_mutex_init(&my_obj->omx_evt_lock, NULL);
- pthread_cond_init(&my_obj->omx_evt_cond, NULL);
-
- /* init ongoing job queue */
- rc = mm_jpeg_queue_init(&my_obj->ongoing_job_q);
- rc = mm_jpeg_queue_init(&my_obj->cb_q);
-
- /* init job semaphore and launch jobmgr thread */
- CDBG("%s : Launch jobmgr thread",__func__);
- rc = mm_jpeg_jobmgr_thread_launch(my_obj);
-
- /* load OMX */
- rc = mm_jpeg_omx_load(my_obj);
- if (0 != rc) {
- /* roll back in error case */
- mm_jpeg_jobmgr_thread_release(my_obj);
- mm_jpeg_queue_deinit(&my_obj->ongoing_job_q);
- pthread_mutex_destroy(&my_obj->job_lock);
- pthread_mutex_destroy(&my_obj->omx_evt_lock);
- pthread_cond_destroy(&my_obj->omx_evt_cond);
- }
-
- return rc;
-}
-
-int32_t mm_jpeg_deinit(mm_jpeg_obj *my_obj)
-{
- int32_t rc = 0;
-
- /* unload OMX engine */
- rc = mm_jpeg_omx_unload(my_obj);
-
- /* release jobmgr thread */
- rc = mm_jpeg_jobmgr_thread_release(my_obj);
-
- /* deinit ongoing job and cb queue */
- rc = mm_jpeg_queue_deinit(&my_obj->ongoing_job_q);
- rc = mm_jpeg_queue_deinit(&my_obj->cb_q);
-
- /* destroy locks */
- pthread_mutex_destroy(&my_obj->job_lock);
- pthread_mutex_destroy(&my_obj->omx_evt_lock);
- pthread_cond_destroy(&my_obj->omx_evt_cond);
-
- return rc;
-}
-
-uint32_t mm_jpeg_new_client(mm_jpeg_obj *my_obj)
-{
- uint32_t client_hdl = 0;
- uint8_t idx;
-
- if (my_obj->num_clients >= MAX_JPEG_CLIENT_NUM) {
- CDBG_ERROR("%s: num of clients reached limit", __func__);
- return client_hdl;
- }
-
- for (idx = 0; idx < MAX_JPEG_CLIENT_NUM; idx++) {
- if (0 == my_obj->clnt_mgr[idx].is_used) {
- break;
- }
- }
-
- if (idx < MAX_JPEG_CLIENT_NUM) {
- /* client entry avail */
- /* generate client handler by index */
- client_hdl = mm_jpeg_util_generate_handler(idx);
-
- /* update client entry */
- my_obj->clnt_mgr[idx].is_used = 1;
- my_obj->clnt_mgr[idx].client_handle = client_hdl;
-
- /* increse client count */
- my_obj->num_clients++;
- }
-
- return client_hdl;
-}
-
-int32_t mm_jpeg_start_job(mm_jpeg_obj *my_obj,
- uint32_t client_hdl,
- mm_jpeg_job* job,
- uint32_t* jobId)
-{
- int32_t rc = -1;
- uint8_t clnt_idx = 0;
- uint32_t job_id = 0;
- mm_jpeg_job_q_node_t* node = NULL;
-
- *jobId = 0;
-
- /* check if valid client */
- clnt_idx = mm_jpeg_util_get_index_by_handler(client_hdl);
- if (clnt_idx >= MAX_JPEG_CLIENT_NUM ) {
- CDBG_ERROR("%s: invalid client with handler (%d)", __func__, client_hdl);
- return rc;
- }
-
- /* generate client handler by index */
- job_id = mm_jpeg_util_generate_handler(clnt_idx);
-
- /* enqueue new job into todo job queue */
- node = (mm_jpeg_job_q_node_t *)malloc(sizeof(mm_jpeg_job_q_node_t));
- if (NULL == node) {
- CDBG_ERROR("%s: No memory for mm_jpeg_job_q_node_t", __func__);
- return -rc;
- }
-
- memset(node, 0, sizeof(mm_jpeg_job_q_node_t));
- node->type = MM_JPEG_CMD_TYPE_JOB;
- node->entry.client_hdl = client_hdl;
- node->entry.jobId = job_id;
- memcpy(&node->entry.job, job, sizeof(mm_jpeg_job));
- node->entry.jpeg_obj = (void*)my_obj; /* save a ptr to jpeg_obj */
-
- rc = mm_jpeg_queue_enq(&my_obj->job_mgr.job_queue, node);
- if (0 == rc) {
- sem_post(&my_obj->job_mgr.job_sem);
- *jobId = job_id;
- }
-
- return rc;
-}
-
-int32_t mm_jpeg_abort_job(mm_jpeg_obj *my_obj,
- uint32_t client_hdl,
- uint32_t jobId)
-{
- int32_t rc = -1;
- uint8_t clnt_idx = 0;
- void * node = NULL;
- mm_jpeg_job_entry* job_entry = NULL;
-
- /* check if valid client */
- clnt_idx = mm_jpeg_util_get_index_by_handler(client_hdl);
- if (clnt_idx >= MAX_JPEG_CLIENT_NUM ) {
- CDBG_ERROR("%s: invalid client with handler (%d)", __func__, client_hdl);
- return rc;
- }
-
- pthread_mutex_lock(&my_obj->job_lock);
-
- /* abort job if in ongoing queue */
- node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->ongoing_job_q, jobId);
- if (NULL != node) {
- /* find job that is OMX ongoing, ask OMX to abort the job */
- job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
- rc = mm_jpeg_omx_abort_job(my_obj, job_entry);
- free(node);
- goto abort_done;
- }
-
- /* abort job if in todo queue */
- node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->job_mgr.job_queue, jobId);
- if (NULL != node) {
- /* simply delete it */
- free(node);
- goto abort_done;
- }
- /* abort job if in cb queue */
- node = mm_jpeg_queue_remove_job_by_job_id(&my_obj->cb_q, jobId);
- if (NULL != node) {
- /* join cb thread */
- job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
- if (pthread_join(job_entry->cb_pid, NULL) != 0) {
- CDBG("%s: pthread dead already\n", __func__);
- }
- free(node);
- }
-abort_done:
- pthread_mutex_unlock(&my_obj->job_lock);
-
- /* wake up jobMgr thread to work on new job if there is any */
- sem_post(&my_obj->job_mgr.job_sem);
-
- return rc;
-}
-
-int32_t mm_jpeg_close(mm_jpeg_obj *my_obj, uint32_t client_hdl)
-{
- int32_t rc = -1;
- uint8_t clnt_idx = 0;
- void* node = NULL;
- mm_jpeg_job_entry* job_entry = NULL;
-
- /* check if valid client */
- clnt_idx = mm_jpeg_util_get_index_by_handler(client_hdl);
- if (clnt_idx >= MAX_JPEG_CLIENT_NUM ) {
- CDBG_ERROR("%s: invalid client with handler (%d)", __func__, client_hdl);
- return rc;
- }
-
- CDBG("%s: E", __func__);
-
- /* abort all jobs from the client */
- pthread_mutex_lock(&my_obj->job_lock);
-
- /* abort job if in ongoing queue */
- CDBG("%s: abort ongoing jobs", __func__);
- node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->ongoing_job_q, client_hdl);
- while (NULL != node) {
- /* find job that is OMX ongoing, ask OMX to abort the job */
- job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
- rc = mm_jpeg_omx_abort_job(my_obj, job_entry);
- free(node);
-
- /* find next job from ongoing queue that belongs to this client */
- node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->ongoing_job_q, client_hdl);
- }
-
- /* abort job if in todo queue */
- CDBG("%s: abort todo jobs", __func__);
- node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->job_mgr.job_queue, client_hdl);
- while (NULL != node) {
- /* simply delete the job if in todo queue */
- free(node);
-
- /* find next job from todo queue that belongs to this client */
- node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->job_mgr.job_queue, client_hdl);
- }
-
- /* abort job if in cb queue */
- CDBG("%s: abort done jobs in cb threads", __func__);
- node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->cb_q, client_hdl);
- while (NULL != node) {
- /* join cb thread */
- job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
- if (pthread_join(job_entry->cb_pid, NULL) != 0) {
- CDBG("%s: pthread dead already\n", __func__);
- }
- free(node);
-
- /* find next job from cb queue that belongs to this client */
- node = mm_jpeg_queue_remove_job_by_client_id(&my_obj->cb_q, client_hdl);
- }
-
- pthread_mutex_unlock(&my_obj->job_lock);
-
- /* invalidate client entry */
- memset(&my_obj->clnt_mgr[clnt_idx], 0, sizeof(mm_jpeg_client_t));
-
- rc = 0;
- CDBG("%s: X", __func__);
- return rc;
-}
-
-void mm_jpeg_job_wait_for_event(mm_jpeg_obj *my_obj, uint32_t evt_mask)
-{
- pthread_mutex_lock(&my_obj->omx_evt_lock);
- while (!(my_obj->omx_evt_rcvd.evt & evt_mask)) {
- pthread_cond_wait(&my_obj->omx_evt_cond, &my_obj->omx_evt_lock);
- }
- CDBG("%s:done", __func__);
- pthread_mutex_unlock(&my_obj->omx_evt_lock);
-}
-
-void mm_jpeg_job_wait_for_cmd_complete(mm_jpeg_obj *my_obj,
- int cmd,
- int status)
-{
- pthread_mutex_lock(&my_obj->omx_evt_lock);
- while (!((my_obj->omx_evt_rcvd.evt & MM_JPEG_EVENT_MASK_CMD_COMPLETE) &&
- (my_obj->omx_evt_rcvd.omx_value1 == cmd) &&
- (my_obj->omx_evt_rcvd.omx_value2 == status))) {
- pthread_cond_wait(&my_obj->omx_evt_cond, &my_obj->omx_evt_lock);
- }
- CDBG("%s:done", __func__);
- pthread_mutex_unlock(&my_obj->omx_evt_lock);
-}
-
-OMX_ERRORTYPE mm_jpeg_etbdone(OMX_HANDLETYPE hComponent,
- OMX_PTR pAppData,
- OMX_BUFFERHEADERTYPE* pBuffer)
-{
- /* no process needed for etbdone, return here */
- return 0;
-}
-
-OMX_ERRORTYPE mm_jpeg_ftbdone(OMX_HANDLETYPE hComponent,
- OMX_PTR pAppData,
- OMX_BUFFERHEADERTYPE* pBuffer)
-{
- int rc = 0;
- void* node = NULL;
- mm_jpeg_job_entry* job_entry = NULL;
- mm_jpeg_obj * my_obj = (mm_jpeg_obj*)pAppData;
-
- if (NULL == my_obj) {
- CDBG_ERROR("%s: pAppData is NULL, return here", __func__);
- return rc;
- }
-
- CDBG("%s: jpeg done", __func__);
-
- /* signal JPEG_DONE event */
- pthread_mutex_lock(&my_obj->omx_evt_lock);
- my_obj->omx_evt_rcvd.evt = MM_JPEG_EVENT_MASK_JPEG_DONE;
- pthread_cond_signal(&my_obj->omx_evt_cond);
- pthread_mutex_unlock(&my_obj->omx_evt_lock);
-
- /* find job that is OMX ongoing */
- /* If OMX can support multi encoding, it should provide a way to pass jobID.
- * then we can find job by jobID from ongoing queue.
- * For now, since OMX only support one job per time, we simply dequeue it. */
- pthread_mutex_lock(&my_obj->job_lock);
- node = mm_jpeg_queue_deq(&my_obj->ongoing_job_q);
- if (NULL != node) {
- job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);
-
- /* update status in job entry */
- job_entry->jpeg_size = pBuffer->nFilledLen;
- job_entry->job_status = JPEG_JOB_STATUS_DONE;
- CDBG("%s:filled len = %u, status = %d",
- __func__, job_entry->jpeg_size, job_entry->job_status);
-
- /* clean omx job */
- mm_jpeg_clean_omx_job(my_obj, job_entry);
-
- if (NULL != job_entry->job.encode_job.jpeg_cb) {
- /* has callback, create a thread to send CB */
- pthread_create(&job_entry->cb_pid,
- NULL,
- mm_jpeg_notify_thread,
- node);
-
- } else {
- CDBG_ERROR("%s: no cb provided, return here", __func__);
- free(node);
- }
- }
- pthread_mutex_unlock(&my_obj->job_lock);
-
- /* Wake up jobMgr thread to work on next job if there is any */
- sem_post(&my_obj->job_mgr.job_sem);
-
- return rc;
-}
-
-OMX_ERRORTYPE mm_jpeg_handle_omx_event(OMX_HANDLETYPE hComponent,
- OMX_PTR pAppData,
- OMX_EVENTTYPE eEvent,
- OMX_U32 nData1,
- OMX_U32 nData2,
- OMX_PTR pEventData)
-{
- int rc = 0;
- void* node = NULL;
- mm_jpeg_job_entry* job_entry = NULL;
- mm_jpeg_obj * my_obj = (mm_jpeg_obj*)pAppData;
- uint32_t jobId = 0;
-
- if (NULL == my_obj) {
- CDBG_ERROR("%s: pAppData is NULL, return here", __func__);
- return rc;
- }
-
- /* signal event */
- switch (eEvent) {
- case OMX_EVENT_JPEG_ABORT:
- {
- CDBG("%s: eEvent=OMX_EVENT_JPEG_ABORT", __func__);
- /* signal error evt */
- pthread_mutex_lock(&my_obj->omx_evt_lock);
- my_obj->omx_evt_rcvd.evt = MM_JPEG_EVENT_MASK_JPEG_ABORT;
- pthread_cond_signal(&my_obj->omx_evt_cond);
- pthread_mutex_unlock(&my_obj->omx_evt_lock);
- }
- break;
- case OMX_EventError:
- {
- CDBG("%s: eEvent=OMX_EventError", __func__);
- switch (nData1) {
- case OMX_EVENT_THUMBNAIL_DROPPED:
- {
- uint8_t thumbnail_dropped_flag = 1;
- mm_jpeg_job_q_node_t* data = (mm_jpeg_job_q_node_t*)mm_jpeg_queue_peek(&my_obj->ongoing_job_q);
- jobId = data->entry.jobId;
- mm_jpeg_queue_update_flag(&my_obj->ongoing_job_q,
- jobId,
- thumbnail_dropped_flag);
- }
- break;
- case OMX_EVENT_JPEG_ERROR:
- {
- /* signal error evt */
- pthread_mutex_lock(&my_obj->omx_evt_lock);
- my_obj->omx_evt_rcvd.evt = MM_JPEG_EVENT_MASK_JPEG_ERROR;
- pthread_cond_signal(&my_obj->omx_evt_cond);
- pthread_mutex_unlock(&my_obj->omx_evt_lock);
-
- /* send CB for error case */
- /* If OMX can support multi encoding, it should provide a way to pass jobID.
- * then we can find job by jobID from ongoing queue.
- * For now, since OMX only support one job per time, we simply dequeue it. */
- pthread_mutex_lock(&my_obj->job_lock);
- node = mm_jpeg_queue_deq(&my_obj->ongoing_job_q);
- if (NULL != node) {
- job_entry = &(((mm_jpeg_job_q_node_t *)node)->entry);;
-
- /* clean omx job */
- mm_jpeg_clean_omx_job(my_obj, job_entry);
-
- /* find job that is OMX ongoing */
- job_entry->job_status = JPEG_JOB_STATUS_ERROR;
- if (NULL != job_entry->job.encode_job.jpeg_cb) {
- /* has callback, create a thread to send CB */
- pthread_create(&job_entry->cb_pid,
- NULL,
- mm_jpeg_notify_thread,
- node);
-
- } else {
- CDBG_ERROR("%s: no cb provided, return here", __func__);
- free(node);
- }
- }
- pthread_mutex_unlock(&my_obj->job_lock);
-
- /* Wake up jobMgr thread to work on next job if there is any */
- sem_post(&my_obj->job_mgr.job_sem);
- }
- break;
- default:
- break;
- }
- }
- break;
- case OMX_EventCmdComplete:
- {
- CDBG("%s: eEvent=OMX_EventCmdComplete, value1=%d, value2=%d",
- __func__, nData1, nData2);
- /* signal cmd complete evt */
- pthread_mutex_lock(&my_obj->omx_evt_lock);
- my_obj->omx_evt_rcvd.evt = MM_JPEG_EVENT_MASK_CMD_COMPLETE;
- my_obj->omx_evt_rcvd.omx_value1 = nData1;
- my_obj->omx_evt_rcvd.omx_value2 = nData2;
- pthread_cond_signal(&my_obj->omx_evt_cond);
- pthread_mutex_unlock(&my_obj->omx_evt_lock);
- }
- break;
- default:
- break;
- }
- return rc;
-}
-
-/* remove the first job from the queue with matching client handle */
-mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_client_id(mm_jpeg_queue_t* queue, uint32_t client_hdl)
-{
- mm_jpeg_q_node_t* node = NULL;
- mm_jpeg_job_q_node_t* data = NULL;
- mm_jpeg_job_q_node_t* job_node = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
- while(pos != head) {
- node = member_of(pos, mm_jpeg_q_node_t, list);
- data = (mm_jpeg_job_q_node_t *)node->data;
-
- if (data && (data->entry.client_hdl == client_hdl)) {
- CDBG_ERROR("%s: found matching client node", __func__);
- job_node = data;
- cam_list_del_node(&node->list);
- queue->size--;
- free(node);
- CDBG_ERROR("%s: queue size = %d", __func__, queue->size);
- break;
- }
- pos = pos->next;
- }
-
- pthread_mutex_unlock(&queue->lock);
-
- return job_node;
-}
-
-/* remove job from the queue with matching job id */
-mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_job_id(mm_jpeg_queue_t* queue, uint32_t job_id)
-{
- mm_jpeg_q_node_t* node = NULL;
- mm_jpeg_job_q_node_t* data = NULL;
- mm_jpeg_job_q_node_t* job_node = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
- while(pos != head) {
- node = member_of(pos, mm_jpeg_q_node_t, list);
- data = (mm_jpeg_job_q_node_t *)node->data;
-
- if (data && (data->entry.jobId == job_id)) {
- job_node = data;
- cam_list_del_node(&node->list);
- queue->size--;
- free(node);
- break;
- }
- pos = pos->next;
- }
-
- pthread_mutex_unlock(&queue->lock);
-
- return job_node;
-}
-
-/* update thumbnail dropped flag in job queue */
-int32_t mm_jpeg_queue_update_flag(mm_jpeg_queue_t* queue, uint32_t job_id, uint8_t flag)
-{
- int32_t rc = 0;
- mm_jpeg_q_node_t* node = NULL;
- mm_jpeg_job_q_node_t* data = NULL;
- mm_jpeg_job_q_node_t* job_node = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
- while(pos != head) {
- node = member_of(pos, mm_jpeg_q_node_t, list);
- data = (mm_jpeg_job_q_node_t *)node->data;
- if (data && (data->entry.jobId == job_id)) {
- job_node = data;
- break;
- }
- pos = pos->next;
- }
-
- if (job_node) {
- /* find matching job for its job id */
- job_node->entry.thumbnail_dropped = flag;
- } else {
- CDBG_ERROR("%s: No entry for jobId = %d", __func__, job_id);
- rc = -1;
- }
- pthread_mutex_unlock(&queue->lock);
- return rc;
-}
diff --git a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_interface.c b/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_interface.c
deleted file mode 100755
index 46f6fba..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_interface.c
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <semaphore.h>
-
-#include "mm_jpeg_dbg.h"
-#include "mm_jpeg_interface.h"
-#include "mm_jpeg.h"
-
-static pthread_mutex_t g_intf_lock = PTHREAD_MUTEX_INITIALIZER;
-static mm_jpeg_obj* g_jpeg_obj = NULL;
-
-static pthread_mutex_t g_handler_lock = PTHREAD_MUTEX_INITIALIZER;
-static uint16_t g_handler_history_count = 0; /* history count for handler */
-
-void static mm_jpeg_dump_job(mm_jpeg_job* job )
-{
- #if 1
- int i;
- jpeg_image_buffer_config * buf_info;
- buf_info = &job->encode_job.encode_parm.buf_info;
- CDBG_ERROR("*****Dump job************");
- CDBG_ERROR("rotation =%d, exif_numEntries=%d, is_video_frame=%d",
- job->encode_job.encode_parm.rotation, job->encode_job.encode_parm.exif_numEntries,
- job->encode_job.encode_parm.buf_info.src_imgs.is_video_frame);
- CDBG_ERROR("Buff_inof: sin_img fd=%d, buf_len=%d, buf_add=%p: src img img num=%d", buf_info->sink_img.fd, buf_info->sink_img.buf_len,
- buf_info->sink_img.buf_vaddr, buf_info->src_imgs.src_img_num);
- for (i=0; i < buf_info->src_imgs.src_img_num; i++) {
- CDBG_ERROR("src_img[%d] fmt=%d, col_fmt=%d, type=%d, bum_buf=%d, quality=%d, src: %dx%d, out:%dx%d, crop: %dx%d, x=%d, y=%d", i, buf_info->src_imgs.src_img[i].img_fmt,
- buf_info->src_imgs.src_img[i].color_format,
- buf_info->src_imgs.src_img[i].type,
- buf_info->src_imgs.src_img[i].num_bufs,
- buf_info->src_imgs.src_img[i].quality,
- buf_info->src_imgs.src_img[i].src_dim.width, buf_info->src_imgs.src_img[i].src_dim.height,
- buf_info->src_imgs.src_img[i].out_dim.width, buf_info->src_imgs.src_img[i].out_dim.height,
- buf_info->src_imgs.src_img[i].crop.width, buf_info->src_imgs.src_img[i].crop.height,
- buf_info->src_imgs.src_img[i].crop.offset_x, buf_info->src_imgs.src_img[i].crop.offset_y
- );
- }
-
- #endif
-
-}
-
-/* utility function to generate handler */
-uint32_t mm_jpeg_util_generate_handler(uint8_t index)
-{
- uint32_t handler = 0;
- pthread_mutex_lock(&g_handler_lock);
- g_handler_history_count++;
- if (0 == g_handler_history_count) {
- g_handler_history_count++;
- }
- handler = g_handler_history_count;
- handler = (handler<<8) | index;
- pthread_mutex_unlock(&g_handler_lock);
- return handler;
-}
-
-uint8_t mm_jpeg_util_get_index_by_handler(uint32_t handler)
-{
- return (handler&0x000000ff);
-}
-
-static int32_t mm_jpeg_intf_start_job(uint32_t client_hdl, mm_jpeg_job* job, uint32_t* jobId)
-{
- int32_t rc = -1;
-
- if (0 == client_hdl ||
- NULL == job ||
- NULL == jobId) {
- CDBG_ERROR("%s: invalid parameters for client_hdl, job or jobId", __func__);
- return rc;
- }
-
- pthread_mutex_lock(&g_intf_lock);
- if (NULL == g_jpeg_obj) {
- /* mm_jpeg obj not exists, return error */
- CDBG_ERROR("%s: mm_jpeg is not opened yet", __func__);
- pthread_mutex_unlock(&g_intf_lock);
- return rc;
- }
- mm_jpeg_dump_job(job);
- rc = mm_jpeg_start_job(g_jpeg_obj, client_hdl, job, jobId);
- pthread_mutex_unlock(&g_intf_lock);
- return rc;
-}
-
-static int32_t mm_jpeg_intf_abort_job(uint32_t client_hdl, uint32_t jobId)
-{
- int32_t rc = -1;
-
- if (0 == client_hdl || 0 == jobId) {
- CDBG_ERROR("%s: invalid client_hdl or jobId", __func__);
- return rc;
- }
-
- pthread_mutex_lock(&g_intf_lock);
- if (NULL == g_jpeg_obj) {
- /* mm_jpeg obj not exists, return error */
- CDBG_ERROR("%s: mm_jpeg is not opened yet", __func__);
- pthread_mutex_unlock(&g_intf_lock);
- return rc;
- }
-
- rc = mm_jpeg_abort_job(g_jpeg_obj, client_hdl, jobId);
- pthread_mutex_unlock(&g_intf_lock);
- return rc;
-}
-
-static int32_t mm_jpeg_intf_close(uint32_t client_hdl)
-{
- int32_t rc = -1;
-
- if (0 == client_hdl) {
- CDBG_ERROR("%s: invalid client_hdl", __func__);
- return rc;
- }
-
- pthread_mutex_lock(&g_intf_lock);
- if (NULL == g_jpeg_obj) {
- /* mm_jpeg obj not exists, return error */
- CDBG_ERROR("%s: mm_jpeg is not opened yet", __func__);
- pthread_mutex_unlock(&g_intf_lock);
- return rc;
- }
-
- rc = mm_jpeg_close(g_jpeg_obj, client_hdl);
- g_jpeg_obj->num_clients--;
- if(0 == rc) {
- if (0 == g_jpeg_obj->num_clients) {
- /* No client, close jpeg internally */
- rc = mm_jpeg_deinit(g_jpeg_obj);
- free(g_jpeg_obj);
- g_jpeg_obj = NULL;
- }
- }
-
- pthread_mutex_unlock(&g_intf_lock);
- return rc;
-}
-
-/* open jpeg client */
-uint32_t jpeg_open(mm_jpeg_ops_t *ops)
-{
- int32_t rc = 0;
- uint32_t clnt_hdl = 0;
- mm_jpeg_obj* jpeg_obj = NULL;
-
- pthread_mutex_lock(&g_intf_lock);
- /* first time open */
- if(NULL == g_jpeg_obj) {
- jpeg_obj = (mm_jpeg_obj *)malloc(sizeof(mm_jpeg_obj));
- if(NULL == jpeg_obj) {
- CDBG_ERROR("%s: no mem", __func__);
- pthread_mutex_unlock(&g_intf_lock);
- return clnt_hdl;
- }
-
- /* initialize jpeg obj */
- memset(jpeg_obj, 0, sizeof(mm_jpeg_obj));
- rc = mm_jpeg_init(jpeg_obj);
- if(0 != rc) {
- CDBG_ERROR("%s: mm_jpeg_init err = %d", __func__, rc);
- free(jpeg_obj);
- pthread_mutex_unlock(&g_intf_lock);
- return clnt_hdl;
- }
-
- /* remember in global variable */
- g_jpeg_obj = jpeg_obj;
- }
-
- /* open new client */
- clnt_hdl = mm_jpeg_new_client(g_jpeg_obj);
- if (clnt_hdl > 0) {
- /* valid client */
- if (NULL != ops) {
- /* fill in ops tbl if ptr not NULL */
- ops->start_job = mm_jpeg_intf_start_job;
- ops->abort_job = mm_jpeg_intf_abort_job;
- //ops->abort_job_all = mm_jpeg_intf_close,
- ops->close = mm_jpeg_intf_close;
- }
- } else {
- /* failed new client */
- CDBG_ERROR("%s: mm_jpeg_new_client failed", __func__);
-
- if (0 == g_jpeg_obj->num_clients) {
- /* no client, close jpeg */
- mm_jpeg_deinit(g_jpeg_obj);
- free(g_jpeg_obj);
- g_jpeg_obj = NULL;
- }
- }
-
- pthread_mutex_unlock(&g_intf_lock);
- return clnt_hdl;
-}
diff --git a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_queue.c b/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_queue.c
deleted file mode 100755
index 222a7e3..0000000
--- a/camera/QCamera/stack/mm-jpeg-interface/src/mm_jpeg_queue.c
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-Copyright (c) 2012, The Linux Foundation. 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 The Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-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.
-*/
-
-#include <pthread.h>
-#include "mm_jpeg_dbg.h"
-#include "mm_jpeg.h"
-
-int32_t mm_jpeg_queue_init(mm_jpeg_queue_t* queue)
-{
- pthread_mutex_init(&queue->lock, NULL);
- cam_list_init(&queue->head.list);
- queue->size = 0;
- return 0;
-}
-
-int32_t mm_jpeg_queue_enq(mm_jpeg_queue_t* queue, void* data)
-{
- mm_jpeg_q_node_t* node =
- (mm_jpeg_q_node_t *)malloc(sizeof(mm_jpeg_q_node_t));
- if (NULL == node) {
- CDBG_ERROR("%s: No memory for mm_jpeg_q_node_t", __func__);
- return -1;
- }
-
- memset(node, 0, sizeof(mm_jpeg_q_node_t));
- node->data = data;
-
- pthread_mutex_lock(&queue->lock);
- cam_list_add_tail_node(&node->list, &queue->head.list);
- queue->size++;
- pthread_mutex_unlock(&queue->lock);
-
- return 0;
-
-}
-
-
-void* mm_jpeg_queue_peek(mm_jpeg_queue_t* queue)
-{
- mm_jpeg_q_node_t* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
- if (pos != head) {
- node = member_of(pos, mm_jpeg_q_node_t, list);
- }
- pthread_mutex_unlock(&queue->lock);
-
- if (NULL != node) {
- data = node->data;
- }
- return data;
-}
-
-void* mm_jpeg_queue_deq(mm_jpeg_queue_t* queue)
-{
- mm_jpeg_q_node_t* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
- if (pos != head) {
- node = member_of(pos, mm_jpeg_q_node_t, list);
- cam_list_del_node(&node->list);
- queue->size--;
- }
- pthread_mutex_unlock(&queue->lock);
-
- if (NULL != node) {
- data = node->data;
- free(node);
- }
-
- return data;
-}
-
-uint32_t mm_jpeg_queue_get_size(mm_jpeg_queue_t* queue)
-{
- uint32_t size = 0;
-
- pthread_mutex_lock(&queue->lock);
- size = queue->size;
- pthread_mutex_unlock(&queue->lock);
-
- return size;
-
-}
-
-int32_t mm_jpeg_queue_deinit(mm_jpeg_queue_t* queue)
-{
- mm_jpeg_queue_flush(queue);
- pthread_mutex_destroy(&queue->lock);
- return 0;
-}
-
-int32_t mm_jpeg_queue_flush(mm_jpeg_queue_t* queue)
-{
- mm_jpeg_q_node_t* node = NULL;
- void* data = NULL;
- struct cam_list *head = NULL;
- struct cam_list *pos = NULL;
-
- pthread_mutex_lock(&queue->lock);
- head = &queue->head.list;
- pos = head->next;
-
- while(pos != head) {
- node = member_of(pos, mm_jpeg_q_node_t, list);
- cam_list_del_node(&node->list);
- queue->size--;
-
- /* for now we only assume there is no ptr inside data
- * so we free data directly */
- if (NULL != node->data) {
- free(node->data);
- }
- free(node);
- pos = pos->next;
- }
- queue->size = 0;
- pthread_mutex_unlock(&queue->lock);
- return 0;
-}