/* Copyright (c) 2012, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * Neither the name of The Linux Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ //#define ALOG_NDEBUG 0 #define ALOG_NIDEBUG 0 #define LOG_TAG "QCameraUsbParm" #include #include #include #include #include #include #include #include #include #include #if HAVE_ANDROID_OS #include #endif #include #include #include #include #include "linux/msm_mdp.h" #include #include extern "C" { #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include } // extern "C" #include "QCameraHWI.h" #include "QualcommUsbCamera.h" #include "QCameraUsbPriv.h" #include "QCameraUsbParm.h" namespace android { /********************************************************************/ static const str_map preview_formats[] = { {QCameraParameters::PIXEL_FORMAT_YUV420SP, HAL_PIXEL_FORMAT_YCrCb_420_SP}, }; static const preview_format_info_t preview_format_info_list[] = { {HAL_PIXEL_FORMAT_YV12, CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3} }; static struct camera_size_type previewSizes[] = { { 1920, 1088}, //1080p { 1280, 720}, // 720P, { 640, 480}, // VGA { 512, 384}, { 480, 320}, { 320, 240}, // QVGA }; // All fps ranges which can be supported. This list will be filtered according // to the min and max fps supported by hardware // this list must be sorted first by max_fps and then min_fps // fps values are multiplied by 1000 static android::FPSRange prevFpsRanges[] = { android::FPSRange(5000, 121000), }; /* TBR: Is frame rate mode mandatory */ static const str_map frame_rate_modes[] = { {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO}, {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED} }; static const str_map picture_formats[] = { {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG}, //{QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW} }; static camera_size_type picture_sizes[] = { { 1920, 1088}, //HD1080 { 1280, 720}, //HD720 { 640, 480}, // VGA { 320, 240}, // QVGA }; /* aspect ratio removed */ static camera_size_type thumbnail_sizes[] = { { 512, 288 }, //1.777778 { 480, 288 }, //1.666667 { 256, 154 }, //1.66233 { 432, 288 }, //1.5 { 512, 384 }, //1.333333 { 352, 288 }, //1.222222 { 320, 240 }, //1.33333 { 176, 144 }, //1.222222 }; static const str_map recording_Hints[] = { {"false", FALSE}, {"true", TRUE} }; /* Static functions list */ static String8 create_sizes_str(const camera_size_type *sizes, int len); static String8 create_values_str(const str_map *values, int len); static String8 create_fps_str(const android:: FPSRange* fps, int len); static String8 create_values_range_str(int min, int max); static int usbCamSetPrvwSize( camera_hardware_t *camHal, const QCameraParameters& params); static int usbCamSetPictSize( camera_hardware_t *camHal, const QCameraParameters& params); static int usbCamSetThumbnailSize( camera_hardware_t *camHal, const QCameraParameters& params); static int usbCamSetJpegQlty( camera_hardware_t *camHal, const QCameraParameters& params); /****************************************************************************** * Function: usbCamInitDefaultParameters * Description: This function sets default parameters to camera HAL context * * Input parameters: * camHal - camera HAL handle * * Return values: * None * * Notes: none *****************************************************************************/ int usbCamInitDefaultParameters(camera_hardware_t *camHal) { ALOGD("%s: E", __func__); int rc = 0; char tempStr[FILENAME_LENGTH]; /* Default initializations */ camHal->prevFormat = DEFAULT_USBCAM_PRVW_FMT; camHal->prevWidth = DEFAULT_USBCAM_PRVW_WD; camHal->prevHeight = DEFAULT_USBCAM_PRVW_HT; camHal->dispFormat = camHal->prevFormat; camHal->dispWidth = camHal->prevWidth; camHal->dispHeight = camHal->prevHeight; camHal->pictFormat = DEFAULT_USBCAM_PICT_FMT; camHal->pictWidth = DEFAULT_USBCAM_PICT_WD; camHal->pictHeight = DEFAULT_USBCAM_PICT_HT; camHal->pictJpegQlty = DEFAULT_USBCAM_PICT_QLTY; camHal->thumbnailWidth = DEFAULT_USBCAM_THUMBNAIL_WD; camHal->thumbnailHeight = DEFAULT_USBCAM_THUMBNAIL_HT; camHal->thumbnailJpegQlty = DEFAULT_USBCAM_THUMBNAIL_QLTY; camHal->previewEnabledFlag = 0; camHal->prvwStoppedForPicture = 0; camHal->prvwCmdPending = 0; camHal->takePictInProgress = 0; //Set picture size values camHal->pictSizeValues = create_sizes_str( picture_sizes, sizeof(picture_sizes) / sizeof(camera_size_type)); camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES, camHal->pictSizeValues.string()); camHal->qCamParams.setPictureSize(camHal->pictWidth, camHal->pictHeight); //Set picture format camHal->pictFormatValues = create_values_str( picture_formats, sizeof(picture_formats) / sizeof(str_map)); camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, camHal->pictFormatValues.string()); if(PICTURE_FORMAT_JPEG == camHal->pictFormat) camHal->qCamParams.setPictureFormat(QCameraParameters::PIXEL_FORMAT_JPEG); //Set picture quality sprintf(tempStr, "%d", camHal->pictJpegQlty); camHal->qCamParams.set(QCameraParameters::KEY_JPEG_QUALITY, tempStr); //Set Thumbnail size camHal->thumbnailSizeValues = create_sizes_str( thumbnail_sizes, sizeof(thumbnail_sizes) /sizeof(camera_size_type)); camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, camHal->thumbnailSizeValues.string()); sprintf(tempStr, "%d", camHal->thumbnailWidth); camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, tempStr); sprintf(tempStr, "%d", camHal->thumbnailHeight); camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, tempStr); //Set Thumbnail quality sprintf(tempStr, "%d", camHal->thumbnailJpegQlty); camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, tempStr); //Set Preview Format camHal->prevFormatValues = create_values_str( preview_formats, sizeof(preview_formats) / sizeof(str_map)); camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, camHal->prevFormatValues.string()); if(HAL_PIXEL_FORMAT_YCrCb_420_SP == camHal->prevFormat) camHal->qCamParams.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP); //Set Preview size camHal->prevSizeValues = create_sizes_str( previewSizes, sizeof(previewSizes) / sizeof(camera_size_type)); camHal->qCamParams.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, camHal->prevSizeValues.string()); camHal->qCamParams.setPreviewSize(camHal->prevWidth, camHal->prevHeight); //Set Preivew fps range camHal->prevFpsRangesValues = create_fps_str( prevFpsRanges, sizeof(prevFpsRanges) / sizeof(android::FPSRange)); camHal->qCamParams.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, camHal->prevFpsRangesValues); camHal->qCamParams.setPreviewFpsRange(MIN_PREV_FPS, MAX_PREV_FPS); ALOGD("%s: X", __func__); return rc; } /* usbCamInitDefaultParameters */ /****************************************************************************** * Function: usbCamSetParameters * Description: This function parses the parameter string and stores the * parameters in the camera HAL handle * * Input parameters: * camHal - camera HAL handle * params - pointer to parameter string * * Return values: * 0 Success * -1 Error * Notes: none *****************************************************************************/ int usbCamSetParameters(camera_hardware_t *camHal, const char *params) { int rc = 0; String8 str = String8(params); QCameraParameters qParam; ALOGD("%s: E", __func__); if(params) PRINT_PARAM_STR(params); qParam.unflatten(str); if(usbCamSetPrvwSize(camHal, qParam)) rc = -1; if(usbCamSetPictSize(camHal, qParam)) rc = -1; if(usbCamSetThumbnailSize(camHal, qParam)) rc = -1; if(usbCamSetJpegQlty(camHal, qParam)) rc = -1; ALOGD("%s: X", __func__); return rc; } /* usbCamSetParameters */ /****************************************************************************** * Function: usbCamGetParameters * Description: This function allocates memory for parameter string, * composes and returns the parameter string * * Input parameters: * camHal - camera HAL handle * * Return values: * Address to the parameter string * * Notes: none *****************************************************************************/ char* usbCamGetParameters(camera_hardware_t *camHal) { ALOGD("%s: E", __func__); char *parms = NULL; char* rc = NULL; String8 str; QCameraParameters qParam = camHal->qCamParams; //qParam.dump(); str = qParam.flatten( ); rc = (char *)malloc(sizeof(char)*(str.length()+1)); if(rc != NULL){ memset(rc, 0, sizeof(char)*(str.length()+1)); strncpy(rc, str.string(), str.length()); rc[str.length()] = 0; parms = rc; } PRINT_PARAM_STR(parms); ALOGD("%s: X", __func__); return (parms); } /* usbCamGetParameters */ /****************************************************************************** * Function: usbCamPutParameters * Description: This function frees the memory allocated for parameter string * * Input parameters: * camHal - camera HAL handle * parms - Parameter string * * Return values: * None * * Notes: none *****************************************************************************/ void usbCamPutParameters(camera_hardware_t *camHal, char *parms) { ALOGD("%s: E", __func__); if(parms) free(parms); parms = NULL; ALOGD("%s: X", __func__); } /* usbCamPutParameters */ /****************************************************************************** * Function: create_sizes_str * Description: This function loops through /dev/video entries and probes with * UVCIOC query. If the device responds to the query, then it is * detected as UVC webcam * Input parameters: * devname - String pointer. The function return dev entry * name in this string * Return values: * 0 Success * -1 Error * Notes: none *****************************************************************************/ static String8 create_sizes_str(const camera_size_type *sizes, int len) { String8 str; char buffer[32]; if (len > 0) { snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height); str.append(buffer); } for (int i = 1; i < len; i++) { snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height); str.append(buffer); } return str; } /****************************************************************************** * Function: create_values_str * Description: This function loops through /dev/video entries and probes with * UVCIOC query. If the device responds to the query, then it is * detected as UVC webcam * Input parameters: * devname - String pointer. The function return dev entry * name in this string * Return values: * 0 Success * -1 Error * Notes: none *****************************************************************************/ static String8 create_values_str(const str_map *values, int len) { String8 str; if (len > 0) { str.append(values[0].desc); } for (int i = 1; i < len; i++) { str.append(","); str.append(values[i].desc); } return str; } /****************************************************************************** * Function: create_fps_str * Description: This function loops through /dev/video entries and probes with * UVCIOC query. If the device responds to the query, then it is * detected as UVC webcam * Input parameters: * devname - String pointer. The function return dev entry * name in this string * Return values: * 0 Success * -1 Error * Notes: none *****************************************************************************/ static String8 create_fps_str(const android:: FPSRange* fps, int len) { String8 str; char buffer[32]; if (len > 0) { snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS); str.append(buffer); } for (int i = 1; i < len; i++) { snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS); str.append(buffer); } return str; } /****************************************************************************** * Function: create_values_range_str * Description: This function loops through /dev/video entries and probes with * UVCIOC query. If the device responds to the query, then it is * detected as UVC webcam * Input parameters: * devname - String pointer. The function return dev entry * name in this string * Return values: * 0 Success * -1 Error * Notes: none *****************************************************************************/ static String8 create_values_range_str(int min, int max){ String8 str; char buffer[32]; if(min <= max){ snprintf(buffer, sizeof(buffer), "%d", min); str.append(buffer); for (int i = min + 1; i <= max; i++) { snprintf(buffer, sizeof(buffer), ",%d", i); str.append(buffer); } } return str; } /****************************************************************************** * Function: usbCamSetPrvwSize * Description: This function parses preview width and height from the input * parameters and stores into the context * * Input parameters: * camHal - camera HAL handle * params - QCameraParameters reference * * Return values: * 0 If parameters are valid * -1 If parameters are invalid * * Notes: none *****************************************************************************/ static int usbCamSetPrvwSize( camera_hardware_t *camHal, const QCameraParameters& params) { int rc = 0, width, height, i, numPrvwSizes, validSize; ALOGD("%s: E", __func__); params.getPreviewSize(&width, &height); ALOGI("%s: Requested preview size %d x %d", __func__, width, height); // Validate the preview size numPrvwSizes = sizeof(previewSizes) / sizeof(camera_size_type); for (i = 0, validSize = 0; i < numPrvwSizes; i++) { if (width == previewSizes[i].width && height == previewSizes[i].height) { validSize = 1; camHal->qCamParams.setPreviewSize(width, height); ALOGD("%s: setPreviewSize: width: %d height: %d", __func__, width, height); camHal->prevWidth = width; camHal->prevHeight = height; camHal->dispWidth = width; camHal->dispHeight = height; /* TBD: restrict pictures size and video to preview size */ } } if(!validSize) ALOGE("%s: Invalid preview size %dx%d requested", __func__, width, height); rc = (validSize == 0)? -1:0; ALOGD("%s: X", __func__); return rc; } /* usbCamSetPrvwSize */ /****************************************************************************** * Function: usbCamSetPictSize * Description: This function parses picture width and height from the input * parameters and stores into the context * * Input parameters: * camHal - camera HAL handle * params - QCameraParameters reference * * Return values: * 0 If parameters are valid * -1 If parameters are invalid * * Notes: none *****************************************************************************/ static int usbCamSetPictSize( camera_hardware_t *camHal, const QCameraParameters& params) { int rc = 0, width, height, i, numPictSizes, validSize; ALOGD("%s: E", __func__); /* parse for picture width and height */ params.getPictureSize(&width, &height); ALOGI("%s: Requested picture size %d x %d", __func__, width, height); // Validate the picture size numPictSizes = sizeof(picture_sizes) / sizeof(camera_size_type); for (i = 0, validSize = 0; i < numPictSizes; i++) { if (width == picture_sizes[i].width && height == picture_sizes[i].height) { validSize = 1; camHal->qCamParams.setPictureSize(width, height); ALOGD("%s: setPictureSize: width: %d height: %d", __func__, width, height); /* TBD: If new pictSize is different from old size, restart prvw */ camHal->pictWidth = width; camHal->pictHeight = height; } } if(!validSize) ALOGE("%s: Invalid picture size %dx%d requested", __func__, width, height); rc = (validSize == 0)? -1:0; ALOGD("%s: X", __func__); return rc; } /* usbCamSetPictSize */ /****************************************************************************** * Function: usbCamSetThumbnailSize * Description: This function parses picture width and height from the input * parameters and stores into the context * * Input parameters: * camHal - camera HAL handle * params - QCameraParameters reference * * Return values: * 0 If parameters are valid * -1 If parameters are invalid * * Notes: none *****************************************************************************/ static int usbCamSetThumbnailSize( camera_hardware_t *camHal, const QCameraParameters& params) { int rc = 0, width, height, i, numThumbnailSizes, validSize; char tempStr[FILENAME_LENGTH]; ALOGD("%s: E", __func__); /* parse for thumbnail width and height */ width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); ALOGI("%s: Requested thumbnail size %d x %d", __func__, width, height); // Validate the thumbnail size numThumbnailSizes = sizeof(thumbnail_sizes) / sizeof(camera_size_type); for (i = 0, validSize = 0; i < numThumbnailSizes; i++) { if (width == thumbnail_sizes[i].width && height == thumbnail_sizes[i].height) { validSize = 1; camHal->thumbnailWidth = width; camHal->thumbnailHeight = height; sprintf(tempStr, "%d", camHal->thumbnailWidth); camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width); sprintf(tempStr, "%d", camHal->thumbnailHeight); camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height); } } if(!validSize) ALOGE("%s: Invalid picture size %dx%d requested", __func__, width, height); rc = (validSize == 0)? -1:0; ALOGD("%s: X", __func__); return rc; } /* usbCamSetThumbnailSize */ /****************************************************************************** * Function: usbCamSetJpegQlty * Description: This function parses picture and thumbnail JPEG quality and * validates before storing in the context * * Input parameters: * camHal - camera HAL handle * params - QCameraParameters reference * * Return values: * 0 If parameters are valid * -1 If parameters are invalid * * Notes: none *****************************************************************************/ static int usbCamSetJpegQlty( camera_hardware_t *camHal, const QCameraParameters& params) { int rc = 0, quality = 0; char tempStr[FILENAME_LENGTH]; ALOGD("%s: E", __func__); /**/ quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY); ALOGI("%s: Requested picture qlty %d", __func__, quality); if (quality >= 0 && quality <= 100) { camHal->pictJpegQlty = quality; sprintf(tempStr, "%d", camHal->pictJpegQlty); camHal->qCamParams.set(QCameraParameters::KEY_JPEG_QUALITY, quality); } else { ALOGE("Invalid jpeg quality=%d", quality); rc = -1; } quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY); ALOGI("%s: Requested thumbnail qlty %d", __func__, quality); if (quality >= 0 && quality <= 100) { camHal->thumbnailJpegQlty = quality; sprintf(tempStr, "%d", camHal->thumbnailJpegQlty); camHal->qCamParams.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, tempStr); } else { ALOGE("Invalid jpeg thumbnail quality=%d", quality); rc = -1; } ALOGD("%s: X rc:%d", __func__, rc); return rc; } }; /*namespace android */