1 /* Copyright (c) 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 29 //#define ALOG_NDEBUG 0 30 #define ALOG_NIDEBUG 0 31 #define LOG_TAG "QCameraUsbParm" 32 #include <utils/Log.h> 33 34 #include <utils/Errors.h> 35 #include <utils/threads.h> 36 #include <utils/String16.h> 37 #include <sys/types.h> 38 #include <sys/stat.h> 39 #include <unistd.h> 40 #include <fcntl.h> 41 #include <cutils/properties.h> 42 #include <math.h> 43 #if HAVE_ANDROID_OS 44 #include <linux/android_pmem.h> 45 #endif 46 #include <linux/ioctl.h> 47 #include <camera/QCameraParameters.h> 48 #include <media/mediarecorder.h> 49 #include <gralloc_priv.h> 50 51 #include "linux/msm_mdp.h" 52 #include <linux/fb.h> 53 #include <limits.h> 54 55 56 extern "C" { 57 #include <fcntl.h> 58 #include <time.h> 59 #include <pthread.h> 60 #include <stdio.h> 61 #include <string.h> 62 #include <unistd.h> 63 #include <termios.h> 64 #include <assert.h> 65 #include <stdlib.h> 66 #include <ctype.h> 67 #include <signal.h> 68 #include <errno.h> 69 #include <sys/mman.h> 70 #include <sys/system_properties.h> 71 #include <sys/time.h> 72 #include <stdlib.h> 73 #include <linux/msm_ion.h> 74 #include <camera.h> 75 #include <cam_fifo.h> 76 #include <jpege.h> 77 78 } // extern "C" 79 80 #include "QCameraHWI.h" 81 #include "QualcommUsbCamera.h" 82 #include "QCameraUsbPriv.h" 83 #include "QCameraUsbParm.h" 84 85 namespace android { 86 87 /********************************************************************/ 88 static const str_map preview_formats[] = { 89 {QCameraParameters::PIXEL_FORMAT_YUV420SP, HAL_PIXEL_FORMAT_YCrCb_420_SP}, 90 }; 91 92 static const preview_format_info_t preview_format_info_list[] = { 93 {HAL_PIXEL_FORMAT_YV12, CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3} 94 }; 95 96 static struct camera_size_type previewSizes[] = { 97 { 1920, 1088}, //1080p 98 { 1280, 720}, // 720P, 99 { 640, 480}, // VGA 100 { 512, 384}, 101 { 480, 320}, 102 { 320, 240}, // QVGA 103 }; 104 105 // All fps ranges which can be supported. This list will be filtered according 106 // to the min and max fps supported by hardware 107 // this list must be sorted first by max_fps and then min_fps 108 // fps values are multiplied by 1000 109 static android::FPSRange prevFpsRanges[] = { 110 android::FPSRange(5000, 121000), 111 }; 112 113 /* TBR: Is frame rate mode mandatory */ 114 static const str_map frame_rate_modes[] = { 115 {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO}, 116 {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED} 117 }; 118 119 static const str_map picture_formats[] = { 120 {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG}, 121 //{QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW} 122 }; 123 124 static camera_size_type picture_sizes[] = { 125 { 1920, 1088}, //HD1080 126 { 1280, 720}, //HD720 127 { 640, 480}, // VGA 128 { 320, 240}, // QVGA 129 }; 130 131 /* aspect ratio removed */ 132 static camera_size_type thumbnail_sizes[] = { 133 { 512, 288 }, //1.777778 134 { 480, 288 }, //1.666667 135 { 256, 154 }, //1.66233 136 { 432, 288 }, //1.5 137 { 512, 384 }, //1.333333 138 { 352, 288 }, //1.222222 139 { 320, 240 }, //1.33333 140 { 176, 144 }, //1.222222 141 }; 142 143 static const str_map recording_Hints[] = { 144 {"false", FALSE}, 145 {"true", TRUE} 146 }; 147 148 /* Static functions list */ 149 static String8 create_sizes_str(const camera_size_type *sizes, int len); 150 static String8 create_values_str(const str_map *values, int len); 151 static String8 create_fps_str(const android:: FPSRange* fps, int len); 152 static String8 create_values_range_str(int min, int max); 153 static int usbCamSetPrvwSize( camera_hardware_t *camHal, 154 const QCameraParameters& params); 155 static int usbCamSetPictSize( camera_hardware_t *camHal, 156 const QCameraParameters& params); 157 static int usbCamSetThumbnailSize( camera_hardware_t *camHal, 158 const QCameraParameters& params); 159 static int usbCamSetJpegQlty( camera_hardware_t *camHal, 160 const QCameraParameters& params); 161 162 /****************************************************************************** 163 * Function: usbCamInitDefaultParameters 164 * Description: This function sets default parameters to camera HAL context 165 * 166 * Input parameters: 167 * camHal - camera HAL handle 168 * 169 * Return values: 170 * None 171 * 172 * Notes: none 173 *****************************************************************************/ 174 int usbCamInitDefaultParameters(camera_hardware_t *camHal) 175 { 176 ALOGD("%s: E", __func__); 177 int rc = 0; 178 char tempStr[FILENAME_LENGTH]; 179 180 /* Default initializations */ 181 camHal->prevFormat = DEFAULT_USBCAM_PRVW_FMT; 182 camHal->prevWidth = DEFAULT_USBCAM_PRVW_WD; 183 camHal->prevHeight = DEFAULT_USBCAM_PRVW_HT; 184 camHal->dispFormat = camHal->prevFormat; 185 camHal->dispWidth = camHal->prevWidth; 186 camHal->dispHeight = camHal->prevHeight; 187 camHal->pictFormat = DEFAULT_USBCAM_PICT_FMT; 188 camHal->pictWidth = DEFAULT_USBCAM_PICT_WD; 189 camHal->pictHeight = DEFAULT_USBCAM_PICT_HT; 190 camHal->pictJpegQlty = DEFAULT_USBCAM_PICT_QLTY; 191 camHal->thumbnailWidth = DEFAULT_USBCAM_THUMBNAIL_WD; 192 camHal->thumbnailHeight = DEFAULT_USBCAM_THUMBNAIL_HT; 193 camHal->thumbnailJpegQlty = DEFAULT_USBCAM_THUMBNAIL_QLTY; 194 camHal->previewEnabledFlag = 0; 195 camHal->prvwStoppedForPicture = 0; 196 camHal->prvwCmdPending = 0; 197 camHal->takePictInProgress = 0; 198 199 //Set picture size values 200 camHal->pictSizeValues = create_sizes_str( 201 picture_sizes, sizeof(picture_sizes) / sizeof(camera_size_type)); 202 camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 203 camHal->pictSizeValues.string()); 204 camHal->qCamParams.setPictureSize(camHal->pictWidth, camHal->pictHeight); 205 206 //Set picture format 207 camHal->pictFormatValues = create_values_str( 208 picture_formats, sizeof(picture_formats) / sizeof(str_map)); 209 camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 210 camHal->pictFormatValues.string()); 211 if(PICTURE_FORMAT_JPEG == camHal->pictFormat) 212 camHal->qCamParams.setPictureFormat(QCameraParameters::PIXEL_FORMAT_JPEG); 213 214 //Set picture quality 215 sprintf(tempStr, "%d", camHal->pictJpegQlty); 216 camHal->qCamParams.set(QCameraParameters::KEY_JPEG_QUALITY, tempStr); 217 218 //Set Thumbnail size 219 camHal->thumbnailSizeValues = create_sizes_str( 220 thumbnail_sizes, sizeof(thumbnail_sizes) /sizeof(camera_size_type)); 221 camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 222 camHal->thumbnailSizeValues.string()); 223 sprintf(tempStr, "%d", camHal->thumbnailWidth); 224 camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 225 tempStr); 226 sprintf(tempStr, "%d", camHal->thumbnailHeight); 227 camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 228 tempStr); 229 230 //Set Thumbnail quality 231 sprintf(tempStr, "%d", camHal->thumbnailJpegQlty); 232 camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 233 tempStr); 234 235 //Set Preview Format 236 camHal->prevFormatValues = create_values_str( 237 preview_formats, sizeof(preview_formats) / sizeof(str_map)); 238 camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 239 camHal->prevFormatValues.string()); 240 if(HAL_PIXEL_FORMAT_YCrCb_420_SP == camHal->prevFormat) 241 camHal->qCamParams.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP); 242 243 //Set Preview size 244 camHal->prevSizeValues = create_sizes_str( 245 previewSizes, sizeof(previewSizes) / sizeof(camera_size_type)); 246 camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 247 camHal->prevSizeValues.string()); 248 camHal->qCamParams.setPreviewSize(camHal->prevWidth, camHal->prevHeight); 249 250 //Set Preivew fps range 251 camHal->prevFpsRangesValues = create_fps_str( 252 prevFpsRanges, sizeof(prevFpsRanges) / sizeof(android::FPSRange)); 253 254 camHal->qCamParams.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 255 camHal->prevFpsRangesValues); 256 camHal->qCamParams.setPreviewFpsRange(MIN_PREV_FPS, MAX_PREV_FPS); 257 258 ALOGD("%s: X", __func__); 259 260 return rc; 261 } /* usbCamInitDefaultParameters */ 262 263 /****************************************************************************** 264 * Function: usbCamSetParameters 265 * Description: This function parses the parameter string and stores the 266 * parameters in the camera HAL handle 267 * 268 * Input parameters: 269 * camHal - camera HAL handle 270 * params - pointer to parameter string 271 * 272 * Return values: 273 * 0 Success 274 * -1 Error 275 * Notes: none 276 *****************************************************************************/ 277 int usbCamSetParameters(camera_hardware_t *camHal, const char *params) 278 { 279 int rc = 0; 280 String8 str = String8(params); 281 QCameraParameters qParam; 282 283 ALOGD("%s: E", __func__); 284 285 if(params) 286 PRINT_PARAM_STR(params); 287 288 qParam.unflatten(str); 289 290 if(usbCamSetPrvwSize(camHal, qParam)) 291 rc = -1; 292 if(usbCamSetPictSize(camHal, qParam)) 293 rc = -1; 294 if(usbCamSetThumbnailSize(camHal, qParam)) 295 rc = -1; 296 if(usbCamSetJpegQlty(camHal, qParam)) 297 rc = -1; 298 299 ALOGD("%s: X", __func__); 300 return rc; 301 } /* usbCamSetParameters */ 302 303 /****************************************************************************** 304 * Function: usbCamGetParameters 305 * Description: This function allocates memory for parameter string, 306 * composes and returns the parameter string 307 * 308 * Input parameters: 309 * camHal - camera HAL handle 310 * 311 * Return values: 312 * Address to the parameter string 313 * 314 * Notes: none 315 *****************************************************************************/ 316 char* usbCamGetParameters(camera_hardware_t *camHal) 317 { 318 ALOGD("%s: E", __func__); 319 char *parms = NULL; 320 char* rc = NULL; 321 String8 str; 322 323 QCameraParameters qParam = camHal->qCamParams; 324 //qParam.dump(); 325 str = qParam.flatten( ); 326 rc = (char *)malloc(sizeof(char)*(str.length()+1)); 327 if(rc != NULL){ 328 memset(rc, 0, sizeof(char)*(str.length()+1)); 329 strncpy(rc, str.string(), str.length()); 330 rc[str.length()] = 0; 331 parms = rc; 332 } 333 334 PRINT_PARAM_STR(parms); 335 336 ALOGD("%s: X", __func__); 337 return (parms); 338 } /* usbCamGetParameters */ 339 340 /****************************************************************************** 341 * Function: usbCamPutParameters 342 * Description: This function frees the memory allocated for parameter string 343 * 344 * Input parameters: 345 * camHal - camera HAL handle 346 * parms - Parameter string 347 * 348 * Return values: 349 * None 350 * 351 * Notes: none 352 *****************************************************************************/ 353 void usbCamPutParameters(camera_hardware_t *camHal, char *parms) 354 { 355 ALOGD("%s: E", __func__); 356 if(parms) 357 free(parms); 358 parms = NULL; 359 ALOGD("%s: X", __func__); 360 } /* usbCamPutParameters */ 361 362 /****************************************************************************** 363 * Function: create_sizes_str 364 * Description: This function loops through /dev/video entries and probes with 365 * UVCIOC query. If the device responds to the query, then it is 366 * detected as UVC webcam 367 * Input parameters: 368 * devname - String pointer. The function return dev entry 369 * name in this string 370 * Return values: 371 * 0 Success 372 * -1 Error 373 * Notes: none 374 *****************************************************************************/ 375 static String8 create_sizes_str(const camera_size_type *sizes, int len) { 376 String8 str; 377 char buffer[32]; 378 379 if (len > 0) { 380 snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height); 381 str.append(buffer); 382 } 383 for (int i = 1; i < len; i++) { 384 snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height); 385 str.append(buffer); 386 } 387 return str; 388 } 389 390 /****************************************************************************** 391 * Function: create_values_str 392 * Description: This function loops through /dev/video entries and probes with 393 * UVCIOC query. If the device responds to the query, then it is 394 * detected as UVC webcam 395 * Input parameters: 396 * devname - String pointer. The function return dev entry 397 * name in this string 398 * Return values: 399 * 0 Success 400 * -1 Error 401 * Notes: none 402 *****************************************************************************/ 403 static String8 create_values_str(const str_map *values, int len) { 404 String8 str; 405 406 if (len > 0) { 407 str.append(values[0].desc); 408 } 409 for (int i = 1; i < len; i++) { 410 str.append(","); 411 str.append(values[i].desc); 412 } 413 return str; 414 } 415 416 /****************************************************************************** 417 * Function: create_fps_str 418 * Description: This function loops through /dev/video entries and probes with 419 * UVCIOC query. If the device responds to the query, then it is 420 * detected as UVC webcam 421 * Input parameters: 422 * devname - String pointer. The function return dev entry 423 * name in this string 424 * Return values: 425 * 0 Success 426 * -1 Error 427 * Notes: none 428 *****************************************************************************/ 429 static String8 create_fps_str(const android:: FPSRange* fps, int len) { 430 String8 str; 431 char buffer[32]; 432 433 if (len > 0) { 434 snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS); 435 str.append(buffer); 436 } 437 for (int i = 1; i < len; i++) { 438 snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS); 439 str.append(buffer); 440 } 441 return str; 442 } 443 444 /****************************************************************************** 445 * Function: create_values_range_str 446 * Description: This function loops through /dev/video entries and probes with 447 * UVCIOC query. If the device responds to the query, then it is 448 * detected as UVC webcam 449 * Input parameters: 450 * devname - String pointer. The function return dev entry 451 * name in this string 452 * Return values: 453 * 0 Success 454 * -1 Error 455 * Notes: none 456 *****************************************************************************/ 457 static String8 create_values_range_str(int min, int max){ 458 String8 str; 459 char buffer[32]; 460 461 if(min <= max){ 462 snprintf(buffer, sizeof(buffer), "%d", min); 463 str.append(buffer); 464 465 for (int i = min + 1; i <= max; i++) { 466 snprintf(buffer, sizeof(buffer), ",%d", i); 467 str.append(buffer); 468 } 469 } 470 return str; 471 } 472 473 /****************************************************************************** 474 * Function: usbCamSetPrvwSize 475 * Description: This function parses preview width and height from the input 476 * parameters and stores into the context 477 * 478 * Input parameters: 479 * camHal - camera HAL handle 480 * params - QCameraParameters reference 481 * 482 * Return values: 483 * 0 If parameters are valid 484 * -1 If parameters are invalid 485 * 486 * Notes: none 487 *****************************************************************************/ 488 static int usbCamSetPrvwSize( camera_hardware_t *camHal, 489 const QCameraParameters& params) 490 { 491 int rc = 0, width, height, i, numPrvwSizes, validSize; 492 ALOGD("%s: E", __func__); 493 494 params.getPreviewSize(&width, &height); 495 ALOGI("%s: Requested preview size %d x %d", __func__, width, height); 496 497 // Validate the preview size 498 numPrvwSizes = sizeof(previewSizes) / sizeof(camera_size_type); 499 for (i = 0, validSize = 0; i < numPrvwSizes; i++) { 500 if (width == previewSizes[i].width 501 && height == previewSizes[i].height) { 502 validSize = 1; 503 504 camHal->qCamParams.setPreviewSize(width, height); 505 ALOGD("%s: setPreviewSize: width: %d height: %d", 506 __func__, width, height); 507 508 camHal->prevWidth = width; 509 camHal->prevHeight = height; 510 camHal->dispWidth = width; 511 camHal->dispHeight = height; 512 513 /* TBD: restrict pictures size and video to preview size */ 514 } 515 } 516 if(!validSize) 517 ALOGE("%s: Invalid preview size %dx%d requested", __func__, 518 width, height); 519 520 rc = (validSize == 0)? -1:0; 521 ALOGD("%s: X", __func__); 522 523 return rc; 524 } /* usbCamSetPrvwSize */ 525 526 /****************************************************************************** 527 * Function: usbCamSetPictSize 528 * Description: This function parses picture width and height from the input 529 * parameters and stores into the context 530 * 531 * Input parameters: 532 * camHal - camera HAL handle 533 * params - QCameraParameters reference 534 * 535 * Return values: 536 * 0 If parameters are valid 537 * -1 If parameters are invalid 538 * 539 * Notes: none 540 *****************************************************************************/ 541 static int usbCamSetPictSize( camera_hardware_t *camHal, 542 const QCameraParameters& params) 543 { 544 int rc = 0, width, height, i, numPictSizes, validSize; 545 ALOGD("%s: E", __func__); 546 547 /* parse for picture width and height */ 548 params.getPictureSize(&width, &height); 549 ALOGI("%s: Requested picture size %d x %d", __func__, width, height); 550 551 // Validate the picture size 552 numPictSizes = sizeof(picture_sizes) / sizeof(camera_size_type); 553 for (i = 0, validSize = 0; i < numPictSizes; i++) { 554 if (width == picture_sizes[i].width 555 && height == picture_sizes[i].height) { 556 validSize = 1; 557 558 camHal->qCamParams.setPictureSize(width, height); 559 ALOGD("%s: setPictureSize: width: %d height: %d", 560 __func__, width, height); 561 562 /* TBD: If new pictSize is different from old size, restart prvw */ 563 camHal->pictWidth = width; 564 camHal->pictHeight = height; 565 } 566 } 567 if(!validSize) 568 ALOGE("%s: Invalid picture size %dx%d requested", __func__, 569 width, height); 570 rc = (validSize == 0)? -1:0; 571 ALOGD("%s: X", __func__); 572 573 return rc; 574 } /* usbCamSetPictSize */ 575 576 /****************************************************************************** 577 * Function: usbCamSetThumbnailSize 578 * Description: This function parses picture width and height from the input 579 * parameters and stores into the context 580 * 581 * Input parameters: 582 * camHal - camera HAL handle 583 * params - QCameraParameters reference 584 * 585 * Return values: 586 * 0 If parameters are valid 587 * -1 If parameters are invalid 588 * 589 * Notes: none 590 *****************************************************************************/ 591 static int usbCamSetThumbnailSize( camera_hardware_t *camHal, 592 const QCameraParameters& params) 593 { 594 int rc = 0, width, height, i, numThumbnailSizes, validSize; 595 char tempStr[FILENAME_LENGTH]; 596 ALOGD("%s: E", __func__); 597 598 /* parse for thumbnail width and height */ 599 width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 600 height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 601 ALOGI("%s: Requested thumbnail size %d x %d", __func__, width, height); 602 603 // Validate the thumbnail size 604 numThumbnailSizes = sizeof(thumbnail_sizes) / sizeof(camera_size_type); 605 for (i = 0, validSize = 0; i < numThumbnailSizes; i++) { 606 if (width == thumbnail_sizes[i].width 607 && height == thumbnail_sizes[i].height) { 608 validSize = 1; 609 610 camHal->thumbnailWidth = width; 611 camHal->thumbnailHeight = height; 612 sprintf(tempStr, "%d", camHal->thumbnailWidth); 613 camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 614 width); 615 sprintf(tempStr, "%d", camHal->thumbnailHeight); 616 camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 617 height); 618 619 } 620 } 621 if(!validSize) 622 ALOGE("%s: Invalid picture size %dx%d requested", __func__, 623 width, height); 624 rc = (validSize == 0)? -1:0; 625 ALOGD("%s: X", __func__); 626 627 return rc; 628 } /* usbCamSetThumbnailSize */ 629 630 /****************************************************************************** 631 * Function: usbCamSetJpegQlty 632 * Description: This function parses picture and thumbnail JPEG quality and 633 * validates before storing in the context 634 * 635 * Input parameters: 636 * camHal - camera HAL handle 637 * params - QCameraParameters reference 638 * 639 * Return values: 640 * 0 If parameters are valid 641 * -1 If parameters are invalid 642 * 643 * Notes: none 644 *****************************************************************************/ 645 static int usbCamSetJpegQlty( camera_hardware_t *camHal, 646 const QCameraParameters& params) 647 { 648 int rc = 0, quality = 0; 649 char tempStr[FILENAME_LENGTH]; 650 ALOGD("%s: E", __func__); 651 652 /**/ 653 quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY); 654 ALOGI("%s: Requested picture qlty %d", __func__, quality); 655 656 if (quality >= 0 && quality <= 100) { 657 camHal->pictJpegQlty = quality; 658 sprintf(tempStr, "%d", camHal->pictJpegQlty); 659 camHal->qCamParams.set(QCameraParameters::KEY_JPEG_QUALITY, quality); 660 } else { 661 ALOGE("Invalid jpeg quality=%d", quality); 662 rc = -1; 663 } 664 665 quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); 666 ALOGI("%s: Requested thumbnail qlty %d", __func__, quality); 667 668 if (quality >= 0 && quality <= 100) { 669 camHal->thumbnailJpegQlty = quality; 670 sprintf(tempStr, "%d", camHal->thumbnailJpegQlty); 671 camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 672 tempStr); 673 } else { 674 ALOGE("Invalid jpeg thumbnail quality=%d", quality); 675 rc = -1; 676 } 677 678 ALOGD("%s: X rc:%d", __func__, rc); 679 680 return rc; 681 } 682 683 }; /*namespace android */ 684
