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