xref: /hardware/qcom/camera/msm8998/usbcamcore/src/QCameraUsbParm.cpp

/* 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 <utils/Log.h>

#include <utils/Errors.h>
#include <utils/threads.h>
#include <utils/String16.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <cutils/properties.h>
#include <math.h>
#if HAVE_ANDROID_OS
#include <linux/android_pmem.h>
#endif
#include <linux/ioctl.h>
#include <camera/QCameraParameters.h>
#include <media/mediarecorder.h>
#include <gralloc_priv.h>

#include "linux/msm_mdp.h"
#include <linux/fb.h>
#include <limits.h>


extern "C" {
#include <fcntl.h>
#include <time.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <termios.h>
#include <assert.h>
#include <stdlib.h>
#include <ctype.h>
#include <signal.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/system_properties.h>
#include <sys/time.h>
#include <stdlib.h>
#include <linux/msm_ion.h>
#include <camera.h>
#include <cam_fifo.h>
#include <jpege.h>

} // 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 */