1 /* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. 2 * 3 * Redistribution and use in source and binary forms, with or without 4 * modification, are permitted provided that the following conditions are 5 * met: 6 * * Redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above 9 * copyright notice, this list of conditions and the following 10 * disclaimer in the documentation and/or other materials provided 11 * with the distribution. 12 * * Neither the name of The Linux Foundation nor the names of its 13 * contributors may be used to endorse or promote products derived 14 * from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 /*#error uncomment this for compiler test!*/ 29 //#define ALOG_NDEBUG 0 30 #define ALOG_NIDEBUG 0 31 #define LOG_TAG "QualcommUsbCamera" 32 33 #include <utils/Log.h> 34 #include <utils/threads.h> 35 #include <fcntl.h> 36 #include <sys/mman.h> 37 #include <sys/stat.h> 38 #include <unistd.h> 39 #include <sys/prctl.h> 40 #include <sys/resource.h> 41 #include <pthread.h> 42 #include <linux/uvcvideo.h> 43 44 #include "QCameraHAL.h" 45 #include "QualcommUsbCamera.h" 46 #include "QCameraUsbPriv.h" 47 #include "QCameraMjpegDecode.h" 48 #include "QCameraUsbParm.h" 49 #include <gralloc_priv.h> 50 #include <genlock.h> 51 52 extern "C" { 53 #include <sys/time.h> 54 } 55 56 camera_device_ops_t usbcam_camera_ops = { 57 set_preview_window: android::usbcam_set_preview_window, 58 set_callbacks: android::usbcam_set_CallBacks, 59 enable_msg_type: android::usbcam_enable_msg_type, 60 disable_msg_type: android::usbcam_disable_msg_type, 61 msg_type_enabled: android::usbcam_msg_type_enabled, 62 63 start_preview: android::usbcam_start_preview, 64 stop_preview: android::usbcam_stop_preview, 65 preview_enabled: android::usbcam_preview_enabled, 66 store_meta_data_in_buffers: android::usbcam_store_meta_data_in_buffers, 67 68 start_recording: android::usbcam_start_recording, 69 stop_recording: android::usbcam_stop_recording, 70 recording_enabled: android::usbcam_recording_enabled, 71 release_recording_frame: android::usbcam_release_recording_frame, 72 73 auto_focus: android::usbcam_auto_focus, 74 cancel_auto_focus: android::usbcam_cancel_auto_focus, 75 76 take_picture: android::usbcam_take_picture, 77 cancel_picture: android::usbcam_cancel_picture, 78 79 set_parameters: android::usbcam_set_parameters, 80 get_parameters: android::usbcam_get_parameters, 81 put_parameters: android::usbcam_put_parameters, 82 send_command: android::usbcam_send_command, 83 84 release: android::usbcam_release, 85 dump: android::usbcam_dump, 86 }; 87 88 #define CAPTURE 1 89 #define DISPLAY 1 90 #define CALL_BACK 1 91 #define MEMSET 0 92 #define FREAD_JPEG_PICTURE 0 93 #define JPEG_ON_USB_CAMERA 1 94 #define FILE_DUMP_CAMERA 0 95 #define FILE_DUMP_B4_DISP 0 96 97 namespace android { 98 99 static int initUsbCamera( camera_hardware_t *camHal, 100 int width, int height, 101 int pixelFormat); 102 static int startUsbCamCapture( camera_hardware_t *camHal); 103 static int stopUsbCamCapture( camera_hardware_t *camHal); 104 static int initV4L2mmap( camera_hardware_t *camHal); 105 static int unInitV4L2mmap( camera_hardware_t *camHal); 106 static int launch_preview_thread( camera_hardware_t *camHal); 107 static int launchTakePictureThread( camera_hardware_t *camHal); 108 static int initDisplayBuffers( camera_hardware_t *camHal); 109 static int deInitDisplayBuffers( camera_hardware_t *camHal); 110 static int stopPreviewInternal( camera_hardware_t *camHal); 111 static int get_buf_from_cam( camera_hardware_t *camHal); 112 static int put_buf_to_cam( camera_hardware_t *camHal); 113 static int prvwThreadTakePictureInternal(camera_hardware_t *camHal); 114 static int get_buf_from_display( camera_hardware_t *camHal, int *buffer_id); 115 static int put_buf_to_display( camera_hardware_t *camHal, int buffer_id); 116 static int convert_data_frm_cam_to_disp(camera_hardware_t *camHal, int buffer_id); 117 static void * previewloop(void *); 118 static void * takePictureThread(void *); 119 static int convert_YUYV_to_420_NV12(char *in_buf, char *out_buf, int wd, int ht); 120 static int get_uvc_device(char *devname); 121 static int getPreviewCaptureFmt(camera_hardware_t *camHal); 122 static int allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type); 123 static int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info); 124 static int ioctlLoop(int fd, int ioctlCmd, void *args); 125 static int readFromFile(char* fileName, char* buffer, int bufferSize); 126 static int fileDump(const char* fileName, char* data, int length, int* frm_cnt); 127 static int encodeJpeg( camera_hardware_t *camHal); 128 void jpegEncodeCb (jpeg_job_status_t status, 129 uint8_t thumbnailDroppedFlag, 130 uint32_t client_hdl, 131 uint32_t jobId, 132 uint8_t* out_data, 133 uint32_t data_size, 134 void *userData); 135 136 /* HAL function implementation goes here*/ 137 138 /** 139 * The functions need to be provided by the camera HAL. 140 * 141 * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo() 142 * and openCameraHardware() is 0 to N-1. 143 */ 144 145 extern "C" int usbcam_get_number_of_cameras() 146 { 147 /* TBR: This is hardcoded currently to 1 USB camera */ 148 int numCameras = 1; 149 ALOGI("%s: E", __func__); 150 ALOGI("%s: X", __func__); 151 152 return numCameras; 153 } 154 155 extern "C" int usbcam_get_camera_info(int camera_id, struct camera_info *info) 156 { 157 int rc = -1; 158 ALOGI("%s: E", __func__); 159 160 /* TBR: This info is hardcoded currently irrespective of camera_id */ 161 if(info) { 162 struct CameraInfo camInfo; 163 memset(&camInfo, -1, sizeof (struct CameraInfo)); 164 165 info->facing = CAMERA_FACING_FRONT;//CAMERA_FACING_BACK; 166 info->orientation = 0; 167 rc = 0; 168 } 169 ALOGI("%s: X", __func__); 170 return rc; 171 } 172 173 /* HAL should return NULL handle if it fails to open camera hardware. */ 174 extern "C" int usbcam_camera_device_open( 175 const struct hw_module_t* module, const char* id, 176 struct hw_device_t** hw_device) 177 { 178 int rc = -1; 179 camera_device *device = NULL; 180 camera_hardware_t *camHal; 181 char *dev_name; 182 183 ALOGI("%s: E", __func__); 184 185 /* initialize return handle value to NULL */ 186 *hw_device = NULL; 187 188 camHal = new camera_hardware_t(); 189 if(!camHal) { 190 191 ALOGE("%s: end in no mem", __func__); 192 return -1; 193 } 194 195 rc = usbCamInitDefaultParameters(camHal); 196 if(0 != rc) 197 { 198 ALOGE("%s: usbCamInitDefaultParameters error", __func__); 199 return rc; 200 } 201 #if CAPTURE 202 203 dev_name = camHal->dev_name; 204 205 rc = get_uvc_device(dev_name); 206 if(rc || *dev_name == '\0'){ 207 ALOGE("%s: No UVC node found \n", __func__); 208 return -1; 209 } 210 211 camHal->fd = open(dev_name, O_RDWR /* required */ | O_NONBLOCK, 0); 212 213 if (camHal->fd < 0) { 214 ALOGE("%s: Cannot open '%s'", __func__, dev_name); 215 free(camHal); 216 rc = -1; 217 }else{ 218 rc = 0; 219 } 220 221 #else /* CAPTURE */ 222 rc = 0; 223 #endif /* CAPTURE */ 224 225 device = &camHal->hw_dev; 226 device->common.close = usbcam_close_camera_device; 227 device->ops = &usbcam_camera_ops; 228 device->priv = (void *)camHal; 229 *hw_device = &(device->common); 230 231 ALOGD("%s: camHal: %p", __func__, camHal); 232 ALOGI("%s: X %d", __func__, rc); 233 234 return rc; 235 } 236 237 extern "C" int usbcam_close_camera_device( hw_device_t *hw_dev) 238 { 239 ALOGI("%s: device =%p E", __func__, hw_dev); 240 int rc = -1; 241 camera_device_t *device = (camera_device_t *)hw_dev; 242 243 if(device) { 244 camera_hardware_t *camHal = (camera_hardware_t *)device->priv; 245 if(camHal) { 246 rc = close(camHal->fd); 247 if(rc < 0) { 248 ALOGE("%s: close failed ", __func__); 249 } 250 camHal->fd = 0; 251 delete camHal; 252 }else{ 253 ALOGE("%s: camHal is NULL pointer ", __func__); 254 } 255 } 256 ALOGI("%s: X device =%p, rc = %d", __func__, hw_dev, rc); 257 return rc; 258 } 259 260 int usbcam_set_preview_window(struct camera_device * device, 261 struct preview_stream_ops *window) 262 { 263 ALOGI("%s: E", __func__); 264 int rc = 0; 265 camera_hardware_t *camHal; 266 267 VALIDATE_DEVICE_HDL(camHal, device, -1); 268 Mutex::Autolock autoLock(camHal->lock); 269 270 /* if window is already set, then de-init previous buffers */ 271 if(camHal->window){ 272 rc = deInitDisplayBuffers(camHal); 273 if(rc < 0) { 274 ALOGE("%s: deInitDisplayBuffers returned error", __func__); 275 } 276 } 277 camHal->window = window; 278 279 if(camHal->window){ 280 rc = initDisplayBuffers(camHal); 281 if(rc < 0) { 282 ALOGE("%s: initDisplayBuffers returned error", __func__); 283 } 284 } 285 ALOGI("%s: X. rc = %d", __func__, rc); 286 return rc; 287 } 288 289 void usbcam_set_CallBacks(struct camera_device * device, 290 camera_notify_callback notify_cb, 291 camera_data_callback data_cb, 292 camera_data_timestamp_callback data_cb_timestamp, 293 camera_request_memory get_memory, 294 void *user) 295 { 296 ALOGI("%s: E", __func__); 297 camera_hardware_t *camHal; 298 299 if(device && device->priv){ 300 camHal = (camera_hardware_t *)device->priv; 301 }else{ 302 ALOGE("%s: Null device or device->priv", __func__); 303 return; 304 } 305 306 Mutex::Autolock autoLock(camHal->lock); 307 308 camHal->notify_cb = notify_cb; 309 camHal->data_cb = data_cb; 310 camHal->data_cb_timestamp = data_cb_timestamp; 311 camHal->get_memory = get_memory; 312 camHal->cb_ctxt = user; 313 314 ALOGI("%s: X", __func__); 315 } 316 317 void usbcam_enable_msg_type(struct camera_device * device, int32_t msg_type) 318 { 319 ALOGI("%s: E", __func__); 320 ALOGI("%s: msg_type: %d", __func__, msg_type); 321 322 camera_hardware_t *camHal; 323 324 if(device && device->priv){ 325 camHal = (camera_hardware_t *)device->priv; 326 }else{ 327 ALOGE("%s: Null device or device->priv", __func__); 328 return; 329 } 330 331 Mutex::Autolock autoLock(camHal->lock); 332 333 camHal->msgEnabledFlag |= msg_type; 334 335 ALOGI("%s: X", __func__); 336 } 337 338 void usbcam_disable_msg_type(struct camera_device * device, int32_t msg_type) 339 { 340 ALOGI("%s: E", __func__); 341 ALOGI("%s: msg_type: %d", __func__, msg_type); 342 343 camera_hardware_t *camHal; 344 if(device && device->priv){ 345 camHal = (camera_hardware_t *)device->priv; 346 }else{ 347 ALOGE("%s: Null device or device->priv", __func__); 348 return; 349 } 350 351 Mutex::Autolock autoLock(camHal->lock); 352 353 camHal->msgEnabledFlag &= ~msg_type; 354 355 ALOGI("%s: X", __func__); 356 } 357 358 int usbcam_msg_type_enabled(struct camera_device * device, int32_t msg_type) 359 { 360 ALOGI("%s: E", __func__); 361 362 camera_hardware_t *camHal; 363 if(device && device->priv){ 364 camHal = (camera_hardware_t *)device->priv; 365 }else{ 366 ALOGE("%s: Null device or device->priv", __func__); 367 return -1; 368 } 369 370 Mutex::Autolock autoLock(camHal->lock); 371 372 ALOGI("%s: X", __func__); 373 return (camHal->msgEnabledFlag & msg_type); 374 } 375 376 int usbcam_start_preview(struct camera_device * device) 377 { 378 ALOGI("%s: E", __func__); 379 380 int rc = -1; 381 camera_hardware_t *camHal = NULL; 382 383 VALIDATE_DEVICE_HDL(camHal, device, -1); 384 Mutex::Autolock autoLock(camHal->lock); 385 386 /* If preivew is already running, nothing to be done */ 387 if(camHal->previewEnabledFlag){ 388 ALOGI("%s: Preview is already running", __func__); 389 return 0; 390 } 391 392 #if CAPTURE 393 rc = initUsbCamera(camHal, camHal->prevWidth, 394 camHal->prevHeight, getPreviewCaptureFmt(camHal)); 395 if(rc < 0) { 396 ALOGE("%s: Failed to intialize the device", __func__); 397 }else{ 398 rc = startUsbCamCapture(camHal); 399 if(rc < 0) { 400 ALOGE("%s: Failed to startUsbCamCapture", __func__); 401 }else{ 402 rc = launch_preview_thread(camHal); 403 if(rc < 0) { 404 ALOGE("%s: Failed to launch_preview_thread", __func__); 405 } 406 } 407 } 408 #else /* CAPTURE */ 409 rc = launch_preview_thread(camHal); 410 if(rc < 0) { 411 ALOGE("%s: Failed to launch_preview_thread", __func__); 412 } 413 #endif /* CAPTURE */ 414 /* if no errors, then set the flag */ 415 if(!rc) 416 camHal->previewEnabledFlag = 1; 417 418 ALOGD("%s: X", __func__); 419 return rc; 420 } 421 422 void usbcam_stop_preview(struct camera_device * device) 423 { 424 ALOGD("%s: E", __func__); 425 426 int rc = 0; 427 camera_hardware_t *camHal; 428 429 if(device && device->priv){ 430 camHal = (camera_hardware_t *)device->priv; 431 }else{ 432 ALOGE("%s: Null device or device->priv", __func__); 433 return; 434 } 435 436 Mutex::Autolock autoLock(camHal->lock); 437 438 rc = stopPreviewInternal(camHal); 439 if(rc) 440 ALOGE("%s: stopPreviewInternal returned error", __func__); 441 442 ALOGI("%s: X", __func__); 443 return; 444 } 445 446 /* This function is equivalent to is_preview_enabled */ 447 int usbcam_preview_enabled(struct camera_device * device) 448 { 449 ALOGI("%s: E", __func__); 450 camera_hardware_t *camHal; 451 452 if(device && device->priv){ 453 camHal = (camera_hardware_t *)device->priv; 454 }else{ 455 ALOGE("%s: Null device or device->priv", __func__); 456 return -1; 457 } 458 Mutex::Autolock autoLock(camHal->lock); 459 460 ALOGI("%s: X", __func__); 461 return camHal->previewEnabledFlag; 462 } 463 464 /* TBD */ 465 int usbcam_store_meta_data_in_buffers(struct camera_device * device, int enable) 466 { 467 ALOGI("%s: E", __func__); 468 int rc = 0; 469 470 ALOGI("%s: X", __func__); 471 return rc; 472 } 473 474 /* TBD */ 475 int usbcam_start_recording(struct camera_device * device) 476 { 477 int rc = 0; 478 ALOGD("%s: E", __func__); 479 480 ALOGD("%s: X", __func__); 481 482 return rc; 483 } 484 485 /* TBD */ 486 void usbcam_stop_recording(struct camera_device * device) 487 { 488 ALOGD("%s: E", __func__); 489 490 ALOGD("%s: X", __func__); 491 } 492 493 /* TBD */ 494 int usbcam_recording_enabled(struct camera_device * device) 495 { 496 int rc = 0; 497 ALOGD("%s: E", __func__); 498 499 ALOGD("%s: X", __func__); 500 return rc; 501 } 502 503 /* TBD */ 504 void usbcam_release_recording_frame(struct camera_device * device, 505 const void *opaque) 506 { 507 ALOGV("%s: E", __func__); 508 509 ALOGD("%s: X", __func__); 510 } 511 512 /* TBD */ 513 int usbcam_auto_focus(struct camera_device * device) 514 { 515 ALOGD("%s: E", __func__); 516 int rc = 0; 517 518 ALOGD("%s: X", __func__); 519 return rc; 520 } 521 522 /* TBD */ 523 int usbcam_cancel_auto_focus(struct camera_device * device) 524 { 525 int rc = 0; 526 ALOGD("%s: E", __func__); 527 528 ALOGD("%s: X", __func__); 529 return rc; 530 } 531 532 int usbcam_take_picture(struct camera_device * device) 533 { 534 ALOGI("%s: E", __func__); 535 int rc = 0; 536 camera_hardware_t *camHal; 537 538 VALIDATE_DEVICE_HDL(camHal, device, -1); 539 540 Mutex::Autolock autoLock(camHal->lock); 541 542 /* If take picture is already in progress, nothing t be done */ 543 if(camHal->takePictInProgress){ 544 ALOGI("%s: Take picture already in progress", __func__); 545 return 0; 546 } 547 548 if(camHal->previewEnabledFlag) 549 { 550 rc = stopPreviewInternal(camHal); 551 if(rc){ 552 ALOGE("%s: stopPreviewInternal returned error", __func__); 553 } 554 USB_CAM_CLOSE(camHal); 555 camHal->prvwStoppedForPicture = 1; 556 } 557 /* TBD: Need to handle any dependencies on video recording state */ 558 rc = launchTakePictureThread(camHal); 559 if(rc) 560 ALOGE("%s: launchTakePictureThread error", __func__); 561 562 #if 0 563 /* This implementation requests preview thread to take picture */ 564 if(camHal->previewEnabledFlag) 565 { 566 camHal->prvwCmdPending++; 567 camHal->prvwCmd = USB_CAM_PREVIEW_TAKEPIC; 568 ALOGD("%s: Take picture command set ", __func__); 569 }else{ 570 ALOGE("%s: Take picture without preview started!", __func__); 571 rc = -1; 572 } 573 #endif 574 575 if(!rc) 576 camHal->takePictInProgress = 1; 577 578 ALOGI("%s: X", __func__); 579 return rc; 580 } 581 582 /* TBD */ 583 int usbcam_cancel_picture(struct camera_device * device) 584 585 { 586 ALOGI("%s: E", __func__); 587 int rc = 0; 588 589 ALOGI("%s: X", __func__); 590 return rc; 591 } 592 593 int usbcam_set_parameters(struct camera_device * device, const char *params) 594 595 { 596 ALOGI("%s: E", __func__); 597 int rc = 0; 598 camera_hardware_t *camHal; 599 600 VALIDATE_DEVICE_HDL(camHal, device, -1); 601 602 Mutex::Autolock autoLock(camHal->lock); 603 604 rc = usbCamSetParameters(camHal, params); 605 606 ALOGI("%s: X", __func__); 607 return rc; 608 } 609 610 char* usbcam_get_parameters(struct camera_device * device) 611 { 612 char *parms; 613 ALOGI("%s: E", __func__); 614 615 camera_hardware_t *camHal; 616 VALIDATE_DEVICE_HDL(camHal, device, NULL); 617 618 Mutex::Autolock autoLock(camHal->lock); 619 620 parms = usbCamGetParameters(camHal); 621 622 ALOGI("%s: X", __func__); 623 return parms; 624 } 625 626 void usbcam_put_parameters(struct camera_device * device, char *parm) 627 628 { 629 ALOGI("%s: E", __func__); 630 631 camera_hardware_t *camHal; 632 633 if(device && device->priv){ 634 camHal = (camera_hardware_t *)device->priv; 635 }else{ 636 ALOGE("%s: Null device or device->priv", __func__); 637 return; 638 } 639 640 usbCamPutParameters(camHal, parm); 641 642 ALOGI("%s: X", __func__); 643 return; 644 } 645 646 /* TBD */ 647 int usbcam_send_command(struct camera_device * device, 648 int32_t cmd, int32_t arg1, int32_t arg2) 649 { 650 int rc = 0; 651 ALOGI("%s: E", __func__); 652 ALOGI("%d", cmd); 653 654 ALOGI("%s: X", __func__); 655 return rc; 656 } 657 658 /* TBD */ 659 void usbcam_release(struct camera_device * device) 660 { 661 ALOGI("%s: E", __func__); 662 #if 0 663 Mutex::Autolock l(&mLock); 664 665 switch(mPreviewState) { 666 case QCAMERA_HAL_PREVIEW_STOPPED: 667 break; 668 case QCAMERA_HAL_PREVIEW_START: 669 break; 670 case QCAMERA_HAL_PREVIEW_STARTED: 671 stopPreviewInternal(); 672 break; 673 case QCAMERA_HAL_RECORDING_STARTED: 674 stopRecordingInternal(); 675 stopPreviewInternal(); 676 break; 677 case QCAMERA_HAL_TAKE_PICTURE: 678 cancelPictureInternal(); 679 break; 680 default: 681 break; 682 } 683 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 684 #endif 685 ALOGI("%s: X", __func__); 686 } 687 688 /* TBD */ 689 int usbcam_dump(struct camera_device * device, int fd) 690 { 691 ALOGI("%s: E", __func__); 692 int rc = 0; 693 694 ALOGI("%s: X", __func__); 695 return rc; 696 } 697 /***************************************************************************** 698 * Static function definitions below 699 *****************************************************************************/ 700 701 /******************************************************************************/ 702 /* No in place conversion supported. Output buffer and input MUST should be */ 703 /* different input buffer for a 4x4 pixel video ***/ 704 /****** YUYVYUYV 00 01 02 03 04 05 06 07 ************/ 705 /****** YUYVYUYV 08 09 10 11 12 13 14 15 ************/ 706 /****** YUYVYUYV 16 17 18 19 20 21 22 23 ************/ 707 /****** YUYVYUYV 24 25 26 27 28 29 30 31 ************/ 708 /******************************************************************************/ 709 /* output generated by this function ******************************************/ 710 /************************** YYYY 00 02 04 06 ************/ 711 /************************** YYYY 08 10 12 14 ************/ 712 /************************** YYYY 16 18 20 22 ************/ 713 /************************** YYYY 24 26 28 30 ************/ 714 /************************** VUVU 03 01 07 05 ************/ 715 /************************** VUVU 19 17 23 21 ************/ 716 /******************************************************************************/ 717 718 static int convert_YUYV_to_420_NV12(char *in_buf, char *out_buf, int wd, int ht) 719 { 720 int rc =0; 721 int row, col, uv_row; 722 723 ALOGD("%s: E", __func__); 724 /* Arrange Y */ 725 for(row = 0; row < ht; row++) 726 for(col = 0; col < wd * 2; col += 2) 727 { 728 out_buf[row * wd + col / 2] = in_buf[row * wd * 2 + col]; 729 } 730 731 /* Arrange UV */ 732 for(row = 0, uv_row = ht; row < ht; row += 2, uv_row++) 733 for(col = 1; col < wd * 2; col += 4) 734 { 735 out_buf[uv_row * wd + col / 2]= in_buf[row * wd * 2 + col + 2]; 736 out_buf[uv_row * wd + col / 2 + 1] = in_buf[row * wd * 2 + col]; 737 } 738 739 ALOGD("%s: X", __func__); 740 return rc; 741 } 742 743 /****************************************************************************** 744 * Function: initDisplayBuffers 745 * Description: This function initializes the preview buffers 746 * 747 * Input parameters: 748 * camHal - camera HAL handle 749 * 750 * Return values: 751 * 0 Success 752 * -1 Error 753 * Notes: none 754 *****************************************************************************/ 755 static int initDisplayBuffers(camera_hardware_t *camHal) 756 { 757 preview_stream_ops *mPreviewWindow; 758 struct ion_fd_data ion_info_fd; 759 int numMinUndequeuedBufs = 0; 760 int rc = 0; 761 int gralloc_usage = 0; 762 int err; 763 int color=30; 764 765 ALOGD("%s: E", __func__); 766 767 #if DISPLAY 768 if(camHal == NULL) { 769 ALOGE("%s: camHal = NULL", __func__); 770 return -1; 771 } 772 773 mPreviewWindow = camHal->window; 774 if(!mPreviewWindow) { 775 ALOGE("%s: mPreviewWindow = NULL", __func__); 776 return -1; 777 } 778 779 /************************************************************************/ 780 /* - get_min_undequeued_buffer_count */ 781 /* - set_buffer_count */ 782 /* - set_buffers_geometry */ 783 /* - set_usage */ 784 /* - dequeue all the display buffers */ 785 /* - cancel buffers: release w/o displaying */ 786 /************************************************************************/ 787 788 /************************************************************************/ 789 /* - get_min_undequeued_buffer_count */ 790 /************************************************************************/ 791 if(mPreviewWindow->get_min_undequeued_buffer_count) { 792 rc = mPreviewWindow->get_min_undequeued_buffer_count( 793 mPreviewWindow, &numMinUndequeuedBufs); 794 if (0 != rc) { 795 ALOGE("%s: get_min_undequeued_buffer_count returned error", __func__); 796 } 797 else 798 ALOGD("%s: get_min_undequeued_buffer_count returned: %d ", 799 __func__, numMinUndequeuedBufs); 800 } 801 else 802 ALOGE("%s: get_min_undequeued_buffer_count is NULL pointer", __func__); 803 804 /************************************************************************/ 805 /* - set_buffer_count */ 806 /************************************************************************/ 807 if(mPreviewWindow->set_buffer_count) { 808 camHal->previewMem.buffer_count = numMinUndequeuedBufs 809 + PRVW_DISP_BUF_CNT; 810 rc = mPreviewWindow->set_buffer_count( 811 mPreviewWindow, 812 camHal->previewMem.buffer_count); 813 if (rc != 0) { 814 ALOGE("%s: set_buffer_count returned error", __func__); 815 }else 816 ALOGD("%s: set_buffer_count returned success", __func__); 817 }else 818 ALOGE("%s: set_buffer_count is NULL pointer", __func__); 819 820 /************************************************************************/ 821 /* - set_buffers_geometry */ 822 /************************************************************************/ 823 if(mPreviewWindow->set_buffers_geometry) { 824 rc = mPreviewWindow->set_buffers_geometry(mPreviewWindow, 825 camHal->dispWidth, 826 camHal->dispHeight, 827 camHal->dispFormat); 828 if (rc != 0) { 829 ALOGE("%s: set_buffers_geometry returned error. %s (%d)", 830 __func__, strerror(-rc), -rc); 831 }else 832 ALOGD("%s: set_buffers_geometry returned success", __func__); 833 }else 834 ALOGE("%s: set_buffers_geometry is NULL pointer", __func__); 835 836 /************************************************************************/ 837 /* - set_usage */ 838 /************************************************************************/ 839 gralloc_usage = CAMERA_GRALLOC_HEAP_ID | CAMERA_GRALLOC_FALLBACK_HEAP_ID | 840 GRALLOC_USAGE_PRIVATE_UNCACHED; 841 842 if(mPreviewWindow->set_usage) { 843 rc = mPreviewWindow->set_usage(mPreviewWindow, gralloc_usage); 844 if (rc != 0) { 845 ALOGE("%s: set_usage returned error", __func__); 846 }else 847 ALOGD("%s: set_usage returned success", __func__); 848 } 849 else 850 ALOGE("%s: set_usage is NULL pointer", __func__); 851 852 /************************************************************************/ 853 /* - dequeue all the display buffers */ 854 /************************************************************************/ 855 for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) { 856 int stride; 857 err = mPreviewWindow->dequeue_buffer( 858 mPreviewWindow, 859 &camHal->previewMem.buffer_handle[cnt], 860 &camHal->previewMem.stride[cnt]); 861 if(!err) { 862 ALOGD("%s: dequeue buf: %p\n", 863 __func__, camHal->previewMem.buffer_handle[cnt]); 864 865 if(mPreviewWindow->lock_buffer) { 866 err = mPreviewWindow->lock_buffer( 867 mPreviewWindow, 868 camHal->previewMem.buffer_handle[cnt]); 869 ALOGD("%s: mPreviewWindow->lock_buffer success", 870 __func__); 871 } 872 873 // lock the buffer using genlock 874 ALOGD("%s: camera call genlock_lock, hdl=%p", 875 __func__, (*camHal->previewMem.buffer_handle[cnt])); 876 877 if (GENLOCK_NO_ERROR != 878 genlock_lock_buffer( 879 (native_handle_t *) (*camHal->previewMem.buffer_handle[cnt]), 880 GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT)) 881 { 882 ALOGE("%s: genlock_lock_buffer(WRITE) failed", 883 __func__); 884 camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED; 885 }else { 886 ALOGD("%s: genlock_lock_buffer hdl =%p", 887 __func__, *camHal->previewMem.buffer_handle[cnt]); 888 camHal->previewMem.local_flag[cnt] = BUFFER_LOCKED; 889 } 890 891 /* Store this buffer details in the context */ 892 camHal->previewMem.private_buffer_handle[cnt] = 893 (struct private_handle_t *) (*camHal->previewMem.buffer_handle[cnt]); 894 895 ALOGD("%s: idx = %d, fd = %d, size = %d, offset = %d", __func__, 896 cnt, camHal->previewMem.private_buffer_handle[cnt]->fd, 897 camHal->previewMem.private_buffer_handle[cnt]->size, 898 camHal->previewMem.private_buffer_handle[cnt]->offset); 899 900 camHal->previewMem.camera_memory[cnt] = 901 camHal->get_memory( 902 camHal->previewMem.private_buffer_handle[cnt]->fd, 903 camHal->previewMem.private_buffer_handle[cnt]->size, 904 1, camHal->cb_ctxt); 905 906 ALOGD("%s: data = %p, size = %d, handle = %p", __func__, 907 camHal->previewMem.camera_memory[cnt]->data, 908 camHal->previewMem.camera_memory[cnt]->size, 909 camHal->previewMem.camera_memory[cnt]->handle); 910 911 #ifdef USE_ION 912 /* In case of ION usage, open ION fd */ 913 camHal->previewMem.mem_info[cnt].main_ion_fd = 914 open("/dev/ion", O_RDONLY); 915 if (camHal->previewMem.mem_info[cnt].main_ion_fd < 0) { 916 ALOGE("%s: failed: could not open ion device\n", __func__); 917 }else{ 918 memset(&ion_info_fd, 0, sizeof(ion_info_fd)); 919 ion_info_fd.fd = 920 camHal->previewMem.private_buffer_handle[cnt]->fd; 921 if (ioctl(camHal->previewMem.mem_info[cnt].main_ion_fd, 922 ION_IOC_IMPORT, &ion_info_fd) < 0) { 923 ALOGE("ION import failed\n"); 924 } 925 } 926 camHal->previewMem.mem_info[cnt].fd = 927 camHal->previewMem.private_buffer_handle[cnt]->fd; 928 camHal->previewMem.mem_info[cnt].size = 929 camHal->previewMem.private_buffer_handle[cnt]->size; 930 camHal->previewMem.mem_info[cnt].handle = ion_info_fd.handle; 931 932 #endif 933 } 934 else 935 ALOGE("%s: dequeue buf %d failed \n", __func__, cnt); 936 } 937 /************************************************************************/ 938 /* - cancel buffers: queue w/o displaying */ 939 /************************************************************************/ 940 for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) { 941 if (GENLOCK_FAILURE == genlock_unlock_buffer( 942 (native_handle_t *)(*(camHal->previewMem.buffer_handle[cnt])))){ 943 ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__, 944 (*(camHal->previewMem.buffer_handle[cnt])) ); 945 } else { 946 camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED; 947 ALOGD("%s: genlock_unlock_buffer success: hdl = %p", 948 __func__, (*(camHal->previewMem.buffer_handle[cnt]))); 949 } 950 951 err = mPreviewWindow->cancel_buffer(mPreviewWindow, 952 (buffer_handle_t *)camHal->previewMem.buffer_handle[cnt]); 953 if(!err) { 954 ALOGD("%s: cancel_buffer successful: %p\n", 955 __func__, camHal->previewMem.buffer_handle[cnt]); 956 }else 957 ALOGE("%s: cancel_buffer failed: %p\n", __func__, 958 camHal->previewMem.buffer_handle[cnt]); 959 } 960 #else 961 rc = 0; 962 #endif /* #if DISPLAY */ 963 ALOGD("%s: X", __func__); 964 return rc; 965 } 966 967 /****************************************************************************** 968 * Function: deInitDisplayBuffers 969 * Description: This function de-initializes all the display buffers allocated 970 * in initDisplayBuffers 971 * 972 * Input parameters: 973 * camHal - camera HAL handle 974 * 975 * Return values: 976 * 0 Success 977 * -1 Error 978 * Notes: none 979 *****************************************************************************/ 980 static int deInitDisplayBuffers(camera_hardware_t *camHal) 981 { 982 int rc = 0; 983 preview_stream_ops *previewWindow; 984 985 ALOGD("%s: E", __func__); 986 987 if(!camHal || !camHal->window) { 988 ALOGE("%s: camHal = NULL or window = NULL ", __func__); 989 return -1; 990 } 991 992 previewWindow = camHal->window; 993 994 /************************************************************************/ 995 /* - Release all buffers that were acquired using get_memory */ 996 /* - If using ION memory, free ION related resources */ 997 /* - genUnlock if buffer is genLocked */ 998 /* - Cancel buffers: queue w/o displaying */ 999 /************************************************************************/ 1000 1001 #if DISPLAY 1002 for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) { 1003 1004 /* Release all buffers that were acquired using get_memory */ 1005 camHal->previewMem.camera_memory[cnt]->release( 1006 camHal->previewMem.camera_memory[cnt]); 1007 1008 #ifdef USE_ION 1009 /* If using ION memory, free ION related resources */ 1010 struct ion_handle_data ion_handle; 1011 memset(&ion_handle, 0, sizeof(ion_handle)); 1012 ion_handle.handle = camHal->previewMem.mem_info[cnt].handle; 1013 if (ioctl(camHal->previewMem.mem_info[cnt].main_ion_fd, 1014 ION_IOC_FREE, &ion_handle) < 0) { 1015 ALOGE("%s: ion free failed\n", __func__); 1016 } 1017 close(camHal->previewMem.mem_info[cnt].main_ion_fd); 1018 #endif 1019 1020 /* genUnlock if buffer is genLocked */ 1021 if(camHal->previewMem.local_flag[cnt] == BUFFER_LOCKED){ 1022 if (GENLOCK_FAILURE == genlock_unlock_buffer( 1023 (native_handle_t *)(*(camHal->previewMem.buffer_handle[cnt])))){ 1024 ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__, 1025 (*(camHal->previewMem.buffer_handle[cnt])) ); 1026 } else { 1027 camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED; 1028 ALOGD("%s: genlock_unlock_buffer success: hdl = %p", 1029 __func__, (*(camHal->previewMem.buffer_handle[cnt]))); 1030 } 1031 } 1032 /* cancel buffers: enqueue w/o displaying */ 1033 rc = previewWindow->cancel_buffer(previewWindow, 1034 (buffer_handle_t *)camHal->previewMem.buffer_handle[cnt]); 1035 if(!rc) { 1036 ALOGD("%s: cancel_buffer successful: %p\n", 1037 __func__, camHal->previewMem.buffer_handle[cnt]); 1038 }else 1039 ALOGE("%s: cancel_buffer failed: %p\n", __func__, 1040 camHal->previewMem.buffer_handle[cnt]); 1041 } 1042 #endif /* #if DISPLAY */ 1043 memset(&camHal->previewMem, 0, sizeof(camHal->previewMem)); 1044 1045 ALOGD("%s: X", __func__); 1046 return rc; 1047 } 1048 1049 /****************************************************************************** 1050 * Function: getPreviewCaptureFmt 1051 * Description: This function implements the logic to decide appropriate 1052 * capture format from the USB camera 1053 * 1054 * Input parameters: 1055 * camHal - camera HAL handle 1056 * 1057 * Return values: 1058 * Capture format. Default (V4L2_PIX_FMT_MJPEG) 1059 * 1060 * Notes: none 1061 *****************************************************************************/ 1062 static int getPreviewCaptureFmt(camera_hardware_t *camHal) 1063 { 1064 int i = 0, mjpegSupported = 0, h264Supported = 0; 1065 struct v4l2_fmtdesc fmtdesc; 1066 1067 memset(&fmtdesc, 0, sizeof(v4l2_fmtdesc)); 1068 1069 /************************************************************************/ 1070 /* - Query the camera for all supported formats */ 1071 /* - Based on the resolution, pick an apporpriate format */ 1072 /************************************************************************/ 1073 1074 /************************************************************************/ 1075 /* - Query the camera for all supported formats */ 1076 /************************************************************************/ 1077 for(i = 0; ; i++) { 1078 fmtdesc.index = i; 1079 fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1080 if (-1 == ioctlLoop(camHal->fd, VIDIOC_ENUM_FMT, &fmtdesc)) { 1081 if (EINVAL == errno) { 1082 ALOGI("%s: Queried all formats till index %d\n", __func__, i); 1083 break; 1084 } else { 1085 ALOGE("%s: VIDIOC_ENUM_FMT failed", __func__); 1086 } 1087 } 1088 if(V4L2_PIX_FMT_MJPEG == fmtdesc.pixelformat){ 1089 mjpegSupported = 1; 1090 ALOGI("%s: V4L2_PIX_FMT_MJPEG is supported", __func__ ); 1091 } 1092 if(V4L2_PIX_FMT_H264 == fmtdesc.pixelformat){ 1093 h264Supported = 1; 1094 ALOGI("%s: V4L2_PIX_FMT_H264 is supported", __func__ ); 1095 } 1096 1097 } 1098 1099 /************************************************************************/ 1100 /* - Based on the resolution, pick an apporpriate format */ 1101 /************************************************************************/ 1102 //V4L2_PIX_FMT_MJPEG; V4L2_PIX_FMT_YUYV; V4L2_PIX_FMT_H264 = 0x34363248; 1103 camHal->captureFormat = V4L2_PIX_FMT_YUYV; 1104 if(camHal->prevWidth > 640){ 1105 if(1 == mjpegSupported) 1106 camHal->captureFormat = V4L2_PIX_FMT_MJPEG; 1107 else if(1 == h264Supported) 1108 camHal->captureFormat = V4L2_PIX_FMT_H264; 1109 } 1110 ALOGI("%s: Capture format chosen: 0x%x. 0x%x:YUYV. 0x%x:MJPEG. 0x%x: H264", 1111 __func__, camHal->captureFormat, V4L2_PIX_FMT_YUYV, 1112 V4L2_PIX_FMT_MJPEG, V4L2_PIX_FMT_H264); 1113 1114 return camHal->captureFormat; 1115 } 1116 1117 /****************************************************************************** 1118 * Function: getMjpegdOutputFormat 1119 * Description: This function maps display pixel format enum to JPEG output 1120 * format enum 1121 * 1122 * Input parameters: 1123 * dispFormat - Display pixel format 1124 * 1125 * Return values: 1126 * (int)mjpegOutputFormat 1127 * 1128 * Notes: none 1129 *****************************************************************************/ 1130 static int getMjpegdOutputFormat(int dispFormat) 1131 { 1132 int mjpegOutputFormat = YCRCBLP_H2V2; 1133 1134 if(HAL_PIXEL_FORMAT_YCrCb_420_SP == dispFormat) 1135 mjpegOutputFormat = YCRCBLP_H2V2; 1136 1137 return mjpegOutputFormat; 1138 } 1139 1140 /****************************************************************************** 1141 * Function: ioctlLoop 1142 * Description: This function is a blocking call around ioctl 1143 * 1144 * Input parameters: 1145 * fd - IOCTL fd 1146 * ioctlCmd - IOCTL command 1147 * args - IOCTL arguments 1148 * 1149 * Return values: 1150 * (int)mjpegOutputFormat 1151 * 1152 * Notes: none 1153 *****************************************************************************/ 1154 static int ioctlLoop(int fd, int ioctlCmd, void *args) 1155 { 1156 int rc = -1; 1157 1158 while(1) 1159 { 1160 rc = ioctl(fd, ioctlCmd, args); 1161 if(!((-1 == rc) && (EINTR == errno))) 1162 break; 1163 } 1164 return rc; 1165 } 1166 1167 /****************************************************************************** 1168 * Function: initV4L2mmap 1169 * Description: This function requests for V4L2 driver allocated buffers 1170 * 1171 * Input parameters: 1172 * camHal - camera HAL handle 1173 * 1174 * Return values: 1175 * 0 No error 1176 * -1 Error 1177 * 1178 * Notes: none 1179 *****************************************************************************/ 1180 static int initV4L2mmap(camera_hardware_t *camHal) 1181 { 1182 int rc = -1; 1183 struct v4l2_requestbuffers reqBufs; 1184 struct v4l2_buffer tempBuf; 1185 1186 ALOGD("%s: E", __func__); 1187 memset(&reqBufs, 0, sizeof(v4l2_requestbuffers)); 1188 reqBufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1189 reqBufs.memory = V4L2_MEMORY_MMAP; 1190 reqBufs.count = PRVW_CAP_BUF_CNT; 1191 1192 if (-1 == ioctlLoop(camHal->fd, VIDIOC_REQBUFS, &reqBufs)) { 1193 if (EINVAL == errno) { 1194 ALOGE("%s: does not support memory mapping\n", __func__); 1195 } else { 1196 ALOGE("%s: VIDIOC_REQBUFS failed", __func__); 1197 } 1198 } 1199 ALOGD("%s: VIDIOC_REQBUFS success", __func__); 1200 1201 if (reqBufs.count < PRVW_CAP_BUF_CNT) { 1202 ALOGE("%s: Insufficient buffer memory on\n", __func__); 1203 } 1204 1205 camHal->buffers = 1206 ( bufObj* ) calloc(reqBufs.count, sizeof(bufObj)); 1207 1208 if (!camHal->buffers) { 1209 ALOGE("%s: Out of memory\n", __func__); 1210 } 1211 1212 /* Store the indexes in the context. Useful during releasing */ 1213 for (camHal->n_buffers = 0; 1214 camHal->n_buffers < reqBufs.count; 1215 camHal->n_buffers++) { 1216 1217 memset(&tempBuf, 0, sizeof(tempBuf)); 1218 1219 tempBuf.index = camHal->n_buffers; 1220 tempBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1221 tempBuf.memory = V4L2_MEMORY_MMAP; 1222 1223 if (-1 == ioctlLoop(camHal->fd, VIDIOC_QUERYBUF, &tempBuf)) 1224 ALOGE("%s: VIDIOC_QUERYBUF failed", __func__); 1225 1226 ALOGD("%s: VIDIOC_QUERYBUF success", __func__); 1227 1228 camHal->buffers[camHal->n_buffers].len = tempBuf.length; 1229 camHal->buffers[camHal->n_buffers].data = 1230 mmap(NULL /* start anywhere */, 1231 tempBuf.length, 1232 PROT_READ | PROT_WRITE, 1233 MAP_SHARED, 1234 camHal->fd, tempBuf.m.offset); 1235 1236 if (MAP_FAILED == camHal->buffers[camHal->n_buffers].data) 1237 ALOGE("%s: mmap failed", __func__); 1238 } 1239 ALOGD("%s: X", __func__); 1240 return 0; 1241 } 1242 1243 /****************************************************************************** 1244 * Function: unInitV4L2mmap 1245 * Description: This function unmaps the V4L2 driver buffers 1246 * 1247 * Input parameters: 1248 * camHal - camera HAL handle 1249 * 1250 * Return values: 1251 * 0 No error 1252 * -1 Error 1253 * 1254 * Notes: none 1255 *****************************************************************************/ 1256 static int unInitV4L2mmap(camera_hardware_t *camHal) 1257 { 1258 int i, rc = 0; 1259 ALOGD("%s: E", __func__); 1260 1261 for (i = 0; i < camHal->n_buffers; i++) 1262 if (-1 == munmap(camHal->buffers[i].data, camHal->buffers[i].len)){ 1263 ALOGE("%s: munmap failed for buffer: %d", __func__, i); 1264 rc = -1; 1265 } 1266 1267 ALOGD("%s: X", __func__); 1268 return rc; 1269 } 1270 1271 /****************************************************************************** 1272 * Function: initUsbCamera 1273 * Description: This function sets the resolution and pixel format of the 1274 * USB camera 1275 * 1276 * Input parameters: 1277 * camHal - camera HAL handle 1278 * width - picture width in pixels 1279 * height - picture height in pixels 1280 * pixelFormat - capture format for the camera 1281 * 1282 * Return values: 1283 * 0 No error 1284 * -1 Error 1285 * 1286 * Notes: none 1287 *****************************************************************************/ 1288 static int initUsbCamera(camera_hardware_t *camHal, int width, int height, 1289 int pixelFormat) 1290 { 1291 int rc = -1; 1292 struct v4l2_capability cap; 1293 struct v4l2_cropcap cropcap; 1294 struct v4l2_crop crop; 1295 struct v4l2_format v4l2format; 1296 unsigned int min; 1297 1298 ALOGI("%s: E", __func__); 1299 1300 if (-1 == ioctlLoop(camHal->fd, VIDIOC_QUERYCAP, &cap)) { 1301 if (EINVAL == errno) { 1302 ALOGE( "%s: This is not V4L2 device\n", __func__); 1303 return -1; 1304 } else { 1305 ALOGE("%s: VIDIOC_QUERYCAP errno: %d", __func__, errno); 1306 } 1307 } 1308 ALOGD("%s: VIDIOC_QUERYCAP success", __func__); 1309 1310 if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { 1311 ALOGE("%s: This is not video capture device\n", __func__); 1312 return -1; 1313 } 1314 1315 if (!(cap.capabilities & V4L2_CAP_STREAMING)) { 1316 ALOGE("%s: This does not support streaming i/o\n", __func__); 1317 return -1; 1318 } 1319 1320 /* Select video input, video standard and tune here. */ 1321 memset(&cropcap, 0, sizeof(cropcap)); 1322 1323 cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1324 1325 if (0 == ioctlLoop(camHal->fd, VIDIOC_CROPCAP, &cropcap)) { 1326 1327 /* reset to default */ 1328 crop.c = cropcap.defrect; 1329 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1330 1331 ALOGD("%s: VIDIOC_CROPCAP success", __func__); 1332 if (-1 == ioctlLoop(camHal->fd, VIDIOC_S_CROP, &crop)) { 1333 switch (errno) { 1334 case EINVAL: 1335 /* Cropping not supported. */ 1336 break; 1337 default: 1338 /* Errors ignored. */ 1339 break; 1340 } 1341 } 1342 ALOGD("%s: VIDIOC_S_CROP success", __func__); 1343 1344 } else { 1345 /* Errors ignored. */ 1346 ALOGE("%s: VIDIOC_S_CROP failed", __func__); 1347 } 1348 1349 1350 memset(&v4l2format, 0, sizeof(v4l2format)); 1351 1352 v4l2format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1353 { 1354 v4l2format.fmt.pix.field = V4L2_FIELD_NONE; 1355 v4l2format.fmt.pix.pixelformat = pixelFormat; 1356 v4l2format.fmt.pix.width = width; 1357 v4l2format.fmt.pix.height = height; 1358 1359 if (-1 == ioctlLoop(camHal->fd, VIDIOC_S_FMT, &v4l2format)) 1360 { 1361 ALOGE("%s: VIDIOC_S_FMT failed", __func__); 1362 return -1; 1363 } 1364 ALOGD("%s: VIDIOC_S_FMT success", __func__); 1365 1366 /* Note VIDIOC_S_FMT may change width and height. */ 1367 } 1368 1369 /* TBR: In case of user pointer buffers, v4l2format.fmt.pix.sizeimage */ 1370 /* might have to be calculated as per V4L2 sample application due to */ 1371 /* open source driver bug */ 1372 1373 rc = initV4L2mmap(camHal); 1374 ALOGI("%s: X", __func__); 1375 return rc; 1376 } 1377 1378 /****************************************************************************** 1379 * Function: startUsbCamCapture 1380 * Description: This function queues buffer objects to the driver and sends 1381 * STREAM ON command to the USB camera driver 1382 * 1383 * Input parameters: 1384 * camHal - camera HAL handle 1385 * 1386 * Return values: 1387 * 0 No error 1388 * -1 Error 1389 * 1390 * Notes: none 1391 *****************************************************************************/ 1392 static int startUsbCamCapture(camera_hardware_t *camHal) 1393 { 1394 int rc = -1; 1395 unsigned int i; 1396 enum v4l2_buf_type v4l2BufType; 1397 ALOGD("%s: E", __func__); 1398 1399 for (i = 0; i < camHal->n_buffers; ++i) { 1400 struct v4l2_buffer tempBuf; 1401 1402 memset(&tempBuf, 0, sizeof(tempBuf)); 1403 tempBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1404 tempBuf.memory = V4L2_MEMORY_MMAP; 1405 tempBuf.index = i; 1406 1407 if (-1 == ioctlLoop(camHal->fd, VIDIOC_QBUF, &tempBuf)) 1408 ALOGE("%s: VIDIOC_QBUF for %d buffer failed", __func__, i); 1409 else 1410 ALOGD("%s: VIDIOC_QBUF for %d buffer success", __func__, i); 1411 } 1412 1413 v4l2BufType = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1414 if (-1 == ioctlLoop(camHal->fd, VIDIOC_STREAMON, &v4l2BufType)) 1415 ALOGE("%s: VIDIOC_STREAMON failed", __func__); 1416 else 1417 { 1418 ALOGD("%s: VIDIOC_STREAMON success", __func__); 1419 rc = 0; 1420 } 1421 1422 ALOGD("%s: X", __func__); 1423 return rc; 1424 } 1425 1426 /****************************************************************************** 1427 * Function: stopUsbCamCapture 1428 * Description: This function sends STREAM OFF command to the USB camera driver 1429 * 1430 * Input parameters: 1431 * camHal - camera HAL handle 1432 * 1433 * Return values: 1434 * 0 No error 1435 * -1 Error 1436 * 1437 * Notes: none 1438 *****************************************************************************/ 1439 static int stopUsbCamCapture(camera_hardware_t *camHal) 1440 { 1441 int rc = -1; 1442 unsigned int i; 1443 enum v4l2_buf_type v4l2BufType; 1444 ALOGD("%s: E", __func__); 1445 1446 if(!camHal->fd){ 1447 ALOGE("%s: camHal->fd = NULL ", __func__); 1448 return -1; 1449 } 1450 v4l2BufType = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1451 if (-1 == ioctlLoop(camHal->fd, VIDIOC_STREAMOFF, &v4l2BufType)){ 1452 ALOGE("%s: VIDIOC_STREAMOFF failed", __func__); 1453 rc = -1; 1454 }else{ 1455 ALOGD("%s: VIDIOC_STREAMOFF success", __func__); 1456 rc = 0; 1457 } 1458 1459 ALOGD("%s: X", __func__); 1460 return rc; 1461 } 1462 1463 /****************************************************************************** 1464 * Function: stopPreviewInternal 1465 * Description: This function sends EXIT command to prview loop thread, 1466 * stops usb camera capture and uninitializes MMAP. This function 1467 * assumes that calling function has locked camHal->lock 1468 * 1469 * Input parameters: 1470 * camHal - camera HAL handle 1471 * 1472 * Return values: 1473 * 0 No error 1474 * -1 Error 1475 * 1476 * Notes: none 1477 *****************************************************************************/ 1478 static int stopPreviewInternal(camera_hardware_t *camHal) 1479 { 1480 int rc = 0; 1481 ALOGD("%s: E", __func__); 1482 1483 if(camHal->previewEnabledFlag) 1484 { 1485 camHal->prvwCmdPending++; 1486 camHal->prvwCmd = USB_CAM_PREVIEW_EXIT; 1487 1488 /* yield lock while waiting for the preview thread to exit */ 1489 camHal->lock.unlock(); 1490 if(pthread_join(camHal->previewThread, NULL)){ 1491 ALOGE("%s: Error in pthread_join preview thread", __func__); 1492 } 1493 camHal->lock.lock(); 1494 1495 if(stopUsbCamCapture(camHal)){ 1496 ALOGE("%s: Error in stopUsbCamCapture", __func__); 1497 rc = -1; 1498 } 1499 if(unInitV4L2mmap(camHal)){ 1500 ALOGE("%s: Error in stopUsbCamCapture", __func__); 1501 rc = -1; 1502 } 1503 camHal->previewEnabledFlag = 0; 1504 } 1505 1506 ALOGD("%s: X, rc: %d", __func__, rc); 1507 return rc; 1508 } 1509 #if 1 1510 /****************************************************************************** 1511 * Function: prvwThreadTakePictureInternal 1512 * Description: This function processes one camera frame to get JPEG encoded 1513 * picture. 1514 * 1515 * Input parameters: 1516 * camHal - camera HAL handle 1517 * 1518 * Return values: 1519 * 0 No error 1520 * -1 Error 1521 * 1522 * Notes: none 1523 *****************************************************************************/ 1524 static int prvwThreadTakePictureInternal(camera_hardware_t *camHal) 1525 { 1526 int rc = 0; 1527 QCameraHalMemInfo_t *mem_info; 1528 ALOGD("%s: E", __func__); 1529 1530 /************************************************************************/ 1531 /* - If requested for shutter notfication, callback */ 1532 /* - Dequeue capture buffer from USB camera */ 1533 /* - Send capture buffer to JPEG encoder for JPEG compression */ 1534 /* - If jpeg frames callback is requested, callback with jpeg buffers */ 1535 /* - Enqueue capture buffer back to USB camera */ 1536 /************************************************************************/ 1537 1538 /************************************************************************/ 1539 /* - If requested for shutter notfication, callback */ 1540 /************************************************************************/ 1541 if (camHal->msgEnabledFlag & CAMERA_MSG_SHUTTER){ 1542 camHal->lock.unlock(); 1543 camHal->notify_cb(CAMERA_MSG_SHUTTER, 0, 0, camHal->cb_ctxt); 1544 camHal->lock.lock(); 1545 } 1546 1547 #if CAPTURE 1548 /************************************************************************/ 1549 /* - Dequeue capture buffer from USB camera */ 1550 /************************************************************************/ 1551 if (0 == get_buf_from_cam(camHal)) 1552 ALOGD("%s: get_buf_from_cam success", __func__); 1553 else 1554 ALOGE("%s: get_buf_from_cam error", __func__); 1555 #endif 1556 1557 /************************************************************************/ 1558 /* - Send capture buffer to JPEG encoder for JPEG compression */ 1559 /************************************************************************/ 1560 /* Optimization: If camera capture is JPEG format, need not compress! */ 1561 /* instead, just data copy from capture buffer to picture buffer */ 1562 if(V4L2_PIX_FMT_MJPEG == camHal->captureFormat){ 1563 /* allocate heap memory for JPEG output */ 1564 mem_info = &camHal->pictMem.mem_info[0]; 1565 mem_info->size = camHal->curCaptureBuf.bytesused; 1566 /* TBD: allocate_ion_memory 1567 rc = QCameraHardwareInterface::allocate_ion_memory(mem_info, 1568 ((0x1 << CAMERA_ZSL_ION_HEAP_ID) | 1569 (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID))); 1570 */ 1571 if(rc) 1572 ALOGE("%s: ION memory allocation failed", __func__); 1573 1574 camHal->pictMem.camera_memory[0] = camHal->get_memory( 1575 mem_info->fd, mem_info->size, 1, camHal->cb_ctxt); 1576 if(!camHal->pictMem.camera_memory[0]) 1577 ALOGE("%s: get_mem failed", __func__); 1578 1579 memcpy( camHal->pictMem.camera_memory[0]->data, 1580 (char *)camHal->buffers[camHal->curCaptureBuf.index].data, 1581 camHal->curCaptureBuf.bytesused); 1582 } 1583 1584 /************************************************************************/ 1585 /* - If jpeg frames callback is requested, callback with jpeg buffers */ 1586 /************************************************************************/ 1587 if ((camHal->msgEnabledFlag & CAMERA_MSG_COMPRESSED_IMAGE) && 1588 (camHal->data_cb)){ 1589 camHal->lock.unlock(); 1590 camHal->data_cb(CAMERA_MSG_COMPRESSED_IMAGE, 1591 camHal->pictMem.camera_memory[0], 1592 0, NULL, camHal->cb_ctxt); 1593 camHal->lock.lock(); 1594 } 1595 /* release heap memory after the call back */ 1596 if(camHal->pictMem.camera_memory[0]) 1597 camHal->pictMem.camera_memory[0]->release( 1598 camHal->pictMem.camera_memory[0]); 1599 1600 /* TBD: deallocate_ion_memory */ 1601 //rc = QCameraHardwareInterface::deallocate_ion_memory(mem_info); 1602 if(rc) 1603 ALOGE("%s: ION memory de-allocation failed", __func__); 1604 1605 #if CAPTURE 1606 /************************************************************************/ 1607 /* - Enqueue capture buffer back to USB camera */ 1608 /************************************************************************/ 1609 if(0 == put_buf_to_cam(camHal)) { 1610 ALOGD("%s: put_buf_to_cam success", __func__); 1611 } 1612 else 1613 ALOGE("%s: put_buf_to_cam error", __func__); 1614 #endif 1615 1616 ALOGD("%s: X, rc: %d", __func__, rc); 1617 return rc; 1618 } 1619 #endif //#if 0 1620 /****************************************************************************** 1621 * Function: cache_ops 1622 * Description: This function calls ION ioctl for cache related operations 1623 * 1624 * Input parameters: 1625 * mem_info - QCameraHalMemInfo_t structure with ION info 1626 * buf_ptr - Buffer pointer that needs to be cache operated 1627 * cmd - Cache command - clean/invalidate 1628 * 1629 * Return values: 1630 * MM_CAMERA_OK No error 1631 * -1 Error 1632 * 1633 * Notes: none 1634 *****************************************************************************/ 1635 int cache_ops(QCameraHalMemInfo_t *mem_info, 1636 void *buf_ptr, 1637 unsigned int cmd) 1638 { 1639 struct ion_flush_data cache_inv_data; 1640 struct ion_custom_data custom_data; 1641 int ret = MM_CAMERA_OK; 1642 1643 #ifdef USE_ION 1644 if (NULL == mem_info) { 1645 ALOGE("%s: mem_info is NULL, return here", __func__); 1646 return -1; 1647 } 1648 1649 memset(&cache_inv_data, 0, sizeof(cache_inv_data)); 1650 memset(&custom_data, 0, sizeof(custom_data)); 1651 cache_inv_data.vaddr = buf_ptr; 1652 cache_inv_data.fd = mem_info->fd; 1653 cache_inv_data.handle = mem_info->handle; 1654 cache_inv_data.length = mem_info->size; 1655 custom_data.cmd = cmd; 1656 custom_data.arg = (unsigned long)&cache_inv_data; 1657 1658 ALOGD("%s: addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d", 1659 __func__, cache_inv_data.vaddr, cache_inv_data.fd, 1660 cache_inv_data.handle, cache_inv_data.length, 1661 mem_info->main_ion_fd); 1662 if(mem_info->main_ion_fd > 0) { 1663 if(ioctl(mem_info->main_ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) { 1664 ALOGE("%s: Cache Invalidate failed\n", __func__); 1665 ret = -1; 1666 } 1667 } 1668 #endif 1669 1670 return ret; 1671 } 1672 1673 /****************************************************************************** 1674 * Function: get_buf_from_cam 1675 * Description: This funtions gets/acquires 1 capture buffer from the camera 1676 * driver. The fetched buffer is stored in curCaptureBuf 1677 * 1678 * Input parameters: 1679 * camHal - camera HAL handle 1680 * 1681 * Return values: 1682 * 0 No error 1683 * -1 Error 1684 * 1685 * Notes: none 1686 *****************************************************************************/ 1687 static int get_buf_from_cam(camera_hardware_t *camHal) 1688 { 1689 int rc = -1; 1690 1691 ALOGD("%s: E", __func__); 1692 { 1693 memset(&camHal->curCaptureBuf, 0, sizeof(camHal->curCaptureBuf)); 1694 1695 camHal->curCaptureBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1696 camHal->curCaptureBuf.memory = V4L2_MEMORY_MMAP; 1697 1698 if (-1 == ioctlLoop(camHal->fd, VIDIOC_DQBUF, &camHal->curCaptureBuf)){ 1699 switch (errno) { 1700 case EAGAIN: 1701 ALOGE("%s: EAGAIN error", __func__); 1702 return 1; 1703 1704 case EIO: 1705 /* Could ignore EIO, see spec. */ 1706 1707 [[fallthrough]]; 1708 1709 default: 1710 ALOGE("%s: VIDIOC_DQBUF error", __func__); 1711 } 1712 } 1713 else 1714 { 1715 rc = 0; 1716 ALOGD("%s: VIDIOC_DQBUF: %d successful, %d bytes", 1717 __func__, camHal->curCaptureBuf.index, 1718 camHal->curCaptureBuf.bytesused); 1719 } 1720 } 1721 ALOGD("%s: X", __func__); 1722 return rc; 1723 } 1724 1725 /****************************************************************************** 1726 * Function: put_buf_to_cam 1727 * Description: This funtion puts/releases 1 capture buffer back to the camera 1728 * driver 1729 * 1730 * Input parameters: 1731 * camHal - camera HAL handle 1732 * 1733 * Return values: 1734 * 0 No error 1735 * -1 Error 1736 * 1737 * Notes: none 1738 *****************************************************************************/ 1739 static int put_buf_to_cam(camera_hardware_t *camHal) 1740 { 1741 ALOGD("%s: E", __func__); 1742 1743 camHal->curCaptureBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1744 camHal->curCaptureBuf.memory = V4L2_MEMORY_MMAP; 1745 1746 1747 if (-1 == ioctlLoop(camHal->fd, VIDIOC_QBUF, &camHal->curCaptureBuf)) 1748 { 1749 ALOGE("%s: VIDIOC_QBUF failed ", __func__); 1750 return 1; 1751 } 1752 ALOGD("%s: X", __func__); 1753 return 0; 1754 } 1755 1756 /****************************************************************************** 1757 * Function: put_buf_to_cam 1758 * Description: This funtion gets/acquires 1 display buffer from the display 1759 * window 1760 * 1761 * Input parameters: 1762 * camHal - camera HAL handle 1763 * buffer_id - Buffer id pointer. The id of buffer obtained 1764 * by this function is returned in this arg 1765 * 1766 * Return values: 1767 * 0 No error 1768 * -1 Error 1769 * 1770 * Notes: none 1771 *****************************************************************************/ 1772 static int get_buf_from_display(camera_hardware_t *camHal, int *buffer_id) 1773 { 1774 int err = 0; 1775 preview_stream_ops *mPreviewWindow = NULL; 1776 int stride = 0, cnt = 0; 1777 buffer_handle_t *buffer_handle = NULL; 1778 struct private_handle_t *private_buffer_handle = NULL; 1779 1780 ALOGD("%s: E", __func__); 1781 1782 if (camHal == NULL) { 1783 ALOGE("%s: camHal = NULL", __func__); 1784 return -1; 1785 } 1786 1787 mPreviewWindow = camHal->window; 1788 if( mPreviewWindow == NULL) { 1789 ALOGE("%s: mPreviewWindow = NULL", __func__); 1790 return -1; 1791 } 1792 err = mPreviewWindow->dequeue_buffer(mPreviewWindow, 1793 &buffer_handle, 1794 &stride); 1795 if(!err) { 1796 ALOGD("%s: dequeue buf buffer_handle: %p\n", __func__, buffer_handle); 1797 1798 ALOGD("%s: mPreviewWindow->lock_buffer: %p", 1799 __func__, mPreviewWindow->lock_buffer); 1800 if(mPreviewWindow->lock_buffer) { 1801 err = mPreviewWindow->lock_buffer(mPreviewWindow, buffer_handle); 1802 ALOGD("%s: mPreviewWindow->lock_buffer success", __func__); 1803 } 1804 ALOGD("%s: camera call genlock_lock, hdl=%p", 1805 __func__, (*buffer_handle)); 1806 1807 if (GENLOCK_NO_ERROR != 1808 genlock_lock_buffer((native_handle_t *)(*buffer_handle), 1809 GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT)) { 1810 ALOGE("%s: genlock_lock_buffer(WRITE) failed", __func__); 1811 } else { 1812 ALOGD("%s: genlock_lock_buffer hdl =%p", __func__, *buffer_handle); 1813 } 1814 1815 private_buffer_handle = (struct private_handle_t *)(*buffer_handle); 1816 1817 ALOGD("%s: fd = %d, size = %d, offset = %d, stride = %d", 1818 __func__, private_buffer_handle->fd, 1819 private_buffer_handle->size, private_buffer_handle->offset, stride); 1820 1821 for(cnt = 0; cnt < camHal->previewMem.buffer_count + 2; cnt++) { 1822 if(private_buffer_handle->fd == 1823 camHal->previewMem.private_buffer_handle[cnt]->fd) { 1824 *buffer_id = cnt; 1825 ALOGD("%s: deQueued fd = %d, index: %d", 1826 __func__, private_buffer_handle->fd, cnt); 1827 break; 1828 } 1829 } 1830 } 1831 else 1832 ALOGE("%s: dequeue buf failed \n", __func__); 1833 1834 ALOGD("%s: X", __func__); 1835 1836 return err; 1837 } 1838 1839 /****************************************************************************** 1840 * Function: put_buf_to_display 1841 * Description: This funtion puts/enqueues 1 buffer back to the display window 1842 * 1843 * Input parameters: 1844 * camHal - camera HAL handle 1845 * buffer_id - id of the buffer that needs to be enqueued 1846 * 1847 * Return values: 1848 * 0 No error 1849 * -1 Error 1850 * 1851 * Notes: none 1852 *****************************************************************************/ 1853 static int put_buf_to_display(camera_hardware_t *camHal, int buffer_id) 1854 { 1855 int err = 0; 1856 preview_stream_ops *mPreviewWindow; 1857 1858 ALOGD("%s: E", __func__); 1859 1860 if (camHal == NULL) { 1861 ALOGE("%s: camHal = NULL", __func__); 1862 return -1; 1863 } 1864 1865 mPreviewWindow = camHal->window; 1866 if( mPreviewWindow == NULL) { 1867 ALOGE("%s: mPreviewWindow = NULL", __func__); 1868 return -1; 1869 } 1870 1871 if (GENLOCK_FAILURE == 1872 genlock_unlock_buffer( 1873 (native_handle_t *) 1874 (*(camHal->previewMem.buffer_handle[buffer_id])))) { 1875 ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", 1876 __func__, (*(camHal->previewMem.buffer_handle[buffer_id])) ); 1877 } else { 1878 ALOGD("%s: genlock_unlock_buffer success: hdl =%p", 1879 __func__, (*(camHal->previewMem.buffer_handle[buffer_id])) ); 1880 } 1881 1882 /* Cache clean the output buffer so that cache is written back */ 1883 cache_ops(&camHal->previewMem.mem_info[buffer_id], 1884 (void *)camHal->previewMem.camera_memory[buffer_id]->data, 1885 ION_IOC_CLEAN_CACHES); 1886 /* 1887 cache_ops(&camHal->previewMem.mem_info[buffer_id], 1888 (void *)camHal->previewMem.camera_memory[buffer_id]->data, 1889 ION_IOC_CLEAN_INV_CACHES); 1890 */ 1891 err = mPreviewWindow->enqueue_buffer(mPreviewWindow, 1892 (buffer_handle_t *)camHal->previewMem.buffer_handle[buffer_id]); 1893 if(!err) { 1894 ALOGD("%s: enqueue buf successful: %p\n", 1895 __func__, camHal->previewMem.buffer_handle[buffer_id]); 1896 }else 1897 ALOGE("%s: enqueue buf failed: %p\n", 1898 __func__, camHal->previewMem.buffer_handle[buffer_id]); 1899 1900 ALOGD("%s: X", __func__); 1901 1902 return err; 1903 } 1904 1905 /****************************************************************************** 1906 * Function: put_buf_to_display 1907 * Description: This funtion transfers the content from capture buffer to 1908 * preiew display buffer after appropriate conversion 1909 * 1910 * Input parameters: 1911 * camHal - camera HAL handle 1912 * buffer_id - id of the buffer that needs to be enqueued 1913 * 1914 * Return values: 1915 * 0 No error 1916 * -1 Error 1917 * 1918 * Notes: none 1919 *****************************************************************************/ 1920 static int convert_data_frm_cam_to_disp(camera_hardware_t *camHal, int buffer_id) 1921 { 1922 int rc = -1; 1923 1924 if(!camHal) { 1925 ALOGE("%s: camHal is NULL", __func__); 1926 return -1; 1927 } 1928 /* If input and output are raw formats, but different color format, */ 1929 /* call color conversion routine */ 1930 if( (V4L2_PIX_FMT_YUYV == camHal->captureFormat) && 1931 (HAL_PIXEL_FORMAT_YCrCb_420_SP == camHal->dispFormat)) 1932 { 1933 convert_YUYV_to_420_NV12( 1934 (char *)camHal->buffers[camHal->curCaptureBuf.index].data, 1935 (char *)camHal->previewMem.camera_memory[buffer_id]->data, 1936 camHal->prevWidth, 1937 camHal->prevHeight); 1938 ALOGD("%s: Copied %d bytes from camera buffer %d to display buffer: %d", 1939 __func__, camHal->curCaptureBuf.bytesused, 1940 camHal->curCaptureBuf.index, buffer_id); 1941 rc = 0; 1942 } 1943 1944 /* If camera buffer is MJPEG encoded, call mjpeg decode call */ 1945 if(V4L2_PIX_FMT_MJPEG == camHal->captureFormat) 1946 { 1947 if(NULL == camHal->mjpegd) 1948 { 1949 rc = mjpegDecoderInit(&camHal->mjpegd); 1950 if(rc < 0) 1951 ALOGE("%s: mjpegDecoderInit Error: %d", __func__, rc); 1952 } 1953 if(camHal->mjpegd) 1954 { 1955 rc = mjpegDecode( 1956 (void*)camHal->mjpegd, 1957 (char *)camHal->buffers[camHal->curCaptureBuf.index].data, 1958 camHal->curCaptureBuf.bytesused, 1959 (char *)camHal->previewMem.camera_memory[buffer_id]->data, 1960 (char *)camHal->previewMem.camera_memory[buffer_id]->data + 1961 camHal->prevWidth * camHal->prevHeight, 1962 getMjpegdOutputFormat(camHal->dispFormat)); 1963 if(rc < 0) 1964 ALOGE("%s: mjpegDecode Error: %d", __func__, rc); 1965 } 1966 } 1967 return rc; 1968 } 1969 1970 /****************************************************************************** 1971 * Function: launch_preview_thread 1972 * Description: This is a wrapper function to start preview thread 1973 * 1974 * Input parameters: 1975 * camHal - camera HAL handle 1976 * 1977 * Return values: 1978 * 0 No error 1979 * -1 Error 1980 * 1981 * Notes: none 1982 *****************************************************************************/ 1983 static int launch_preview_thread(camera_hardware_t *camHal) 1984 { 1985 ALOGD("%s: E", __func__); 1986 int rc = 0; 1987 1988 if(!camHal) { 1989 ALOGE("%s: camHal is NULL", __func__); 1990 return -1; 1991 } 1992 1993 pthread_attr_t attr; 1994 pthread_attr_init(&attr); 1995 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 1996 pthread_create(&camHal->previewThread, &attr, previewloop, camHal); 1997 1998 ALOGD("%s: X", __func__); 1999 return rc; 2000 } 2001 2002 /****************************************************************************** 2003 * Function: launch_preview_thread 2004 * Description: This is thread funtion for preivew loop 2005 * 2006 * Input parameters: 2007 * hcamHal - camera HAL handle 2008 * 2009 * Return values: 2010 * 0 No error 2011 * -1 Error 2012 * 2013 * Notes: none 2014 *****************************************************************************/ 2015 static void * previewloop(void *hcamHal) 2016 { 2017 int rc; 2018 int buffer_id = 0; 2019 pid_t tid = 0; 2020 camera_hardware_t *camHal = NULL; 2021 int msgType = 0; 2022 camera_memory_t *data = NULL; 2023 camera_frame_metadata_t *metadata= NULL; 2024 camera_memory_t *previewMem = NULL; 2025 2026 camHal = (camera_hardware_t *)hcamHal; 2027 ALOGD("%s: E", __func__); 2028 2029 if(!camHal) { 2030 ALOGE("%s: camHal is NULL", __func__); 2031 return NULL ; 2032 } 2033 2034 tid = gettid(); 2035 /* TBR: Set appropriate thread priority */ 2036 androidSetThreadPriority(tid, ANDROID_PRIORITY_NORMAL); 2037 prctl(PR_SET_NAME, (unsigned long)"Camera HAL preview thread", 0, 0, 0); 2038 2039 /************************************************************************/ 2040 /* - Time wait (select) on camera fd for input read buffer */ 2041 /* - Check if any preview thread commands are set. If set, process */ 2042 /* - Dequeue display buffer from surface */ 2043 /* - Dequeue capture buffer from USB camera */ 2044 /* - Convert capture format to display format */ 2045 /* - If preview frames callback is requested, callback with prvw buffers*/ 2046 /* - Enqueue display buffer back to surface */ 2047 /* - Enqueue capture buffer back to USB camera */ 2048 /************************************************************************/ 2049 while(1) { 2050 fd_set fds; 2051 struct timeval tv; 2052 int r = 0; 2053 2054 FD_ZERO(&fds); 2055 #if CAPTURE 2056 FD_SET(camHal->fd, &fds); 2057 #endif /* CAPTURE */ 2058 2059 /************************************************************************/ 2060 /* - Time wait (select) on camera fd for input read buffer */ 2061 /************************************************************************/ 2062 tv.tv_sec = 0; 2063 tv.tv_usec = 500000; 2064 2065 ALOGD("%s: b4 select on camHal->fd + 1,fd: %d", __func__, camHal->fd); 2066 #if CAPTURE 2067 r = select(camHal->fd + 1, &fds, NULL, NULL, &tv); 2068 #else 2069 r = select(1, NULL, NULL, NULL, &tv); 2070 #endif /* CAPTURE */ 2071 ALOGD("%s: after select : %d", __func__, camHal->fd); 2072 2073 if (-1 == r) { 2074 if (EINTR == errno) 2075 continue; 2076 ALOGE("%s: FDSelect error: %d", __func__, errno); 2077 } 2078 2079 if (0 == r) { 2080 ALOGD("%s: select timeout\n", __func__); 2081 } 2082 2083 /* Protect the context for one iteration of preview loop */ 2084 /* this gets unlocked at the end of the while */ 2085 Mutex::Autolock autoLock(camHal->lock); 2086 2087 /************************************************************************/ 2088 /* - Check if any preview thread commands are set. If set, process */ 2089 /************************************************************************/ 2090 if(camHal->prvwCmdPending) 2091 { 2092 /* command is serviced. Hence command pending = 0 */ 2093 camHal->prvwCmdPending--; 2094 //sempost(ack) 2095 if(USB_CAM_PREVIEW_EXIT == camHal->prvwCmd){ 2096 /* unlock before exiting the thread */ 2097 camHal->lock.unlock(); 2098 ALOGI("%s: Exiting coz USB_CAM_PREVIEW_EXIT", __func__); 2099 return (void *)0; 2100 }else if(USB_CAM_PREVIEW_TAKEPIC == camHal->prvwCmd){ 2101 rc = prvwThreadTakePictureInternal(camHal); 2102 if(rc) 2103 ALOGE("%s: prvwThreadTakePictureInternal returned error", 2104 __func__); 2105 } 2106 } 2107 2108 /* Null check on preview window. If null, sleep */ 2109 if(!camHal->window) { 2110 ALOGD("%s: sleeping coz camHal->window = NULL",__func__); 2111 camHal->lock.unlock(); 2112 sleep(2); 2113 continue; 2114 } 2115 #if DISPLAY 2116 /************************************************************************/ 2117 /* - Dequeue display buffer from surface */ 2118 /************************************************************************/ 2119 if(0 == get_buf_from_display(camHal, &buffer_id)) { 2120 ALOGD("%s: get_buf_from_display success: %d", 2121 __func__, buffer_id); 2122 }else{ 2123 ALOGE("%s: get_buf_from_display failed. Skipping the loop", 2124 __func__); 2125 continue; 2126 } 2127 #endif 2128 2129 #if CAPTURE 2130 /************************************************************************/ 2131 /* - Dequeue capture buffer from USB camera */ 2132 /************************************************************************/ 2133 if (0 == get_buf_from_cam(camHal)) 2134 ALOGD("%s: get_buf_from_cam success", __func__); 2135 else 2136 ALOGE("%s: get_buf_from_cam error", __func__); 2137 #endif 2138 2139 #if FILE_DUMP_CAMERA 2140 /* Debug code to dump frames from camera */ 2141 { 2142 static int frame_cnt = 0; 2143 /* currently hardcoded for Bytes-Per-Pixel = 1.5 */ 2144 fileDump("/data/USBcam.yuv", 2145 (char*)camHal->buffers[camHal->curCaptureBuf.index].data, 2146 camHal->prevWidth * camHal->prevHeight * 1.5, 2147 &frame_cnt); 2148 } 2149 #endif 2150 2151 #if MEMSET 2152 static int color = 30; 2153 color += 50; 2154 if(color > 200) { 2155 color = 30; 2156 } 2157 ALOGE("%s: Setting to the color: %d\n", __func__, color); 2158 /* currently hardcoded for format of type Bytes-Per-Pixel = 1.5 */ 2159 memset(camHal->previewMem.camera_memory[buffer_id]->data, 2160 color, camHal->dispWidth * camHal->dispHeight * 1.5 + 2 * 1024); 2161 #else 2162 convert_data_frm_cam_to_disp(camHal, buffer_id); 2163 ALOGD("%s: Copied data to buffer_id: %d", __func__, buffer_id); 2164 #endif 2165 2166 #if FILE_DUMP_B4_DISP 2167 /* Debug code to dump display buffers */ 2168 { 2169 static int frame_cnt = 0; 2170 /* currently hardcoded for Bytes-Per-Pixel = 1.5 */ 2171 fileDump("/data/display.yuv", 2172 (char*) camHal->previewMem.camera_memory[buffer_id]->data, 2173 camHal->dispWidth * camHal->dispHeight * 1.5, 2174 &frame_cnt); 2175 ALOGD("%s: Written buf_index: %d ", __func__, buffer_id); 2176 } 2177 #endif 2178 2179 #if DISPLAY 2180 /************************************************************************/ 2181 /* - Enqueue display buffer back to surface */ 2182 /************************************************************************/ 2183 if(0 == put_buf_to_display(camHal, buffer_id)) { 2184 ALOGD("%s: put_buf_to_display success: %d", __func__, buffer_id); 2185 } 2186 else 2187 ALOGE("%s: put_buf_to_display error", __func__); 2188 #endif 2189 2190 #if CAPTURE 2191 /************************************************************************/ 2192 /* - Enqueue capture buffer back to USB camera */ 2193 /************************************************************************/ 2194 if(0 == put_buf_to_cam(camHal)) { 2195 ALOGD("%s: put_buf_to_cam success", __func__); 2196 } 2197 else 2198 ALOGE("%s: put_buf_to_cam error", __func__); 2199 #endif 2200 2201 #if CALL_BACK 2202 /************************************************************************/ 2203 /* - If preview frames callback is requested, callback with prvw buffers*/ 2204 /************************************************************************/ 2205 /* TBD: change the 1.5 hardcoding to Bytes Per Pixel */ 2206 int previewBufSize = camHal->prevWidth * camHal->prevHeight * 1.5; 2207 2208 msgType |= CAMERA_MSG_PREVIEW_FRAME; 2209 2210 if(previewBufSize != 2211 camHal->previewMem.private_buffer_handle[buffer_id]->size) { 2212 2213 previewMem = camHal->get_memory( 2214 camHal->previewMem.private_buffer_handle[buffer_id]->fd, 2215 previewBufSize, 2216 1, 2217 camHal->cb_ctxt); 2218 2219 if (!previewMem || !previewMem->data) { 2220 ALOGE("%s: get_memory failed.\n", __func__); 2221 } 2222 else { 2223 data = previewMem; 2224 ALOGD("%s: GetMemory successful. data = %p", 2225 __func__, data); 2226 ALOGD("%s: previewBufSize = %d, priv_buf_size: %d", 2227 __func__, previewBufSize, 2228 camHal->previewMem.private_buffer_handle[buffer_id]->size); 2229 } 2230 } 2231 else{ 2232 data = camHal->previewMem.camera_memory[buffer_id]; 2233 ALOGD("%s: No GetMemory, no invalid fmt. data = %p, idx=%d", 2234 __func__, data, buffer_id); 2235 } 2236 /* Unlock and lock around the callback. */ 2237 /* Sometimes 'disable_msg' is issued in the callback context, */ 2238 /* leading to deadlock */ 2239 camHal->lock.unlock(); 2240 if((camHal->msgEnabledFlag & CAMERA_MSG_PREVIEW_FRAME) && 2241 camHal->data_cb){ 2242 ALOGD("%s: before data callback", __func__); 2243 camHal->data_cb(msgType, data, 0,metadata, camHal->cb_ctxt); 2244 ALOGD("%s: after data callback: %p", __func__, camHal->data_cb); 2245 } 2246 camHal->lock.lock(); 2247 if (previewMem) 2248 previewMem->release(previewMem); 2249 #endif 2250 2251 }//while(1) 2252 ALOGD("%s: X", __func__); 2253 return (void *)0; 2254 } 2255 2256 /****************************************************************************** 2257 * Function: get_uvc_device 2258 * Description: This function loops through /dev/video entries and probes with 2259 * UVCIOC query. If the device responds to the query, then it is 2260 * detected as UVC webcam 2261 * Input parameters: 2262 * devname - String pointer. The function return dev entry 2263 * name in this string 2264 * Return values: 2265 * 0 Success 2266 * -1 Error 2267 * Notes: none 2268 *****************************************************************************/ 2269 static int get_uvc_device(char *devname) 2270 { 2271 char temp_devname[FILENAME_LENGTH]; 2272 FILE *fp = NULL; 2273 int i = 0, ret = 0, fd; 2274 2275 ALOGD("%s: E", __func__); 2276 #if 1 2277 strncpy(devname, "/dev/video1", FILENAME_LENGTH); 2278 2279 /* 2280 struct stat st; 2281 2282 strncpy(dev_name, "/dev/video1", FILENAME_LENGTH); 2283 if (-1 == stat(dev_name, &st)) { 2284 ALOGE("%s: Cannot identify '%s': %d, %s\n", 2285 __func__, dev_name, errno, strerror(errno)); 2286 } 2287 2288 if (!S_ISCHR(st.st_mode)) { 2289 ALOGE("%s: %s is no device\n", __func__, dev_name); 2290 rc = -1; 2291 } 2292 */ 2293 2294 #else 2295 2296 *devname = '\0'; 2297 /************************************************************************/ 2298 /* - List all /dev/video* entries to a file */ 2299 /* - Open the video list file and loop through the list */ 2300 /* - Send UVC specific control query and check the response */ 2301 /* - If device responds to the query as success, device is UVC webcam */ 2302 /************************************************************************/ 2303 2304 /************************************************************************/ 2305 /* - List all /dev/video* entries to a file */ 2306 /************************************************************************/ 2307 /* Temporarily commented out. This logic doesnt seem to be working */ 2308 //system("ls > /data/video_dev_list"); 2309 2310 /************************************************************************/ 2311 /* - Open the video list file and loop through the list */ 2312 /************************************************************************/ 2313 2314 /* Temporarily commented out. This logic doesnt seem to be working */ 2315 /* 2316 fp = fopen("/data/video_dev_list", "rb"); 2317 if(!fp) { 2318 ALOGE("%s: Error in opening /data/video_dev_list ", __func__); 2319 return -1; 2320 } 2321 */ 2322 2323 /* Temporarily commented out. Looping logic changed due to issue in */ 2324 /* executing system("ls > /data/video_dev_list") */ 2325 //while(EOF != fscanf(fp, "%s", devname)){ 2326 while(1){ 2327 uvc_xu_control_query xqry; 2328 2329 sprintf(temp_devname, "/dev/video%d", i); 2330 ALOGD("%s: Probing %s \n", __func__, temp_devname); 2331 2332 fd = open(temp_devname, O_RDWR /* required */ | O_NONBLOCK, 0); 2333 if(-1 != fd){ 2334 memset(&xqry, 0, sizeof(uvc_xu_control_query)); 2335 ret = ioctl(fd, UVCIOC_CTRL_QUERY, &xqry); 2336 ALOGD("%s: UVCIOC ret: %d, errno: %d", __func__, ret, errno); 2337 /****************************************************************/ 2338 /* if UVCIOC is executed successfully, ret = 0 */ 2339 /* if UVCIOC is executed but Control Unit = 0 does not exist, */ 2340 /* ret = -1 and errno = ENOENT */ 2341 /* if UVCIOC doesnot execute, ret = -1 and errno = EINVAL */ 2342 /****************************************************************/ 2343 if((0 == ret) || (ret && (ENOENT == errno))){ 2344 ALOGD("%s: Found UVC node: %s\n", __func__, temp_devname); 2345 strncpy(devname, temp_devname, FILENAME_LENGTH); 2346 /* Exit the loop at the first UVC node detection */ 2347 break; 2348 } 2349 close(fd); 2350 } 2351 /* Temporarily logic to probe video0 to video10 nodes */ 2352 if(i++ > 10) 2353 { 2354 if(fp) 2355 fclose(fp); 2356 break; 2357 } 2358 } 2359 #endif /* #if 0 */ 2360 ALOGD("%s: X", __func__); 2361 return 0; 2362 } /* get_uvc_device */ 2363 2364 /****************************************************************************** 2365 * Function: fileDump 2366 * Description: This is a utility function to dump buffers into a file 2367 * 2368 * Input parameters: 2369 * fn - File name string 2370 * data - pointer to character buffer that needs to be dumped 2371 * length - Length of the buffer to be dumped 2372 * frm_cnt - Pointer to frame count. This count is incremented by this 2373 * function on successful file write 2374 * Return values: 2375 * 0 Success 2376 * -1 Error 2377 * Notes: none 2378 *****************************************************************************/ 2379 static int fileDump(const char* fn, char* data, int length, int* frm_cnt) 2380 { 2381 2382 FILE *fp = NULL; 2383 if (0 == *frm_cnt) { 2384 fp = fopen(fn, "wb"); 2385 if (NULL == fp) { 2386 ALOGE("%s: Error in opening %s", __func__, fn); 2387 } 2388 fclose(fp); 2389 } 2390 fp = fopen(fn, "ab"); 2391 if (NULL == fp) { 2392 ALOGE("%s: Error in opening %s", __func__, fn); 2393 } 2394 fwrite(data, 1, length, fp); 2395 fclose(fp); 2396 (*frm_cnt)++; 2397 ALOGD("%s: Written %d bytes for frame:%d, in %s", 2398 __func__, length, *frm_cnt, fn); 2399 2400 return 0; 2401 } 2402 2403 /****************************************************************************** 2404 * Function: launchTakePictureThread 2405 * Description: This is a wrapper function to start take picture thread 2406 * 2407 * Input parameters: 2408 * camHal - camera HAL handle 2409 * 2410 * Return values: 2411 * 0 No error 2412 * -1 Error 2413 * 2414 * Notes: none 2415 *****************************************************************************/ 2416 static int launchTakePictureThread(camera_hardware_t *camHal) 2417 { 2418 ALOGD("%s: E", __func__); 2419 int rc = 0; 2420 2421 if(!camHal) { 2422 ALOGE("%s: camHal is NULL", __func__); 2423 return -1; 2424 } 2425 2426 pthread_attr_t attr; 2427 pthread_attr_init(&attr); 2428 /* create the thread in detatched state, when the thread exits all */ 2429 /* memory resources are freed up */ 2430 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 2431 pthread_create(&camHal->takePictureThread, &attr, takePictureThread, camHal); 2432 2433 ALOGD("%s: X", __func__); 2434 return rc; 2435 } 2436 2437 /****************************************************************************** 2438 * Function: takePictureThread 2439 * Description: This function is associated with take picture thread 2440 * 2441 * Input parameters: 2442 * camHal - camera HAL handle 2443 * 2444 * Return values: 2445 * 0 No error 2446 * -1 Error 2447 * 2448 * Notes: none 2449 *****************************************************************************/ 2450 static void * takePictureThread(void *hcamHal) 2451 { 2452 int rc = 0; 2453 int buffer_id = 0; 2454 pid_t tid = 0; 2455 camera_hardware_t *camHal = NULL; 2456 int msgType = 0; 2457 int jpegLength = 0; 2458 QCameraHalMemInfo_t *mem_info = NULL; 2459 2460 camHal = (camera_hardware_t *)hcamHal; 2461 ALOGI("%s: E", __func__); 2462 2463 if(!camHal) { 2464 ALOGE("%s: camHal is NULL", __func__); 2465 return NULL ; 2466 } 2467 2468 tid = gettid(); 2469 /* TBR: Set appropriate thread priority */ 2470 androidSetThreadPriority(tid, ANDROID_PRIORITY_NORMAL); 2471 prctl(PR_SET_NAME, (unsigned long)"Camera HAL preview thread", 0, 0, 0); 2472 2473 /************************************************************************/ 2474 /* - If requested for shutter notfication, notify */ 2475 /* - Initialize USB camera with snapshot parameters */ 2476 /* - Time wait (select) on camera fd for camera frame availability */ 2477 /* - Dequeue capture buffer from USB camera */ 2478 /* - Send capture buffer to JPEG encoder for JPEG compression */ 2479 /* - If jpeg frames callback is requested, callback with jpeg buffers */ 2480 /* - Enqueue capture buffer back to USB camera */ 2481 /* - Free USB camera resources and close camera */ 2482 /* - If preview was stopped for taking picture, restart the preview */ 2483 /************************************************************************/ 2484 2485 Mutex::Autolock autoLock(camHal->lock); 2486 /************************************************************************/ 2487 /* - If requested for shutter notfication, notify */ 2488 /************************************************************************/ 2489 #if 0 /* TBD: Temporarily commented out due to an issue. Sometimes it takes */ 2490 /* long time to get back the lock once unlocked and notify callback */ 2491 if (camHal->msgEnabledFlag & CAMERA_MSG_SHUTTER){ 2492 camHal->lock.unlock(); 2493 camHal->notify_cb(CAMERA_MSG_SHUTTER, 0, 0, camHal->cb_ctxt); 2494 camHal->lock.lock(); 2495 } 2496 #endif 2497 /************************************************************************/ 2498 /* - Initialize USB camera with snapshot parameters */ 2499 /************************************************************************/ 2500 USB_CAM_OPEN(camHal); 2501 2502 #if JPEG_ON_USB_CAMERA 2503 rc = initUsbCamera(camHal, camHal->pictWidth, camHal->pictHeight, 2504 V4L2_PIX_FMT_MJPEG); 2505 #else 2506 rc = initUsbCamera(camHal, camHal->pictWidth, camHal->pictHeight, 2507 V4L2_PIX_FMT_YUYV); 2508 #endif 2509 ERROR_CHECK_EXIT_THREAD(rc, "initUsbCamera"); 2510 2511 rc = startUsbCamCapture(camHal); 2512 ERROR_CHECK_EXIT_THREAD(rc, "startUsbCamCapture"); 2513 2514 /************************************************************************/ 2515 /* - Time wait (select) on camera fd for camera frame availability */ 2516 /************************************************************************/ 2517 { 2518 fd_set fds; 2519 struct timeval tv; 2520 int r = 0; 2521 2522 FD_ZERO(&fds); 2523 FD_SET(camHal->fd, &fds); 2524 2525 tv.tv_sec = 1; 2526 tv.tv_usec = 0; 2527 2528 do{ 2529 ALOGD("%s: b4 select on camHal->fd : %d", __func__, camHal->fd); 2530 r = select(camHal->fd + 1, &fds, NULL, NULL, &tv); 2531 ALOGD("%s: after select", __func__); 2532 }while((0 == r) || ((-1 == r) && (EINTR == errno))); 2533 2534 if ((-1 == r) && (EINTR != errno)){ 2535 ALOGE("%s: FDSelect ret = %d error: %d", __func__, r, errno); 2536 return (void *)-1; 2537 } 2538 2539 } 2540 /************************************************************************/ 2541 /* - Dequeue capture buffer from USB camera */ 2542 /************************************************************************/ 2543 if (0 == get_buf_from_cam(camHal)) 2544 ALOGD("%s: get_buf_from_cam success", __func__); 2545 else 2546 ALOGE("%s: get_buf_from_cam error", __func__); 2547 2548 /************************************************************************/ 2549 /* - Send capture buffer to JPEG encoder for JPEG compression */ 2550 /************************************************************************/ 2551 mem_info = &camHal->pictMem.mem_info[0]; 2552 mem_info->size = MAX_JPEG_BUFFER_SIZE; 2553 2554 rc = allocate_ion_memory(mem_info, 2555 ((0x1 << CAMERA_ZSL_ION_HEAP_ID) | 2556 (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID))); 2557 if(rc) 2558 ALOGE("%s: ION memory allocation failed", __func__); 2559 2560 camHal->pictMem.camera_memory[0] = camHal->get_memory( 2561 mem_info->fd, mem_info->size, 1, camHal->cb_ctxt); 2562 if(!camHal->pictMem.camera_memory[0]) 2563 ALOGE("%s: get_mem failed", __func__); 2564 2565 #if FREAD_JPEG_PICTURE 2566 jpegLength = readFromFile("/data/tempVGA.jpeg", 2567 (char*)camHal->pictMem.camera_memory[0]->data, 2568 camHal->pictMem.camera_memory[0]->size); 2569 camHal->pictMem.camera_memory[0]->size = jpegLength; 2570 2571 #elif JPEG_ON_USB_CAMERA 2572 memcpy((char*)camHal->pictMem.camera_memory[0]->data, 2573 (char *)camHal->buffers[camHal->curCaptureBuf.index].data, 2574 camHal->curCaptureBuf.bytesused); 2575 camHal->pictMem.camera_memory[0]->size = camHal->curCaptureBuf.bytesused; 2576 jpegLength = camHal->curCaptureBuf.bytesused; 2577 2578 #else 2579 rc = encodeJpeg(camHal); 2580 ERROR_CHECK_EXIT_THREAD(rc, "jpeg_encode"); 2581 #endif 2582 if(jpegLength <= 0) 2583 ALOGI("%s: jpegLength : %d", __func__, jpegLength); 2584 2585 ALOGD("%s: jpegLength : %d", __func__, jpegLength); 2586 /************************************************************************/ 2587 /* - If jpeg frames callback is requested, callback with jpeg buffers */ 2588 /************************************************************************/ 2589 /* TBD: CAMERA_MSG_RAW_IMAGE data call back */ 2590 2591 if ((camHal->msgEnabledFlag & CAMERA_MSG_COMPRESSED_IMAGE) && 2592 (camHal->data_cb)){ 2593 /* Unlock temporarily, callback might call HAL api in turn */ 2594 camHal->lock.unlock(); 2595 2596 camHal->data_cb(CAMERA_MSG_COMPRESSED_IMAGE, 2597 camHal->pictMem.camera_memory[0], 2598 0, NULL, camHal->cb_ctxt); 2599 camHal->lock.lock(); 2600 } 2601 2602 /* release heap memory after the call back */ 2603 if(camHal->pictMem.camera_memory[0]) 2604 camHal->pictMem.camera_memory[0]->release( 2605 camHal->pictMem.camera_memory[0]); 2606 2607 rc = deallocate_ion_memory(mem_info); 2608 if(rc) 2609 ALOGE("%s: ION memory de-allocation failed", __func__); 2610 2611 /************************************************************************/ 2612 /* - Enqueue capture buffer back to USB camera */ 2613 /************************************************************************/ 2614 if(0 == put_buf_to_cam(camHal)) { 2615 ALOGD("%s: put_buf_to_cam success", __func__); 2616 } 2617 else 2618 ALOGE("%s: put_buf_to_cam error", __func__); 2619 2620 /************************************************************************/ 2621 /* - Free USB camera resources and close camera */ 2622 /************************************************************************/ 2623 rc = stopUsbCamCapture(camHal); 2624 ERROR_CHECK_EXIT_THREAD(rc, "stopUsbCamCapture"); 2625 2626 rc = unInitV4L2mmap(camHal); 2627 ERROR_CHECK_EXIT_THREAD(rc, "unInitV4L2mmap"); 2628 2629 USB_CAM_CLOSE(camHal); 2630 /************************************************************************/ 2631 /* - If preview was stopped for taking picture, restart the preview */ 2632 /************************************************************************/ 2633 if(camHal->prvwStoppedForPicture) 2634 { 2635 struct camera_device device; 2636 device.priv = (void *)camHal; 2637 2638 USB_CAM_OPEN(camHal); 2639 /* Unlock temporarily coz usbcam_start_preview has a lock */ 2640 camHal->lock.unlock(); 2641 rc = usbcam_start_preview(&device); 2642 if(rc) 2643 ALOGE("%s: start_preview error after take picture", __func__); 2644 camHal->lock.lock(); 2645 camHal->prvwStoppedForPicture = 0; 2646 } 2647 2648 /* take picture activity is done */ 2649 camHal->takePictInProgress = 0; 2650 2651 ALOGI("%s: X", __func__); 2652 return (void *)0; 2653 } 2654 2655 /****************************************************************************** 2656 * Function: allocate_ion_memory 2657 * Description: This function is allocates ION memory 2658 * 2659 * Input parameters: 2660 * camHal - camera HAL handle 2661 * 2662 * Return values: 2663 * 0 No error 2664 * -1 Error 2665 * 2666 * Notes: none 2667 *****************************************************************************/ 2668 static int allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type) 2669 { 2670 int rc = 0; 2671 struct ion_handle_data handle_data; 2672 struct ion_allocation_data alloc; 2673 struct ion_fd_data ion_info_fd; 2674 int main_ion_fd = 0; 2675 2676 main_ion_fd = open("/dev/ion", O_RDONLY); 2677 if (main_ion_fd <= 0) { 2678 ALOGE("Ion dev open failed %s\n", strerror(errno)); 2679 goto ION_OPEN_FAILED; 2680 } 2681 2682 memset(&alloc, 0, sizeof(alloc)); 2683 alloc.len = mem_info->size; 2684 /* to make it page size aligned */ 2685 alloc.len = (alloc.len + 4095) & (~4095); 2686 alloc.align = 4096; 2687 alloc.flags = ION_FLAG_CACHED; 2688 alloc.heap_id_mask = ion_type; 2689 rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &alloc); 2690 if (rc < 0) { 2691 ALOGE("ION allocation failed\n"); 2692 goto ION_ALLOC_FAILED; 2693 } 2694 2695 memset(&ion_info_fd, 0, sizeof(ion_info_fd)); 2696 ion_info_fd.handle = alloc.handle; 2697 rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd); 2698 if (rc < 0) { 2699 ALOGE("ION map failed %s\n", strerror(errno)); 2700 goto ION_MAP_FAILED; 2701 } 2702 2703 mem_info->main_ion_fd = main_ion_fd; 2704 mem_info->fd = ion_info_fd.fd; 2705 mem_info->handle = ion_info_fd.handle; 2706 mem_info->size = alloc.len; 2707 return 0; 2708 2709 ION_MAP_FAILED: 2710 memset(&handle_data, 0, sizeof(handle_data)); 2711 handle_data.handle = ion_info_fd.handle; 2712 ioctl(main_ion_fd, ION_IOC_FREE, &handle_data); 2713 ION_ALLOC_FAILED: 2714 close(main_ion_fd); 2715 ION_OPEN_FAILED: 2716 return -1; 2717 } 2718 2719 /****************************************************************************** 2720 * Function: deallocate_ion_memory 2721 * Description: This function de allocates ION memory 2722 * 2723 * Input parameters: 2724 * camHal - camera HAL handle 2725 * 2726 * Return values: 2727 * 0 No error 2728 * -1 Error 2729 * 2730 * Notes: none 2731 *****************************************************************************/ 2732 static int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info) 2733 { 2734 struct ion_handle_data handle_data; 2735 int rc = 0; 2736 2737 if (mem_info->fd > 0) { 2738 close(mem_info->fd); 2739 mem_info->fd = 0; 2740 } 2741 2742 if (mem_info->main_ion_fd > 0) { 2743 memset(&handle_data, 0, sizeof(handle_data)); 2744 handle_data.handle = mem_info->handle; 2745 ioctl(mem_info->main_ion_fd, ION_IOC_FREE, &handle_data); 2746 close(mem_info->main_ion_fd); 2747 mem_info->main_ion_fd = 0; 2748 } 2749 return rc; 2750 } 2751 2752 /****************************************************************************** 2753 * Function: readFromFile 2754 * Description: This function reads data from the given file into given buffer 2755 * 2756 * Input parameters: 2757 * camHal - camera HAL handle 2758 * 2759 * Return values: 2760 * int bytesRead 2761 * 2762 * Notes: none 2763 *****************************************************************************/ 2764 static int readFromFile(char* fileName, char* buffer, int bufferSize) 2765 { 2766 int bytesRead = 0, fileSize = 0; 2767 FILE *fp; 2768 2769 fp = fopen(fileName, "rb"); 2770 if(!fp){ 2771 ALOGE("%s: Error in opening %s ", __func__, fileName); 2772 return bytesRead; 2773 } 2774 2775 /* If file is bigger for given buffer, exit */ 2776 if (fileSize > bufferSize){ 2777 ALOGE("%s: Error %d > %d", __func__, fileSize, bufferSize); 2778 return bytesRead; 2779 } 2780 2781 bytesRead = fread(buffer, 1, bufferSize, fp); 2782 ALOGD(" %s: bytesRead: %d", __func__, bytesRead); 2783 2784 return bytesRead; 2785 } 2786 2787 /****************************************************************************** 2788 * Function: encodeJpeg 2789 * Description: This function initializes Jpeg encoder and calls jpeg encoder 2790 * call and waits for the encode to complete 2791 * 2792 * Input parameters: 2793 * camHal - camera HAL handle 2794 * 2795 * Return values: 2796 * 0 No Error 2797 * -1 Error 2798 * 2799 * Notes: none 2800 *****************************************************************************/ 2801 int encodeJpeg(camera_hardware_t *camHal) 2802 { 2803 int rc = 0; 2804 mm_jpeg_ops_t mmJpegOps; 2805 int jpegEncHdl = 0; 2806 mm_jpeg_job mmJpegJob; 2807 src_image_buffer_info *srcBuf = NULL; 2808 QCameraHalMemInfo_t jpegInMemInfo; 2809 camera_memory_t* jpegInMem; 2810 uint32_t jobId; 2811 2812 ALOGI("%s: E", __func__); 2813 2814 /************************************************************************/ 2815 /* - Allocate Jpeg input buffer from ION memory */ 2816 /************************************************************************/ 2817 jpegInMemInfo.size = camHal->pictWidth * camHal->pictHeight * 2; 2818 rc = allocate_ion_memory(&jpegInMemInfo, 2819 ((0x1 << CAMERA_ZSL_ION_HEAP_ID) | 2820 (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID))); 2821 ERROR_CHECK_EXIT(rc, "allocate_ion_memory"); 2822 2823 jpegInMem = camHal->get_memory( 2824 jpegInMemInfo.fd, jpegInMemInfo.size, 1, camHal->cb_ctxt); 2825 if(!jpegInMem){ 2826 ALOGE("%s: get_mem failed", __func__); 2827 return -1; 2828 } 2829 2830 rc = convert_YUYV_to_420_NV12( 2831 (char *)camHal->buffers[camHal->curCaptureBuf.index].data, 2832 (char *)jpegInMem->data, camHal->pictWidth, camHal->pictHeight); 2833 ERROR_CHECK_EXIT(rc, "convert_YUYV_to_420_NV12"); 2834 /************************************************************************/ 2835 /* - Populate JPEG encoding parameters from the camHal context */ 2836 /************************************************************************/ 2837 memset(&mmJpegJob, 0, sizeof(mmJpegJob)); 2838 2839 mmJpegJob.job_type = JPEG_JOB_TYPE_ENCODE; 2840 mmJpegJob.encode_job.jpeg_cb = jpegEncodeCb; 2841 mmJpegJob.encode_job.userdata = (void *)camHal; 2842 /* TBD: Rotation to be set from settings sent from app */ 2843 mmJpegJob.encode_job.encode_parm.rotation = 0; 2844 mmJpegJob.encode_job.encode_parm.exif_numEntries = 0; 2845 mmJpegJob.encode_job.encode_parm.exif_data = NULL; 2846 2847 /* TBD: Add thumbnail support */ 2848 mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.src_img_num = 1; 2849 mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.is_video_frame = 0; 2850 2851 /* Fill main image information */ 2852 srcBuf = &mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.src_img[0]; 2853 srcBuf->type = JPEG_SRC_IMAGE_TYPE_MAIN; 2854 srcBuf->img_fmt = JPEG_SRC_IMAGE_FMT_YUV; 2855 /* TBD: convert from YUYV to CRCBH2V2 */ 2856 srcBuf->color_format = MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2; 2857 srcBuf->num_bufs = 1; 2858 srcBuf->src_image[0].fd = jpegInMemInfo.fd; 2859 srcBuf->src_image[0].buf_vaddr = (uint8_t*)jpegInMem->data; 2860 //srcBuf->src_image[0].offset = 0; 2861 srcBuf->src_dim.width = camHal->pictWidth; 2862 srcBuf->src_dim.height = camHal->pictHeight; 2863 srcBuf->out_dim.width = camHal->pictWidth; 2864 srcBuf->out_dim.height = camHal->pictHeight; 2865 srcBuf->crop.offset_x = 0; 2866 srcBuf->crop.offset_y = 0; 2867 srcBuf->crop.width = srcBuf->src_dim.width; 2868 srcBuf->crop.height = srcBuf->src_dim.height; 2869 srcBuf->quality = camHal->pictJpegQlty; 2870 2871 /* TBD:Fill thumbnail image information */ 2872 2873 /* Fill out buf information */ 2874 mmJpegJob.encode_job.encode_parm.buf_info.sink_img.buf_vaddr = 2875 (uint8_t*)camHal->pictMem.camera_memory[0]->data; 2876 mmJpegJob.encode_job.encode_parm.buf_info.sink_img.fd = 0; 2877 /* TBD: hard coded for 1.5 bytes per pixel */ 2878 mmJpegJob.encode_job.encode_parm.buf_info.sink_img.buf_len = 2879 camHal->pictWidth * camHal->pictHeight * 1.5; 2880 2881 /************************************************************************/ 2882 /* - Initialize jpeg encoder and call Jpeg encoder start */ 2883 /************************************************************************/ 2884 memset(&mmJpegOps, 0, sizeof(mm_jpeg_ops_t)); 2885 jpegEncHdl = jpeg_open(&mmJpegOps); 2886 if(!jpegEncHdl){ 2887 ALOGE("%s: Failed to open Jpeg Encoder instance", __func__); 2888 }else 2889 ALOGD("%s: jpegEncHdl = %d", __func__, jpegEncHdl); 2890 2891 camHal->jpegEncInProgress = 1; 2892 rc = mmJpegOps.start_job(jpegEncHdl, &mmJpegJob, &jobId); 2893 2894 /************************************************************************/ 2895 /* - Wait for JPEG encoder to complete encoding */ 2896 /************************************************************************/ 2897 pthread_mutex_init(&camHal->jpegEncMutex, NULL); 2898 pthread_cond_init(&camHal->jpegEncCond, NULL); 2899 2900 pthread_mutex_lock(&camHal->jpegEncMutex); 2901 while(camHal->jpegEncInProgress) 2902 pthread_cond_wait(&camHal->jpegEncCond, &camHal->jpegEncMutex); 2903 pthread_mutex_unlock(&camHal->jpegEncMutex); 2904 2905 /************************************************************************/ 2906 /* - De-allocate Jpeg input buffer from ION memory */ 2907 /************************************************************************/ 2908 if(jpegInMem) 2909 jpegInMem->release(jpegInMem); 2910 2911 rc = deallocate_ion_memory(&jpegInMemInfo); 2912 if(rc) 2913 ALOGE("%s: ION memory de-allocation failed", __func__); 2914 2915 ALOGI("%s: X rc = %d", __func__, rc); 2916 return rc; 2917 } 2918 2919 /****************************************************************************** 2920 * Function: jpegEncodeCb 2921 * Description: This is a call back function registered with JPEG encoder. 2922 * Jpeg encoder calls this function on completion of encoding 2923 * 2924 * Input parameters: 2925 * camHal - camera HAL handle 2926 * 2927 * Return values: 2928 * 0 No Error 2929 * -1 Error 2930 * 2931 * Notes: none 2932 *****************************************************************************/ 2933 void jpegEncodeCb (jpeg_job_status_t status, 2934 uint8_t thumbnailDroppedFlag, 2935 uint32_t client_hdl, 2936 uint32_t jobId, 2937 uint8_t* out_data, 2938 uint32_t data_size, 2939 void *userData) 2940 { 2941 int rc = 0; 2942 camera_hardware_t *camHal = NULL; 2943 2944 ALOGI("%s: E status = %d", __func__, status); 2945 2946 camHal = (camera_hardware_t*) userData; 2947 2948 if(JPEG_JOB_STATUS_DONE == status){ 2949 ALOGD("%s: JPEG encode successful. out_data:%p, size: %d", __func__, 2950 out_data, data_size); 2951 camHal->jpegEncInProgress = 0; 2952 } 2953 2954 pthread_mutex_lock(&camHal->jpegEncMutex); 2955 pthread_cond_signal(&camHal->jpegEncCond); 2956 pthread_mutex_unlock(&camHal->jpegEncMutex); 2957 2958 ALOGI("%s: X", __func__); 2959 return; 2960 } 2961 2962 /******************************************************************************/ 2963 }; // namespace android 2964
