1 /* 2 ** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved. 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 #ifndef ANDROID_HARDWARE_QCAMERA_HARDWARE_INTERFACE_H 18 #define ANDROID_HARDWARE_QCAMERA_HARDWARE_INTERFACE_H 19 20 21 #include <utils/threads.h> 22 //#include <camera/CameraHardwareInterface.h> 23 #include <hardware/camera.h> 24 #include <binder/MemoryBase.h> 25 #include <binder/MemoryHeapBase.h> 26 //#include <binder/MemoryHeapPmem.h> 27 #include <utils/threads.h> 28 #include <cutils/properties.h> 29 #include <camera/Camera.h> 30 #include "QCameraParameters.h" 31 #include <system/window.h> 32 #include <system/camera.h> 33 #include <hardware/camera.h> 34 #include <gralloc_priv.h> 35 #include <QComOMXMetadata.h> 36 37 extern "C" { 38 #include <linux/msm_ion.h> 39 #include <mm_camera_interface2.h> 40 #include "mm_omx_jpeg_encoder.h" 41 } //extern C 42 43 #include "QCameraHWI_Mem.h" 44 #include "QCameraStream.h" 45 #include "QCamera_Intf.h" 46 47 #include "hdr/include/morpho_noise_reduction_ext.h" 48 //Error codes 49 #define NOT_FOUND -1 50 #define MAX_ZOOM_RATIOS 62 51 52 #ifdef Q12 53 #undef Q12 54 #endif 55 56 #define Q12 4096 57 #define QCAMERA_PARM_ENABLE 1 58 #define QCAMERA_PARM_DISABLE 0 59 #define PREVIEW_TBL_MAX_SIZE 14 60 #define VIDEO_TBL_MAX_SIZE 14 61 #define THUMB_TBL_MAX_SIZE 16 62 #define HFR_TBL_MAX_SIZE 2 63 64 struct str_map { 65 const char *const desc; 66 int val; 67 }; 68 69 struct preview_format_info_t { 70 int Hal_format; 71 cam_format_t mm_cam_format; 72 cam_pad_format_t padding; 73 int num_planar; 74 }; 75 76 typedef enum { 77 CAMERA_STATE_UNINITED, 78 CAMERA_STATE_READY, 79 CAMERA_STATE_PREVIEW_START_CMD_SENT, 80 CAMERA_STATE_PREVIEW_STOP_CMD_SENT, 81 CAMERA_STATE_PREVIEW, 82 CAMERA_STATE_RECORD_START_CMD_SENT, /*5*/ 83 CAMERA_STATE_RECORD_STOP_CMD_SENT, 84 CAMERA_STATE_RECORD, 85 CAMERA_STATE_SNAP_START_CMD_SENT, 86 CAMERA_STATE_SNAP_STOP_CMD_SENT, 87 CAMERA_STATE_SNAP_CMD_ACKED, /*10 - snapshot comd acked, snapshot not done yet*/ 88 CAMERA_STATE_ZSL_START_CMD_SENT, 89 CAMERA_STATE_ZSL, 90 CAMERA_STATE_AF_START_CMD_SENT, 91 CAMERA_STATE_AF_STOP_CMD_SENT, 92 CAMERA_STATE_ERROR, /*15*/ 93 94 /*Add any new state above*/ 95 CAMERA_STATE_MAX 96 } HAL_camera_state_type_t; 97 98 enum { 99 BUFFER_NOT_OWNED, 100 BUFFER_UNLOCKED, 101 BUFFER_LOCKED, 102 }; 103 104 typedef enum { 105 HAL_DUMP_FRM_PREVIEW = 1, 106 HAL_DUMP_FRM_VIDEO = 1<<1, 107 HAL_DUMP_FRM_MAIN = 1<<2, 108 HAL_DUMP_FRM_THUMBNAIL = 1<<3, 109 110 /*8 bits mask*/ 111 HAL_DUMP_FRM_MAX = 1 << 8 112 } HAL_cam_dump_frm_type_t; 113 114 115 typedef enum { 116 HAL_CAM_MODE_ZSL = 1, 117 118 /*add new entry before and update the max entry*/ 119 HAL_CAM_MODE_MAX = HAL_CAM_MODE_ZSL << 1, 120 } qQamera_mode_t; 121 122 #define HAL_DUMP_FRM_MASK_ALL ( HAL_DUMP_FRM_PREVIEW + HAL_DUMP_FRM_VIDEO + \ 123 HAL_DUMP_FRM_MAIN + HAL_DUMP_FRM_THUMBNAIL) 124 #define QCAMERA_HAL_PREVIEW_STOPPED 0 125 #define QCAMERA_HAL_PREVIEW_START 1 126 #define QCAMERA_HAL_PREVIEW_STARTED 2 127 #define QCAMERA_HAL_RECORDING_STARTED 3 128 #define QCAMERA_HAL_TAKE_PICTURE 4 129 130 131 typedef struct { 132 int buffer_count; 133 buffer_handle_t *buffer_handle[MM_CAMERA_MAX_NUM_FRAMES]; 134 struct private_handle_t *private_buffer_handle[MM_CAMERA_MAX_NUM_FRAMES]; 135 int stride[MM_CAMERA_MAX_NUM_FRAMES]; 136 uint32_t addr_offset[MM_CAMERA_MAX_NUM_FRAMES]; 137 uint8_t local_flag[MM_CAMERA_MAX_NUM_FRAMES]; 138 camera_memory_t *camera_memory[MM_CAMERA_MAX_NUM_FRAMES]; 139 int main_ion_fd[MM_CAMERA_MAX_NUM_FRAMES]; 140 struct ion_fd_data ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES]; 141 } QCameraHalMemory_t; 142 143 144 typedef struct { 145 int buffer_count; 146 uint32_t size; 147 uint32_t y_offset; 148 uint32_t cbcr_offset; 149 int fd[MM_CAMERA_MAX_NUM_FRAMES]; 150 int local_flag[MM_CAMERA_MAX_NUM_FRAMES]; 151 camera_memory_t* camera_memory[MM_CAMERA_MAX_NUM_FRAMES]; 152 camera_memory_t* metadata_memory[MM_CAMERA_MAX_NUM_FRAMES]; 153 int main_ion_fd[MM_CAMERA_MAX_NUM_FRAMES]; 154 struct ion_allocation_data alloc[MM_CAMERA_MAX_NUM_FRAMES]; 155 struct ion_fd_data ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES]; 156 } QCameraHalHeap_t; 157 158 typedef struct { 159 camera_memory_t* camera_memory[3]; 160 int main_ion_fd[3]; 161 struct ion_allocation_data alloc[3]; 162 struct ion_fd_data ion_info_fd[3]; 163 int fd[3]; 164 int size; 165 } QCameraStatHeap_t; 166 167 typedef struct { 168 int32_t msg_type; 169 int32_t ext1; 170 int32_t ext2; 171 void *cookie; 172 } argm_notify_t; 173 174 typedef struct { 175 int32_t msg_type; 176 camera_memory_t *data; 177 unsigned int index; 178 camera_frame_metadata_t *metadata; 179 void *cookie; 180 } argm_data_cb_t; 181 182 typedef struct { 183 camera_notify_callback notifyCb; 184 camera_data_callback dataCb; 185 argm_notify_t argm_notify; 186 argm_data_cb_t argm_data_cb; 187 } app_notify_cb_t; 188 189 /* camera_area_t 190 * rectangle with weight to store the focus and metering areas. 191 * x1, y1, x2, y2: from -1000 to 1000 192 * weight: 0 to 1000 193 */ 194 typedef struct { 195 int x1, y1, x2, y2; 196 int weight; 197 } camera_area_t; 198 199 //EXIF globals 200 static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 }; // "ASCII\0\0\0" 201 static const char ExifUndefinedPrefix[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // "\0\0\0\0\0\0\0\0" 202 203 //EXIF detfines 204 #define MAX_EXIF_TABLE_ENTRIES 23 205 #define GPS_PROCESSING_METHOD_SIZE 101 206 #define FOCAL_LENGTH_DECIMAL_PRECISION 100 207 #define EXIF_ASCII_PREFIX_SIZE 8 //(sizeof(ExifAsciiPrefix)) 208 #define F_NUMBER_DECIMAL_PRECISION 100 209 210 typedef struct{ 211 //GPS tags 212 rat_t latitude[3]; 213 rat_t longitude[3]; 214 char lonRef[2]; 215 char latRef[2]; 216 rat_t altitude; 217 rat_t gpsTimeStamp[3]; 218 char gpsDateStamp[20]; 219 char gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE+GPS_PROCESSING_METHOD_SIZE]; 220 //Other tags 221 char dateTime[20]; 222 char subsecTime[7]; 223 rat_t focalLength; 224 rat_t f_number; 225 uint16_t flashMode; 226 uint16_t isoSpeed; 227 rat_t exposure_time; 228 229 bool mAltitude; 230 bool mLongitude; 231 bool mLatitude; 232 bool mTimeStamp; 233 bool mGpsProcess; 234 235 int mAltitude_ref; 236 long mGPSTimestamp; 237 int mWbMode; 238 char make[20]; 239 char model[20]; 240 241 } exif_values_t; 242 243 namespace android { 244 245 class QCameraStream; 246 247 class QCameraHardwareInterface : public virtual RefBase { 248 public: 249 250 QCameraHardwareInterface(int cameraId, int mode); 251 252 /** Set the ANativeWindow to which preview frames are sent */ 253 int setPreviewWindow(preview_stream_ops_t* window); 254 255 /** Set the notification and data callbacks */ 256 void setCallbacks(camera_notify_callback notify_cb, 257 camera_data_callback data_cb, 258 camera_data_timestamp_callback data_cb_timestamp, 259 camera_request_memory get_memory, 260 void *user); 261 262 /** 263 * The following three functions all take a msg_type, which is a bitmask of 264 * the messages defined in include/ui/Camera.h 265 */ 266 267 /** 268 * Enable a message, or set of messages. 269 */ 270 void enableMsgType(int32_t msg_type); 271 272 /** 273 * Disable a message, or a set of messages. 274 * 275 * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera 276 * HAL should not rely on its client to call releaseRecordingFrame() to 277 * release video recording frames sent out by the cameral HAL before and 278 * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL 279 * clients must not modify/access any video recording frame after calling 280 * disableMsgType(CAMERA_MSG_VIDEO_FRAME). 281 */ 282 void disableMsgType(int32_t msg_type); 283 284 /** 285 * Query whether a message, or a set of messages, is enabled. Note that 286 * this is operates as an AND, if any of the messages queried are off, this 287 * will return false. 288 */ 289 int msgTypeEnabled(int32_t msg_type); 290 291 /** 292 * Start preview mode. 293 */ 294 int startPreview(); 295 int startPreview2(); 296 297 /** 298 * Stop a previously started preview. 299 */ 300 void stopPreview(); 301 302 /** 303 * Returns true if preview is enabled. 304 */ 305 int previewEnabled(); 306 307 308 /** 309 * Request the camera HAL to store meta data or real YUV data in the video 310 * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If 311 * it is not called, the default camera HAL behavior is to store real YUV 312 * data in the video buffers. 313 * 314 * This method should be called before startRecording() in order to be 315 * effective. 316 * 317 * If meta data is stored in the video buffers, it is up to the receiver of 318 * the video buffers to interpret the contents and to find the actual frame 319 * data with the help of the meta data in the buffer. How this is done is 320 * outside of the scope of this method. 321 * 322 * Some camera HALs may not support storing meta data in the video buffers, 323 * but all camera HALs should support storing real YUV data in the video 324 * buffers. If the camera HAL does not support storing the meta data in the 325 * video buffers when it is requested to do do, INVALID_OPERATION must be 326 * returned. It is very useful for the camera HAL to pass meta data rather 327 * than the actual frame data directly to the video encoder, since the 328 * amount of the uncompressed frame data can be very large if video size is 329 * large. 330 * 331 * @param enable if true to instruct the camera HAL to store 332 * meta data in the video buffers; false to instruct 333 * the camera HAL to store real YUV data in the video 334 * buffers. 335 * 336 * @return OK on success. 337 */ 338 int storeMetaDataInBuffers(int enable); 339 340 /** 341 * Start record mode. When a record image is available, a 342 * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding 343 * frame. Every record frame must be released by a camera HAL client via 344 * releaseRecordingFrame() before the client calls 345 * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls 346 * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's 347 * responsibility to manage the life-cycle of the video recording frames, 348 * and the client must not modify/access any video recording frames. 349 */ 350 int startRecording(); 351 352 /** 353 * Stop a previously started recording. 354 */ 355 void stopRecording(); 356 357 /** 358 * Returns true if recording is enabled. 359 */ 360 int recordingEnabled(); 361 362 /** 363 * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME. 364 * 365 * It is camera HAL client's responsibility to release video recording 366 * frames sent out by the camera HAL before the camera HAL receives a call 367 * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to 368 * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's 369 * responsibility to manage the life-cycle of the video recording frames. 370 */ 371 void releaseRecordingFrame(const void *opaque); 372 373 /** 374 * Start auto focus, the notification callback routine is called with 375 * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be 376 * called again if another auto focus is needed. 377 */ 378 int autoFocus(); 379 380 /** 381 * Cancels auto-focus function. If the auto-focus is still in progress, 382 * this function will cancel it. Whether the auto-focus is in progress or 383 * not, this function will return the focus position to the default. If 384 * the camera does not support auto-focus, this is a no-op. 385 */ 386 int cancelAutoFocus(); 387 388 /** 389 * Take a picture. 390 */ 391 int takePicture(); 392 393 /** 394 * Cancel a picture that was started with takePicture. Calling this method 395 * when no picture is being taken is a no-op. 396 */ 397 int cancelPicture(); 398 399 /** 400 * Set the camera parameters. This returns BAD_VALUE if any parameter is 401 * invalid or not supported. 402 */ 403 int setParameters(const char *parms); 404 405 //status_t setParameters(const QCameraParameters& params); 406 /** Retrieve the camera parameters. The buffer returned by the camera HAL 407 must be returned back to it with put_parameters, if put_parameters 408 is not NULL. 409 */ 410 int getParameters(char **parms); 411 412 /** The camera HAL uses its own memory to pass us the parameters when we 413 call get_parameters. Use this function to return the memory back to 414 the camera HAL, if put_parameters is not NULL. If put_parameters 415 is NULL, then you have to use free() to release the memory. 416 */ 417 void putParameters(char *); 418 419 /** 420 * Send command to camera driver. 421 */ 422 int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); 423 424 /** 425 * Release the hardware resources owned by this object. Note that this is 426 * *not* done in the destructor. 427 */ 428 void release(); 429 430 /** 431 * Dump state of the camera hardware 432 */ 433 int dump(int fd); 434 435 //virtual sp<IMemoryHeap> getPreviewHeap() const; 436 //virtual sp<IMemoryHeap> getRawHeap() const; 437 438 439 status_t takeLiveSnapshot(); 440 status_t takeFullSizeLiveshot(); 441 bool canTakeFullSizeLiveshot(); 442 443 //virtual status_t getBufferInfo( sp<IMemory>& Frame, 444 //size_t *alignedSize); 445 void getPictureSize(int *picture_width, int *picture_height) const; 446 void getPreviewSize(int *preview_width, int *preview_height) const; 447 cam_format_t getPreviewFormat() const; 448 449 cam_pad_format_t getPreviewPadding() const; 450 451 //bool useOverlay(void); 452 //virtual status_t setOverlay(const sp<Overlay> &overlay); 453 void processEvent(mm_camera_event_t *); 454 int getJpegQuality() const; 455 int getNumOfSnapshots(void) const; 456 int getNumOfSnapshots(const QCameraParameters& params); 457 int getThumbSizesFromAspectRatio(uint32_t aspect_ratio, 458 int *picture_width, 459 int *picture_height); 460 bool isRawSnapshot(); 461 bool mShutterSoundPlayed; 462 void dumpFrameToFile(struct msm_frame*, HAL_cam_dump_frm_type_t); 463 464 static QCameraHardwareInterface *createInstance(int, int); 465 status_t setZSLBurstLookBack(const QCameraParameters& params); 466 status_t setZSLBurstInterval(const QCameraParameters& params); 467 int getZSLBurstInterval(void); 468 int getZSLQueueDepth(void) const; 469 int getZSLBackLookCount(void) const; 470 471 ~QCameraHardwareInterface(); 472 int initHeapMem(QCameraHalHeap_t *heap, int num_of_buf, int pmem_type, 473 int frame_len, int cbcr_off, int y_off, mm_cameara_stream_buf_t *StreamBuf, 474 mm_camera_buf_def_t *buf_def, uint8_t num_planes, uint32_t *planes); 475 476 int releaseHeapMem( QCameraHalHeap_t *heap); 477 status_t sendMappingBuf(int ext_mode, int idx, int fd, uint32_t size, 478 int cameraid, mm_camera_socket_msg_type msg_type); 479 status_t sendUnMappingBuf(int ext_mode, int idx, int cameraid, 480 mm_camera_socket_msg_type msg_type); 481 482 int allocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt, 483 int ion_type); 484 int deallocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt); 485 486 int allocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt, 487 int ion_type); 488 int deallocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt); 489 490 int cache_ops(int ion_fd, struct ion_flush_data *cache_inv_data, int type); 491 492 void dumpFrameToFile(const void * data, uint32_t size, char* name, 493 char* ext, int index); 494 preview_format_info_t getPreviewFormatInfo( ); 495 bool isCameraReady(); 496 bool isNoDisplayMode(); 497 498 private: 499 int16_t zoomRatios[MAX_ZOOM_RATIOS]; 500 struct camera_size_type default_preview_sizes[PREVIEW_TBL_MAX_SIZE]; 501 struct camera_size_type default_video_sizes[VIDEO_TBL_MAX_SIZE]; 502 struct camera_size_type default_hfr_sizes[HFR_TBL_MAX_SIZE]; 503 struct camera_size_type default_thumbnail_sizes[THUMB_TBL_MAX_SIZE]; 504 unsigned int preview_sizes_count; 505 unsigned int video_sizes_count; 506 unsigned int thumbnail_sizes_count; 507 unsigned int hfr_sizes_count; 508 509 510 bool mUseOverlay; 511 512 void loadTables(); 513 void initDefaultParameters(); 514 bool getMaxPictureDimension(mm_camera_dimension_t *dim); 515 516 status_t updateFocusDistances(); 517 518 bool native_set_parms(mm_camera_parm_type_t type, uint16_t length, void *value); 519 bool native_set_parms( mm_camera_parm_type_t type, uint16_t length, void *value, int *result); 520 521 void hasAutoFocusSupport(); 522 void debugShowPreviewFPS() const; 523 //void prepareSnapshotAndWait(); 524 525 bool isPreviewRunning(); 526 bool isRecordingRunning(); 527 bool isSnapshotRunning(); 528 529 void processChannelEvent(mm_camera_ch_event_t *, app_notify_cb_t *); 530 void processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *); 531 void processRecordChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *); 532 void processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *); 533 void processCtrlEvent(mm_camera_ctrl_event_t *, app_notify_cb_t *); 534 void processStatsEvent(mm_camera_stats_event_t *, app_notify_cb_t *); 535 void processInfoEvent(mm_camera_info_event_t *event, app_notify_cb_t *); 536 void processprepareSnapshotEvent(cam_ctrl_status_t *); 537 void roiEvent(fd_roi_t roi, app_notify_cb_t *); 538 void zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *); 539 void autofocusevent(cam_ctrl_status_t *status, app_notify_cb_t *); 540 void handleZoomEventForPreview(app_notify_cb_t *); 541 void handleZoomEventForSnapshot(void); 542 status_t autoFocusEvent(cam_ctrl_status_t *, app_notify_cb_t *); 543 status_t autoFocusMoveEvent(cam_ctrl_status_t *, app_notify_cb_t *); 544 545 void filterPictureSizes(); 546 bool supportsSceneDetection(); 547 bool supportsSelectableZoneAf(); 548 bool supportsFaceDetection(); 549 bool supportsRedEyeReduction(); 550 bool preview_parm_config (cam_ctrl_dimension_t* dim,QCameraParameters& parm); 551 552 void stopPreviewInternal(); 553 void stopRecordingInternal(); 554 //void stopPreviewZSL(); 555 status_t cancelPictureInternal(); 556 //status_t startPreviewZSL(); 557 void pausePreviewForSnapshot(); 558 void pausePreviewForZSL(); 559 void pausePreviewForVideo(); 560 void prepareVideoPicture(bool disable); 561 status_t resumePreviewAfterSnapshot(); 562 563 status_t runFaceDetection(); 564 565 status_t setParameters(const QCameraParameters& params); 566 QCameraParameters& getParameters() ; 567 568 bool getFlashCondition(void); 569 570 status_t setCameraMode(const QCameraParameters& params); 571 status_t setPictureSizeTable(void); 572 status_t setPreviewSizeTable(void); 573 status_t setVideoSizeTable(void); 574 status_t setPreviewSize(const QCameraParameters& params); 575 status_t setJpegThumbnailSize(const QCameraParameters& params); 576 status_t setPreviewFpsRange(const QCameraParameters& params); 577 status_t setPreviewFrameRate(const QCameraParameters& params); 578 status_t setPreviewFrameRateMode(const QCameraParameters& params); 579 status_t setVideoSize(const QCameraParameters& params); 580 status_t setPictureSize(const QCameraParameters& params); 581 status_t setJpegQuality(const QCameraParameters& params); 582 status_t setNumOfSnapshot(const QCameraParameters& params); 583 status_t setJpegRotation(int isZSL); 584 int getJpegRotation(void); 585 int getISOSpeedValue(); 586 status_t setAntibanding(const QCameraParameters& params); 587 status_t setEffect(const QCameraParameters& params); 588 status_t setExposureCompensation(const QCameraParameters ¶ms); 589 status_t setAutoExposure(const QCameraParameters& params); 590 status_t setWhiteBalance(const QCameraParameters& params); 591 status_t setFlash(const QCameraParameters& params); 592 status_t setGpsLocation(const QCameraParameters& params); 593 status_t setRotation(const QCameraParameters& params); 594 status_t setZoom(const QCameraParameters& params); 595 status_t setFocusMode(const QCameraParameters& params); 596 status_t setBrightness(const QCameraParameters& params); 597 status_t setSkinToneEnhancement(const QCameraParameters& params); 598 status_t setOrientation(const QCameraParameters& params); 599 status_t setLensshadeValue(const QCameraParameters& params); 600 status_t setMCEValue(const QCameraParameters& params); 601 status_t setISOValue(const QCameraParameters& params); 602 status_t setPictureFormat(const QCameraParameters& params); 603 status_t setSharpness(const QCameraParameters& params); 604 status_t setContrast(const QCameraParameters& params); 605 status_t setSaturation(const QCameraParameters& params); 606 status_t setWaveletDenoise(const QCameraParameters& params); 607 status_t setSceneMode(const QCameraParameters& params); 608 status_t setContinuousAf(const QCameraParameters& params); 609 status_t setFaceDetection(const char *str); 610 status_t setSceneDetect(const QCameraParameters& params); 611 status_t setStrTextures(const QCameraParameters& params); 612 status_t setPreviewFormat(const QCameraParameters& params); 613 status_t setSelectableZoneAf(const QCameraParameters& params); 614 status_t setOverlayFormats(const QCameraParameters& params); 615 status_t setHighFrameRate(const QCameraParameters& params); 616 status_t setRedeyeReduction(const QCameraParameters& params); 617 status_t setAEBracket(const QCameraParameters& params); 618 status_t setFaceDetect(const QCameraParameters& params); 619 status_t setDenoise(const QCameraParameters& params); 620 status_t setAecAwbLock(const QCameraParameters & params); 621 status_t setHistogram(int histogram_en); 622 status_t setRecordingHint(const QCameraParameters& params); 623 status_t setRecordingHintValue(const int32_t value); 624 status_t setFocusAreas(const QCameraParameters& params); 625 status_t setMeteringAreas(const QCameraParameters& params); 626 status_t setFullLiveshot(void); 627 status_t setDISMode(void); 628 status_t setCaptureBurstExp(void); 629 status_t setPowerMode(const QCameraParameters& params); 630 void takePicturePrepareHardware( ); 631 status_t setNoDisplayMode(const QCameraParameters& params); 632 status_t setCAFLockCancel(void); 633 634 isp3a_af_mode_t getAutoFocusMode(const QCameraParameters& params); 635 bool isValidDimension(int w, int h); 636 637 String8 create_values_str(const str_map *values, int len); 638 639 void setMyMode(int mode); 640 bool isZSLMode(); 641 bool isWDenoiseEnabled(); 642 void wdenoiseEvent(cam_ctrl_status_t status, void *cookie); 643 bool isLowPowerCamcorder(); 644 void freePictureTable(void); 645 void freeVideoSizeTable(void); 646 647 int32_t createPreview(); 648 int32_t createRecord(); 649 int32_t createSnapshot(); 650 651 int getHDRMode(); 652 //EXIF 653 void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type, 654 uint32_t count, uint8_t copy, void *data); 655 void setExifTags(); 656 void initExifData(); 657 void deinitExifData(); 658 void setExifTagsGPS(); getExifData()659 exif_tags_info_t* getExifData(){ return mExifData; } getExifTableNumEntries()660 int getExifTableNumEntries() { return mExifTableNumEntries; } 661 void parseGPSCoordinate(const char *latlonString, rat_t* coord); 662 bool getHdrInfoAndSetExp( int max_num_frm, int *num_frame, int *exp); 663 void hdrEvent(cam_ctrl_status_t status, void *cookie); 664 665 int mCameraId; 666 camera_mode_t myMode; 667 bool mPauseFramedispatch; 668 669 QCameraParameters mParameters; 670 //sp<Overlay> mOverlay; 671 int32_t mMsgEnabled; 672 673 camera_notify_callback mNotifyCb; 674 camera_data_callback mDataCb; 675 camera_data_timestamp_callback mDataCbTimestamp; 676 camera_request_memory mGetMemory; 677 void *mCallbackCookie; 678 679 sp<AshmemPool> mMetaDataHeap; 680 681 mutable Mutex mLock; 682 //mutable Mutex eventLock; 683 Mutex mCallbackLock; 684 Mutex mPreviewMemoryLock; 685 Mutex mRecordingMemoryLock; 686 Mutex mAutofocusLock; 687 Mutex mMetaDataWaitLock; 688 Mutex mRecordFrameLock; 689 Mutex mRecordLock; 690 Condition mRecordWait; 691 pthread_mutex_t mAsyncCmdMutex; 692 pthread_cond_t mAsyncCmdWait; 693 694 QCameraStream *mStreamDisplay; 695 QCameraStream *mStreamRecord; 696 QCameraStream *mStreamSnap; 697 QCameraStream *mStreamLiveSnap; 698 699 cam_ctrl_dimension_t mDimension; 700 int mPreviewWidth, mPreviewHeight; 701 int mVideoWidth, mVideoHeight; 702 int thumbnailWidth, thumbnailHeight; 703 int maxSnapshotWidth, maxSnapshotHeight; 704 int mPreviewFormat; 705 int mFps; 706 int mDebugFps; 707 int mBrightness; 708 int mContrast; 709 int mBestShotMode; 710 int mEffects; 711 int mSkinToneEnhancement; 712 int mDenoiseValue; 713 int mHJR; 714 int mRotation; 715 int mJpegQuality; 716 int mThumbnailQuality; 717 int mTargetSmoothZoom; 718 int mSmoothZoomStep; 719 int mMaxZoom; 720 int mCurrentZoom; 721 int mSupportedPictureSizesCount; 722 int mFaceDetectOn; 723 int mDumpFrmCnt; 724 int mDumpSkipCnt; 725 int mFocusMode; 726 727 unsigned int mPictureSizeCount; 728 unsigned int mPreviewSizeCount; 729 int mPowerMode; 730 unsigned int mVideoSizeCount; 731 732 bool mAutoFocusRunning; 733 bool mNeedToUnlockCaf; 734 bool mMultiTouch; 735 bool mHasAutoFocusSupport; 736 bool mInitialized; 737 bool mDisEnabled; 738 bool strTexturesOn; 739 bool mIs3DModeOn; 740 bool mSmoothZoomRunning; 741 bool mPreparingSnapshot; 742 bool mParamStringInitialized; 743 bool mZoomSupported; 744 bool mSendMetaData; 745 bool mFullLiveshotEnabled; 746 bool mRecordingHint; 747 bool mAppRecordingHint; 748 bool mStartRecording; 749 bool mReleasedRecordingFrame; 750 bool mStateLiveshot; 751 int mHdrMode; 752 int mSnapshotFormat; 753 int mZslInterval; 754 bool mRestartPreview; 755 bool isCameraOpen; 756 757 led_mode_t mLedStatusForZsl; 758 bool mFlashCond; 759 760 /*for histogram*/ 761 int mStatsOn; 762 int mCurrentHisto; 763 bool mSendData; 764 sp<AshmemPool> mStatHeap; 765 camera_memory_t *mStatsMapped[3]; 766 QCameraStatHeap_t mHistServer; 767 int32_t mStatSize; 768 769 bool mZslLookBackMode; 770 int mZslLookBackValue; 771 int mHFRLevel; 772 bool mZslEmptyQueueFlag; 773 String8 mEffectValues; 774 String8 mIsoValues; 775 String8 mSceneModeValues; 776 String8 mSceneDetectValues; 777 String8 mFocusModeValues; 778 String8 mSelectableZoneAfValues; 779 String8 mAutoExposureValues; 780 String8 mWhitebalanceValues; 781 String8 mAntibandingValues; 782 String8 mFrameRateModeValues; 783 String8 mTouchAfAecValues; 784 String8 mPreviewSizeValues; 785 String8 mPictureSizeValues; 786 String8 mVideoSizeValues; 787 String8 mFlashValues; 788 String8 mLensShadeValues; 789 String8 mMceValues; 790 String8 mHistogramValues; 791 String8 mSkinToneEnhancementValues; 792 String8 mPictureFormatValues; 793 String8 mDenoiseValues; 794 String8 mZoomRatioValues; 795 String8 mPreviewFrameRateValues; 796 String8 mPreviewFormatValues; 797 String8 mFaceDetectionValues; 798 String8 mHfrValues; 799 String8 mHfrSizeValues; 800 String8 mRedeyeReductionValues; 801 String8 denoise_value; 802 String8 mFpsRangesSupportedValues; 803 String8 mZslValues; 804 String8 mFocusDistance; 805 806 friend class QCameraStream; 807 friend class QCameraStream_record; 808 friend class QCameraStream_preview; 809 friend class QCameraStream_Snapshot; 810 811 camera_size_type* mPictureSizes; 812 camera_size_type* mPreviewSizes; 813 camera_size_type* mVideoSizes; 814 const camera_size_type * mPictureSizesPtr; 815 HAL_camera_state_type_t mCameraState; 816 void *libdnr; 817 int (*LINK_morpho_DNR_ProcessFrame)(unsigned char* yuvImage, int width, int height, int y_level, int c_level); 818 819 /* Temporary - can be removed after Honeycomb*/ 820 #ifdef USE_ION 821 sp<IonPool> mPostPreviewHeap; 822 #else 823 sp<PmemPool> mPostPreviewHeap; 824 #endif 825 mm_cameara_stream_buf_t mPrevForPostviewBuf; 826 int mStoreMetaDataInFrame; 827 preview_stream_ops_t *mPreviewWindow; 828 Mutex mStateLock; 829 int mPreviewState; 830 /*preview memory with display case: memory is allocated and freed via 831 gralloc */ 832 QCameraHalMemory_t mPreviewMemory; 833 834 /*preview memory without display case: memory is allocated 835 directly by camera */ 836 QCameraHalHeap_t mNoDispPreviewMemory; 837 838 QCameraHalHeap_t mSnapshotMemory; 839 QCameraHalHeap_t mThumbnailMemory; 840 QCameraHalHeap_t mRecordingMemory; 841 QCameraHalHeap_t mJpegMemory; 842 QCameraHalHeap_t mRawMemory; 843 camera_frame_metadata_t mMetadata; 844 camera_face_t mFace[MAX_ROI]; 845 preview_format_info_t mPreviewFormatInfo; 846 friend void liveshot_callback(mm_camera_ch_data_buf_t *frame,void *user_data); 847 848 //EXIF 849 exif_tags_info_t mExifData[MAX_EXIF_TABLE_ENTRIES]; //Exif tags for JPEG encoder 850 exif_values_t mExifValues; //Exif values in usable format 851 int mExifTableNumEntries; //NUmber of entries in mExifData 852 int mNoDisplayMode; 853 int mIsoValue; 854 855 /* Used to show the process state of snapshot_jpeg_cb*/ 856 Mutex mSnapJpegCbLock; 857 Condition mSnapJpegCbWait; 858 bool mSnapJpegCbRunning; 859 bool mSnapCbDisabled; 860 }; 861 862 }; // namespace android 863 864 #endif 865