1279 lines
38 KiB
C++
1279 lines
38 KiB
C++
/*
|
|
* Copyright (C) Texas Instruments - http://www.ti.com/
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
* @file OMXCap.cpp
|
|
*
|
|
* This file implements the OMX Capabilities feature.
|
|
*
|
|
*/
|
|
|
|
#include "CameraHal.h"
|
|
#include "OMXCameraAdapter.h"
|
|
#include "ErrorUtils.h"
|
|
#include "TICameraParameters.h"
|
|
|
|
namespace android {
|
|
|
|
#undef LOG_TAG
|
|
|
|
// Maintain a separate tag for OMXCameraAdapter logs to isolate issues OMX specific
|
|
#define LOG_TAG "CameraHAL"
|
|
|
|
/************************************
|
|
* global constants and variables
|
|
*************************************/
|
|
|
|
#define ARRAY_SIZE(array) (sizeof((array)) / sizeof((array)[0]))
|
|
#define FPS_MIN 5
|
|
#define FPS_STEP 5
|
|
#define FPS_RANGE_STEP 5
|
|
|
|
static const char PARAM_SEP[] = ",";
|
|
static const int PARAM_SEP_CHAR = ',';
|
|
static const uint32_t VFR_OFFSET = 8;
|
|
static const char VFR_BACKET_START[] = "(";
|
|
static const char VFR_BRACKET_END[] = ")";
|
|
static const char FRAMERATE_COUNT = 10;
|
|
|
|
/**** look up tables to translate OMX Caps to Parameter ****/
|
|
|
|
const CapResolution OMXCameraAdapter::mImageCapRes [] = {
|
|
{ 4032, 3024, "4032x3024" },
|
|
{ 4000, 3000, "4000x3000" },
|
|
{ 3648, 2736, "3648x2736" },
|
|
{ 3264, 2448, "3264x2448" },
|
|
{ 2592, 1944, "2592x1944" },
|
|
{ 2592, 1728, "2592x1728" },
|
|
{ 2592, 1458, "2592x1458" },
|
|
{ 2048, 1536, "2048x1536" },
|
|
{ 1600, 1200, "1600x1200" },
|
|
{ 1280, 1024, "1280x1024" },
|
|
{ 1152, 864, "1152x864" },
|
|
{ 1280, 960, "1280x960" },
|
|
{ 640, 480, "640x480" },
|
|
{ 320, 240, "320x240" },
|
|
};
|
|
|
|
const CapResolution OMXCameraAdapter::mPreviewRes [] = {
|
|
{ 1920, 1080, "1920x1080" },
|
|
{ 1280, 720, "1280x720" },
|
|
{ 960, 720, "960x720" },
|
|
{ 800, 480, "800x480" },
|
|
{ 720, 576, "720x576" },
|
|
{ 720, 480, "720x480" },
|
|
{ 768, 576, "768x576" },
|
|
{ 640, 480, "640x480" },
|
|
{ 320, 240, "320x240" },
|
|
{ 352, 288, "352x288" },
|
|
{ 240, 160, "240x160" },
|
|
{ 176, 144, "176x144" },
|
|
{ 128, 96, "128x96" },
|
|
};
|
|
|
|
const CapResolution OMXCameraAdapter::mThumbRes [] = {
|
|
{ 640, 480, "640x480" },
|
|
{ 160, 120, "160x120" },
|
|
{ 200, 120, "200x120" },
|
|
{ 320, 240, "320x240" },
|
|
{ 512, 384, "512x384" },
|
|
{ 352, 144, "352x144" },
|
|
{ 176, 144, "176x144" },
|
|
{ 96, 96, "96x96" },
|
|
};
|
|
|
|
const CapPixelformat OMXCameraAdapter::mPixelformats [] = {
|
|
{ OMX_COLOR_FormatCbYCrY, CameraParameters::PIXEL_FORMAT_YUV422I },
|
|
{ OMX_COLOR_FormatYUV420SemiPlanar, CameraParameters::PIXEL_FORMAT_YUV420SP },
|
|
{ OMX_COLOR_Format16bitRGB565, CameraParameters::PIXEL_FORMAT_RGB565 },
|
|
{ OMX_COLOR_FormatRawBayer10bit, TICameraParameters::PIXEL_FORMAT_RAW },
|
|
{ OMX_COLOR_FormatYUV420SemiPlanar, CameraParameters::PIXEL_FORMAT_YUV420P },
|
|
};
|
|
|
|
const CapFramerate OMXCameraAdapter::mFramerates [] = {
|
|
{ 30, "30" },
|
|
{ 15, "15" },
|
|
};
|
|
|
|
const CapZoom OMXCameraAdapter::mZoomStages [] = {
|
|
{ 65536, "100" },
|
|
{ 68157, "104" },
|
|
{ 70124, "107" },
|
|
{ 72745, "111" },
|
|
{ 75366, "115" },
|
|
{ 77988, "119" },
|
|
{ 80609, "123" },
|
|
{ 83231, "127" },
|
|
{ 86508, "132" },
|
|
{ 89784, "137" },
|
|
{ 92406, "141" },
|
|
{ 95683, "146" },
|
|
{ 99615, "152" },
|
|
{ 102892, "157" },
|
|
{ 106168, "162" },
|
|
{ 110100, "168" },
|
|
{ 114033, "174" },
|
|
{ 117965, "180" },
|
|
{ 122552, "187" },
|
|
{ 126484, "193" },
|
|
{ 131072, "200" },
|
|
{ 135660, "207" },
|
|
{ 140247, "214" },
|
|
{ 145490, "222" },
|
|
{ 150733, "230" },
|
|
{ 155976, "238" },
|
|
{ 161219, "246" },
|
|
{ 167117, "255" },
|
|
{ 173015, "264" },
|
|
{ 178913, "273" },
|
|
{ 185467, "283" },
|
|
{ 192020, "293" },
|
|
{ 198574, "303" },
|
|
{ 205783, "314" },
|
|
{ 212992, "325" },
|
|
{ 220201, "336" },
|
|
{ 228065, "348" },
|
|
{ 236585, "361" },
|
|
{ 244449, "373" },
|
|
{ 252969, "386" },
|
|
{ 262144, "400" },
|
|
{ 271319, "414" },
|
|
{ 281149, "429" },
|
|
{ 290980, "444" },
|
|
{ 300810, "459" },
|
|
{ 311951, "476" },
|
|
{ 322437, "492" },
|
|
{ 334234, "510" },
|
|
{ 346030, "528" },
|
|
{ 357827, "546" },
|
|
{ 370934, "566" },
|
|
{ 384041, "586" },
|
|
{ 397148, "606" },
|
|
{ 411566, "628" },
|
|
{ 425984, "650" },
|
|
{ 441057, "673" },
|
|
{ 456131, "696" },
|
|
{ 472515, "721" },
|
|
{ 488899, "746" },
|
|
{ 506593, "773" },
|
|
{ 524288, "800" },
|
|
};
|
|
|
|
const CapISO OMXCameraAdapter::mISOStages [] = {
|
|
{ 0, "auto" },
|
|
{ 100, "100" },
|
|
{ 200, "200"},
|
|
{ 400, "400" },
|
|
{ 800, "800" },
|
|
{ 1000, "1000" },
|
|
{ 1200, "1200" },
|
|
{ 1600, "1600" },
|
|
};
|
|
|
|
// mapped values have to match with new_sensor_MSP.h
|
|
const CapU32 OMXCameraAdapter::mSensorNames [] = {
|
|
{ 300, "IMX060" },
|
|
{ 301, "OV5650" },
|
|
{ 305, "S5K4E1GA"},
|
|
{ 306, "S5K6A1GX03" }
|
|
// TODO(XXX): need to account for S3D camera later
|
|
};
|
|
|
|
// values for supported variable framerates sorted in ascending order
|
|
// CapU32Pair = (max fps, min fps, string representation)
|
|
const CapU32Pair OMXCameraAdapter::mVarFramerates [] = {
|
|
{ 15, 15, "(15000,15000)"},
|
|
{ 30, 15, "(15000,30000)" },
|
|
{ 30, 24, "(24000,30000)" },
|
|
// TODO(XXX): Removing 30,30 range to limit 1080p at 24fps. Will put back soon.
|
|
#if 0
|
|
{ 30, 30, "(30000,30000)" },
|
|
#endif
|
|
};
|
|
/************************************
|
|
* static helper functions
|
|
*************************************/
|
|
|
|
// utility function to remove last seperator
|
|
void remove_last_sep(char* buffer) {
|
|
char* last_sep = NULL;
|
|
last_sep = strrchr(buffer, PARAM_SEP_CHAR);
|
|
if (last_sep != NULL) {
|
|
last_sep[0] = '\0';
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************
|
|
* internal static function declarations
|
|
*****************************************/
|
|
|
|
/**** Utility functions to help translate OMX Caps to Parameter ****/
|
|
|
|
status_t OMXCameraAdapter::encodePixelformatCap(OMX_COLOR_FORMATTYPE format,
|
|
const CapPixelformat *cap,
|
|
size_t capCount,
|
|
char * buffer,
|
|
size_t bufferSize) {
|
|
status_t ret = NO_ERROR;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
if ( ( NULL == buffer ) || ( NULL == cap ) ) {
|
|
CAMHAL_LOGEA("Invalid input arguments");
|
|
return -EINVAL;
|
|
}
|
|
|
|
for ( unsigned int i = 0; i < capCount; i++ ) {
|
|
if ( format == cap[i].pixelformat ) {
|
|
strncat(buffer, cap[i].param, bufferSize - 1);
|
|
strncat(buffer, PARAM_SEP, bufferSize - 1);
|
|
}
|
|
}
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::encodeFramerateCap(OMX_U32 framerateMax,
|
|
OMX_U32 framerateMin,
|
|
const CapFramerate *cap,
|
|
size_t capCount,
|
|
char * buffer,
|
|
size_t bufferSize) {
|
|
status_t ret = NO_ERROR;
|
|
bool minInserted = false;
|
|
bool maxInserted = false;
|
|
char tmpBuffer[FRAMERATE_COUNT];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
if ( ( NULL == buffer ) || ( NULL == cap ) ) {
|
|
CAMHAL_LOGEA("Invalid input arguments");
|
|
return -EINVAL;
|
|
}
|
|
|
|
for ( unsigned int i = 0; i < capCount; i++ ) {
|
|
if ( (framerateMax >= cap[i].num) && (framerateMin <= cap[i].num) ) {
|
|
strncat(buffer, cap[i].param, bufferSize - 1);
|
|
strncat(buffer, PARAM_SEP, bufferSize - 1);
|
|
|
|
if ( cap[i].num == framerateMin ) {
|
|
minInserted = true;
|
|
}
|
|
}
|
|
if ( cap[i].num == framerateMax ) {
|
|
maxInserted = true;
|
|
}
|
|
}
|
|
|
|
if ( !maxInserted ) {
|
|
memset(tmpBuffer, 0, FRAMERATE_COUNT);
|
|
snprintf(tmpBuffer, FRAMERATE_COUNT - 1, "%u,", ( unsigned int ) framerateMax);
|
|
strncat(buffer, tmpBuffer, bufferSize - 1);
|
|
strncat(buffer, PARAM_SEP, bufferSize - 1);
|
|
}
|
|
|
|
if ( !minInserted ) {
|
|
memset(tmpBuffer, 0, FRAMERATE_COUNT);
|
|
snprintf(tmpBuffer, FRAMERATE_COUNT - 1, "%u,", ( unsigned int ) framerateMin);
|
|
strncat(buffer, tmpBuffer, bufferSize - 1);
|
|
strncat(buffer, PARAM_SEP, bufferSize - 1);
|
|
}
|
|
|
|
remove_last_sep(buffer);
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::encodeVFramerateCap(OMX_TI_CAPTYPE &caps,
|
|
const CapU32Pair *cap,
|
|
size_t capCount,
|
|
char *buffer,
|
|
char *defaultRange,
|
|
size_t bufferSize) {
|
|
status_t ret = NO_ERROR;
|
|
uint32_t minVFR, maxVFR;
|
|
int default_index = -1;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
if ( (NULL == buffer) || (NULL == cap) ) {
|
|
CAMHAL_LOGEA("Invalid input arguments");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if(caps.ulPrvVarFPSModesCount < 1) {
|
|
return NO_ERROR;
|
|
}
|
|
|
|
// Assumption: last range in tPrvVarFPSModes will be for S30FPSHD mode
|
|
minVFR = caps.tPrvVarFPSModes[caps.ulPrvVarFPSModesCount-1].nVarFPSMin >> VFR_OFFSET;
|
|
maxVFR = caps.tPrvVarFPSModes[caps.ulPrvVarFPSModesCount-1].nVarFPSMax >> VFR_OFFSET;
|
|
|
|
if (minVFR < FPS_MIN) {
|
|
minVFR = FPS_MIN;
|
|
}
|
|
|
|
for (unsigned int i = 0; i < capCount; i++) {
|
|
// add cap[i] if it is in range and maxVFR != minVFR
|
|
if ((maxVFR >= cap[i].num1) && (minVFR <= cap[i].num2)) {
|
|
if (buffer[0] != '\0') {
|
|
strncat(buffer, PARAM_SEP, bufferSize - 1);
|
|
}
|
|
strncat(buffer, cap[i].param, bufferSize - 1);
|
|
|
|
// choose the max variable framerate as default
|
|
if (cap[i].num1 != cap[i].num2) {
|
|
default_index = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we haven't found any caps in the list to populate
|
|
// just use the min and max
|
|
if (buffer[0] == '\0') {
|
|
snprintf(buffer, bufferSize - 1,
|
|
"(%u,%u)",
|
|
minVFR * CameraHal::VFR_SCALE,
|
|
maxVFR * CameraHal::VFR_SCALE);
|
|
}
|
|
|
|
if (default_index != -1) {
|
|
snprintf(defaultRange, (MAX_PROP_VALUE_LENGTH - 1), "%lu,%lu",
|
|
cap[default_index].num2 * CameraHal::VFR_SCALE,
|
|
cap[default_index].num1 * CameraHal::VFR_SCALE);
|
|
} else {
|
|
snprintf(defaultRange, (MAX_PROP_VALUE_LENGTH - 1), "%u,%u",
|
|
minVFR * CameraHal::VFR_SCALE, maxVFR * CameraHal::VFR_SCALE);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
|
|
return ret;
|
|
}
|
|
|
|
size_t OMXCameraAdapter::encodeZoomCap(OMX_S32 maxZoom,
|
|
const CapZoom *cap,
|
|
size_t capCount,
|
|
char * buffer,
|
|
size_t bufferSize) {
|
|
status_t res = NO_ERROR;
|
|
size_t ret = 0;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
if ( (NULL == buffer) || (NULL == cap) ) {
|
|
CAMHAL_LOGEA("Invalid input arguments");
|
|
return -EINVAL;
|
|
}
|
|
|
|
|
|
for ( unsigned int i = 0; i < capCount; i++ ) {
|
|
if ( cap[i].num <= maxZoom ) {
|
|
strncat(buffer, cap[i].param, bufferSize - 1);
|
|
strncat(buffer, PARAM_SEP, bufferSize - 1);
|
|
ret++;
|
|
}
|
|
}
|
|
remove_last_sep(buffer);
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::encodeISOCap(OMX_U32 maxISO,
|
|
const CapISO *cap,
|
|
size_t capCount,
|
|
char * buffer,
|
|
size_t bufferSize) {
|
|
status_t ret = NO_ERROR;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
if ( (NULL == buffer) || (NULL == cap) ) {
|
|
CAMHAL_LOGEA("Invalid input arguments");
|
|
return -EINVAL;
|
|
}
|
|
|
|
for ( unsigned int i = 0; i < capCount; i++ ) {
|
|
if ( cap[i].num <= maxISO) {
|
|
strncat(buffer, cap[i].param, bufferSize - 1);
|
|
strncat(buffer, PARAM_SEP, bufferSize - 1);
|
|
}
|
|
}
|
|
remove_last_sep(buffer);
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::encodeSizeCap(OMX_TI_CAPRESTYPE &res,
|
|
const CapResolution *cap,
|
|
size_t capCount,
|
|
char * buffer,
|
|
size_t bufferSize) {
|
|
status_t ret = NO_ERROR;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
if ( (NULL == buffer) || (NULL == cap) ) {
|
|
CAMHAL_LOGEA("Invalid input arguments");
|
|
return -EINVAL;
|
|
}
|
|
|
|
for ( unsigned int i = 0 ; i < capCount ; i++ ) {
|
|
if ( (cap[i].width <= res.nWidthMax) &&
|
|
(cap[i].height <= res.nHeightMax) &&
|
|
(cap[i].width >= res.nWidthMin) &&
|
|
(cap[i].height >= res.nHeightMin) ) {
|
|
strncat(buffer, cap[i].param, bufferSize -1);
|
|
strncat(buffer, PARAM_SEP, bufferSize - 1);
|
|
}
|
|
}
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertImageSizes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
ret = encodeSizeCap(caps.tImageResRange,
|
|
mImageCapRes,
|
|
ARRAY_SIZE(mImageCapRes),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported picture sizes 0x%x", ret);
|
|
} else {
|
|
remove_last_sep(supported);
|
|
params->set(CameraProperties::SUPPORTED_PICTURE_SIZES, supported);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertPreviewSizes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
ret = encodeSizeCap(caps.tPreviewResRange,
|
|
mPreviewRes,
|
|
ARRAY_SIZE(mPreviewRes),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported preview sizes 0x%x", ret);
|
|
} else {
|
|
remove_last_sep(supported);
|
|
params->set(CameraProperties::SUPPORTED_PREVIEW_SIZES, supported);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertVideoSizes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
ret = encodeSizeCap(caps.tPreviewResRange,
|
|
mPreviewRes,
|
|
ARRAY_SIZE(mPreviewRes),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported video sizes 0x%x", ret);
|
|
} else {
|
|
remove_last_sep(supported);
|
|
params->set(CameraProperties::SUPPORTED_VIDEO_SIZES, supported);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertThumbSizes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
ret = encodeSizeCap(caps.tThumbResRange,
|
|
mThumbRes,
|
|
ARRAY_SIZE(mThumbRes),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported thumbnail sizes 0x%x", ret);
|
|
} else {
|
|
//CTS Requirement: 0x0 should always be supported
|
|
strncat(supported, "0x0", MAX_PROP_NAME_LENGTH);
|
|
params->set(CameraProperties::SUPPORTED_THUMBNAIL_SIZES, supported);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertZoomStages(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps)
|
|
{
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
size_t zoomStageCount = 0;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
zoomStageCount = encodeZoomCap(caps.xMaxWidthZoom,
|
|
mZoomStages,
|
|
ARRAY_SIZE(mZoomStages),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
|
|
params->set(CameraProperties::SUPPORTED_ZOOM_RATIOS, supported);
|
|
params->set(CameraProperties::SUPPORTED_ZOOM_STAGES, zoomStageCount - 1); //As per CTS requirement
|
|
|
|
if ( 0 == zoomStageCount ) {
|
|
params->set(CameraProperties::ZOOM_SUPPORTED, TICameraParameters::ZOOM_UNSUPPORTED);
|
|
params->set(CameraProperties::SMOOTH_ZOOM_SUPPORTED, TICameraParameters::ZOOM_UNSUPPORTED);
|
|
} else {
|
|
params->set(CameraProperties::ZOOM_SUPPORTED, TICameraParameters::ZOOM_SUPPORTED);
|
|
params->set(CameraProperties::SMOOTH_ZOOM_SUPPORTED, TICameraParameters::ZOOM_SUPPORTED);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertImageFormats(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( int i = 0 ; i < caps.ulImageFormatCount ; i++ ) {
|
|
ret = encodePixelformatCap(caps.eImageFormats[i],
|
|
mPixelformats,
|
|
ARRAY_SIZE(mPixelformats),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported picture formats 0x%x", ret);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
//jpeg is not supported in OMX capabilies yet
|
|
strncat(supported, CameraParameters::PIXEL_FORMAT_JPEG, MAX_PROP_VALUE_LENGTH - 1);
|
|
params->set(CameraProperties::SUPPORTED_PICTURE_FORMATS, supported);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertPreviewFormats(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( int i = 0 ; i < caps.ulPreviewFormatCount; i++ ) {
|
|
ret = encodePixelformatCap(caps.ePreviewFormats[i],
|
|
mPixelformats,
|
|
ARRAY_SIZE(mPixelformats),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported preview formats 0x%x", ret);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
// need to advertise we support YV12 format
|
|
// We will program preview port with NV21 when we see application set YV12
|
|
strncat(supported, CameraParameters::PIXEL_FORMAT_YUV420P, MAX_PROP_VALUE_LENGTH - 1);
|
|
params->set(CameraProperties::SUPPORTED_PREVIEW_FORMATS, supported);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertFramerates(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
ret = encodeFramerateCap(caps.xFramerateMax >> VFR_OFFSET,
|
|
caps.xFramerateMin >> VFR_OFFSET,
|
|
mFramerates,
|
|
ARRAY_SIZE(mFramerates),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported preview framerates 0x%x", ret);
|
|
} else {
|
|
params->set(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES, supported);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertVFramerates(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
char defaultRange[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
ret = encodeVFramerateCap(caps,
|
|
mVarFramerates,
|
|
ARRAY_SIZE(mVarFramerates),
|
|
supported,
|
|
defaultRange,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported preview framerate ranges 0x%x", ret);
|
|
} else {
|
|
params->set(CameraProperties::FRAMERATE_RANGE_SUPPORTED, supported);
|
|
CAMHAL_LOGDB("framerate ranges %s", supported);
|
|
params->set(CameraProperties::FRAMERATE_RANGE, DEFAULT_FRAMERATE_RANGE_IMAGE);
|
|
params->set(CameraProperties::FRAMERATE_RANGE_VIDEO, DEFAULT_FRAMERATE_RANGE_VIDEO);
|
|
params->set(CameraProperties::FRAMERATE_RANGE_IMAGE, DEFAULT_FRAMERATE_RANGE_IMAGE);
|
|
CAMHAL_LOGDB("Default framerate range: [%s]", DEFAULT_FRAMERATE_RANGE_IMAGE);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertEVs(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
snprintf(supported, MAX_PROP_VALUE_LENGTH, "%d", ( int ) ( caps.xEVCompensationMin * 10 ));
|
|
params->set(CameraProperties::SUPPORTED_EV_MIN, supported);
|
|
|
|
snprintf(supported, MAX_PROP_VALUE_LENGTH, "%d", ( int ) ( caps.xEVCompensationMax * 10 ));
|
|
params->set(CameraProperties::SUPPORTED_EV_MAX, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertISOModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
ret = encodeISOCap(caps.nSensitivityMax,
|
|
mISOStages,
|
|
ARRAY_SIZE(mISOStages),
|
|
supported,
|
|
MAX_PROP_VALUE_LENGTH);
|
|
if ( NO_ERROR != ret ) {
|
|
CAMHAL_LOGEB("Error inserting supported ISO modes 0x%x", ret);
|
|
} else {
|
|
params->set(CameraProperties::SUPPORTED_ISO_VALUES, supported);
|
|
}
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertIPPModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
//Off is always supported
|
|
strncat(supported, TICameraParameters::IPP_NONE, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
|
|
if ( caps.bLensDistortionCorrectionSupported ) {
|
|
strncat(supported, TICameraParameters::IPP_LDC, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
|
|
if ( caps.bISONoiseFilterSupported ) {
|
|
strncat(supported, TICameraParameters::IPP_NSF, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
|
|
if ( caps.bISONoiseFilterSupported && caps.bLensDistortionCorrectionSupported ) {
|
|
strncat(supported, TICameraParameters::IPP_LDCNSF, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
|
|
remove_last_sep(supported);
|
|
params->set(CameraProperties::SUPPORTED_IPP_MODES, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertWBModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( unsigned int i = 0 ; i < caps.ulWhiteBalanceCount ; i++ ) {
|
|
p = getLUTvalue_OMXtoHAL(caps.eWhiteBalanceModes[i], WBalLUT);
|
|
if ( NULL != p ) {
|
|
strncat(supported, p, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
}
|
|
|
|
params->set(CameraProperties::SUPPORTED_WHITE_BALANCE, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertEffects(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( unsigned int i = 0 ; i < caps.ulColorEffectCount; i++ ) {
|
|
p = getLUTvalue_OMXtoHAL(caps.eColorEffects[i], EffLUT);
|
|
if ( NULL != p ) {
|
|
strncat(supported, p, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
}
|
|
remove_last_sep(supported);
|
|
params->set(CameraProperties::SUPPORTED_EFFECTS, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertExpModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( unsigned int i = 0 ; i < caps.ulExposureModeCount; i++ ) {
|
|
p = getLUTvalue_OMXtoHAL(caps.eExposureModes[i], ExpLUT);
|
|
if ( NULL != p ) {
|
|
strncat(supported, p, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
}
|
|
|
|
params->set(CameraProperties::SUPPORTED_EXPOSURE_MODES, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertFlashModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( unsigned int i = 0 ; i < caps.ulFlashCount; i++ ) {
|
|
p = getLUTvalue_OMXtoHAL(caps.eFlashModes[i], FlashLUT);
|
|
if ( NULL != p ) {
|
|
strncat(supported, p, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
}
|
|
|
|
remove_last_sep(supported);
|
|
params->set(CameraProperties::SUPPORTED_FLASH_MODES, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertSceneModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( unsigned int i = 0 ; i < caps.ulSceneCount; i++ ) {
|
|
p = getLUTvalue_OMXtoHAL(caps.eSceneModes[i], SceneLUT);
|
|
if ( NULL != p ) {
|
|
strncat(supported, p, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
}
|
|
|
|
remove_last_sep(supported);
|
|
params->set(CameraProperties::SUPPORTED_SCENE_MODES, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertFocusModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( unsigned int i = 0 ; i < caps.ulFocusModeCount; i++ ) {
|
|
p = getLUTvalue_OMXtoHAL(caps.eFocusModes[i], FocusLUT);
|
|
if ( NULL != p ) {
|
|
strncat(supported, p, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
}
|
|
|
|
// Check if focus is supported by camera
|
|
if (caps.ulFocusModeCount == 1 &&
|
|
caps.eFocusModes[0] == OMX_IMAGE_FocusControlOff) {
|
|
// Focus is not supported by camera
|
|
// Advertise this to app as infinitiy focus mode
|
|
strncat(supported, CameraParameters::FOCUS_MODE_INFINITY, MAX_PROP_NAME_LENGTH);
|
|
} else {
|
|
// Focus is supported but these modes are not supported by the
|
|
// capability feature. Apply manually
|
|
strncat(supported, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE, MAX_PROP_NAME_LENGTH);
|
|
}
|
|
|
|
params->set(CameraProperties::SUPPORTED_FOCUS_MODES, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertFlickerModes(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
for ( unsigned int i = 0 ; i < caps.ulFlickerCount; i++ ) {
|
|
p = getLUTvalue_OMXtoHAL(caps.eFlicker[i], FlickerLUT);
|
|
if ( NULL != p ) {
|
|
strncat(supported, p, MAX_PROP_NAME_LENGTH);
|
|
strncat(supported, PARAM_SEP, 1);
|
|
}
|
|
}
|
|
remove_last_sep(supported);
|
|
params->set(CameraProperties::SUPPORTED_ANTIBANDING, supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertAreas(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
sprintf(supported, "%d", caps.ulAlgoAreasFocusCount);
|
|
params->set(CameraProperties::MAX_FOCUS_AREAS, supported);
|
|
CAMHAL_LOGDB("Maximum supported focus areas %s", supported);
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
sprintf(supported, "%d", caps.ulAlgoAreasExposureCount);
|
|
params->set(CameraProperties::MAX_NUM_METERING_AREAS, supported);
|
|
CAMHAL_LOGDB("Maximum supported exposure areas %s", supported);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertLocks(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
|
|
LOG_FUNCTION_NAME
|
|
|
|
params->set(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED, DEFAULT_LOCK_SUPPORTED);
|
|
params->set(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED, DEFAULT_LOCK_SUPPORTED);
|
|
|
|
LOG_FUNCTION_NAME
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertDefaults(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
params->set(CameraProperties::ANTIBANDING, DEFAULT_ANTIBANDING);
|
|
params->set(CameraProperties::BRIGHTNESS, DEFAULT_BRIGHTNESS);
|
|
params->set(CameraProperties::CONTRAST, DEFAULT_CONTRAST);
|
|
params->set(CameraProperties::EFFECT, DEFAULT_EFFECT);
|
|
params->set(CameraProperties::EV_COMPENSATION, DEFAULT_EV_COMPENSATION);
|
|
params->set(CameraProperties::SUPPORTED_EV_STEP, DEFAULT_EV_STEP);
|
|
params->set(CameraProperties::EXPOSURE_MODE, DEFAULT_EXPOSURE_MODE);
|
|
params->set(CameraProperties::FLASH_MODE, DEFAULT_FLASH_MODE);
|
|
char *pos = strstr(params->get(CameraProperties::SUPPORTED_FOCUS_MODES), DEFAULT_FOCUS_MODE_PREFERRED);
|
|
if ( NULL != pos )
|
|
{
|
|
params->set(CameraProperties::FOCUS_MODE, DEFAULT_FOCUS_MODE_PREFERRED);
|
|
}
|
|
else
|
|
{
|
|
params->set(CameraProperties::FOCUS_MODE, DEFAULT_FOCUS_MODE);
|
|
}
|
|
params->set(CameraProperties::IPP, DEFAULT_IPP);
|
|
params->set(CameraProperties::GBCE, DEFAULT_GBCE);
|
|
params->set(CameraProperties::ISO_MODE, DEFAULT_ISO_MODE);
|
|
params->set(CameraProperties::JPEG_QUALITY, DEFAULT_JPEG_QUALITY);
|
|
params->set(CameraProperties::JPEG_THUMBNAIL_QUALITY, DEFAULT_THUMBNAIL_QUALITY);
|
|
params->set(CameraProperties::JPEG_THUMBNAIL_SIZE, DEFAULT_THUMBNAIL_SIZE);
|
|
params->set(CameraProperties::PICTURE_FORMAT, DEFAULT_PICTURE_FORMAT);
|
|
params->set(CameraProperties::PICTURE_SIZE, DEFAULT_PICTURE_SIZE);
|
|
params->set(CameraProperties::PREVIEW_FORMAT, DEFAULT_PREVIEW_FORMAT);
|
|
params->set(CameraProperties::PREVIEW_FRAME_RATE, DEFAULT_FRAMERATE);
|
|
params->set(CameraProperties::PREVIEW_SIZE, DEFAULT_PREVIEW_SIZE);
|
|
params->set(CameraProperties::REQUIRED_PREVIEW_BUFS, DEFAULT_NUM_PREV_BUFS);
|
|
params->set(CameraProperties::REQUIRED_IMAGE_BUFS, DEFAULT_NUM_PIC_BUFS);
|
|
params->set(CameraProperties::SATURATION, DEFAULT_SATURATION);
|
|
params->set(CameraProperties::SCENE_MODE, DEFAULT_SCENE_MODE);
|
|
params->set(CameraProperties::SHARPNESS, DEFAULT_SHARPNESS);
|
|
params->set(CameraProperties::VSTAB, DEFAULT_VSTAB);
|
|
params->set(CameraProperties::VSTAB_SUPPORTED, DEFAULT_VSTAB_SUPPORTED);
|
|
params->set(CameraProperties::WHITEBALANCE, DEFAULT_WB);
|
|
params->set(CameraProperties::ZOOM, DEFAULT_ZOOM);
|
|
params->set(CameraProperties::MAX_FD_HW_FACES, DEFAULT_MAX_FD_HW_FACES);
|
|
params->set(CameraProperties::MAX_FD_SW_FACES, DEFAULT_MAX_FD_SW_FACES);
|
|
params->set(CameraProperties::AUTO_EXPOSURE_LOCK, DEFAULT_AE_LOCK);
|
|
params->set(CameraProperties::AUTO_WHITEBALANCE_LOCK, DEFAULT_AWB_LOCK);
|
|
if(caps.tSenMounting.nSenId == 305) {
|
|
params->set(CameraProperties::FOCAL_LENGTH, DEFAULT_FOCAL_LENGTH_PRIMARY);
|
|
} else {
|
|
params->set(CameraProperties::FOCAL_LENGTH, DEFAULT_FOCAL_LENGTH_SECONDARY);
|
|
}
|
|
params->set(CameraProperties::HOR_ANGLE, DEFAULT_HOR_ANGLE);
|
|
params->set(CameraProperties::VER_ANGLE, DEFAULT_VER_ANGLE);
|
|
params->set(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED, DEFAULT_VIDEO_SNAPSHOT_SUPPORTED);
|
|
params->set(CameraProperties::VIDEO_SIZE, DEFAULT_VIDEO_SIZE);
|
|
params->set(CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO, DEFAULT_PREFERRED_PREVIEW_SIZE_FOR_VIDEO);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertSenMount(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
const char *p;
|
|
unsigned int i = 0;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
|
|
|
|
// 1) Look up and assign sensor name
|
|
for (i = 0; i < ARRAY_SIZE(mSensorNames); i++) {
|
|
if(mSensorNames[i].num == caps.tSenMounting.nSenId) {
|
|
// sensor found
|
|
break;
|
|
}
|
|
}
|
|
if ( i == ARRAY_SIZE(mSensorNames) ) {
|
|
p = "UNKNOWN_SENSOR";
|
|
} else {
|
|
p = mSensorNames[i].param;
|
|
}
|
|
strncat(supported, p, MAX_PROP_NAME_LENGTH);
|
|
params->set(CameraProperties::CAMERA_NAME, supported);
|
|
|
|
// 2) Assign mounting rotation
|
|
params->set(CameraProperties::ORIENTATION_INDEX, caps.tSenMounting.nRotation);
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
return ret;
|
|
}
|
|
|
|
status_t OMXCameraAdapter::insertCapabilities(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps) {
|
|
status_t ret = NO_ERROR;
|
|
char supported[MAX_PROP_VALUE_LENGTH];
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertImageSizes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertPreviewSizes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertThumbSizes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertZoomStages(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertImageFormats(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertPreviewFormats(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertFramerates(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertVFramerates(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertEVs(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertISOModes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertIPPModes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertWBModes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertEffects(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertExpModes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertFlashModes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertSceneModes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertFocusModes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertFlickerModes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertSenMount(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertLocks(params, caps);
|
|
}
|
|
if ( NO_ERROR == ret) {
|
|
ret = insertAreas(params, caps);
|
|
|
|
}
|
|
|
|
//NOTE: Ensure that we always call insertDefaults after inserting the supported capabilities
|
|
//as there are checks inside insertDefaults to make sure a certain default is supported
|
|
// or not
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertVideoSizes(params, caps);
|
|
}
|
|
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertDefaults(params, caps);
|
|
}
|
|
|
|
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*****************************************
|
|
* public exposed function declarations
|
|
*****************************************/
|
|
|
|
status_t OMXCameraAdapter::getCaps(CameraProperties::Properties* params, OMX_HANDLETYPE handle) {
|
|
status_t ret = NO_ERROR;
|
|
int caps_size = 0;
|
|
OMX_ERRORTYPE eError = OMX_ErrorNone;
|
|
OMX_TI_CAPTYPE** caps = NULL;;
|
|
OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
|
|
MemoryManager memMgr;
|
|
|
|
LOG_FUNCTION_NAME;
|
|
|
|
// allocate tiler (or ion) buffer for caps (size is always a multiple of 4K)
|
|
caps_size = ((sizeof(OMX_TI_CAPTYPE)+4095)/4096)*4096;
|
|
caps = (OMX_TI_CAPTYPE**) memMgr.allocateBuffer(0, 0, NULL, caps_size, 1);
|
|
|
|
if (!caps) {
|
|
CAMHAL_LOGEB("Error allocating buffer for caps %d", eError);
|
|
ret = -ENOMEM;
|
|
goto EXIT;
|
|
}
|
|
|
|
// initialize structures to be passed to OMX Camera
|
|
OMX_INIT_STRUCT_PTR (caps[0], OMX_TI_CAPTYPE);
|
|
caps[0]->nPortIndex = OMX_ALL;
|
|
|
|
OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
|
|
sharedBuffer.nPortIndex = OMX_ALL;
|
|
sharedBuffer.nSharedBuffSize = caps_size;
|
|
sharedBuffer.pSharedBuff = (OMX_U8 *) caps[0];
|
|
|
|
// Get capabilities from OMX Camera
|
|
eError = OMX_GetConfig(handle, (OMX_INDEXTYPE) OMX_TI_IndexConfigCamCapabilities, &sharedBuffer);
|
|
if ( OMX_ErrorNone != eError ) {
|
|
CAMHAL_LOGEB("Error during capabilities query 0x%x", eError);
|
|
ret = UNKNOWN_ERROR;
|
|
goto EXIT;
|
|
} else {
|
|
CAMHAL_LOGDA("OMX capability query success");
|
|
}
|
|
|
|
// Translate and insert Ducati capabilities to CameraProperties
|
|
if ( NO_ERROR == ret ) {
|
|
ret = insertCapabilities(params, *caps[0]);
|
|
}
|
|
|
|
CAMHAL_LOGDB("sen mount id=%u", (unsigned int)caps[0]->tSenMounting.nSenId);
|
|
|
|
|
|
EXIT:
|
|
if (caps) {
|
|
memMgr.freeBuffer((void*) caps);
|
|
caps = NULL;
|
|
}
|
|
|
|
LOG_FUNCTION_NAME_EXIT;
|
|
return ret;
|
|
}
|
|
|
|
};
|
|
|