summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--camera/CameraHal.cpp200
-rw-r--r--camera/CameraParameters.cpp2
-rw-r--r--camera/OMXCameraAdapter/OMXCameraAdapter.cpp30
-rw-r--r--camera/OMXCameraAdapter/OMXCapabilities.cpp164
-rw-r--r--camera/TICameraParameters.cpp2
-rw-r--r--camera/inc/CameraHal.h73
-rw-r--r--camera/inc/CameraProperties.h2
-rw-r--r--camera/inc/OMXCameraAdapter/OMXCameraAdapter.h9
-rw-r--r--camera/inc/TICameraParameters.h2
9 files changed, 250 insertions, 234 deletions
diff --git a/camera/CameraHal.cpp b/camera/CameraHal.cpp
index 6735e7b..168629c 100644
--- a/camera/CameraHal.cpp
+++ b/camera/CameraHal.cpp
@@ -245,20 +245,14 @@ int CameraHal::setParameters(const CameraParameters& params)
LOG_FUNCTION_NAME;
int w, h;
- int framerate,minframerate;
+ int framerate;
int maxFPS, minFPS;
- int error;
- int base;
const char *valstr = NULL;
- const char *prevFormat;
- char *af_coord;
status_t ret = NO_ERROR;
// Needed for KEY_RECORDING_HINT
bool restartPreviewRequired = false;
bool updateRequired = false;
CameraParameters oldParams(mParameters.flatten());
- bool videoMode = false;
- char range[MAX_PROP_VALUE_LENGTH];
{
Mutex::Autolock lock(mLock);
@@ -388,7 +382,6 @@ int CameraHal::setParameters(const CameraParameters& params)
{
CAMHAL_LOGDB("Recording Hint is set to %s", valstr);
mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr);
- videoMode = true;
int w, h;
params.getPreviewSize(&w, &h);
@@ -500,103 +493,45 @@ int CameraHal::setParameters(const CameraParameters& params)
}
}
- framerate = params.getPreviewFrameRate();
- valstr = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE);
- CAMHAL_LOGDB("FRAMERATE %d", framerate);
-
- CAMHAL_LOGVB("Passed FRR: %s, Supported FRR %s", valstr
- , mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
- CAMHAL_LOGVB("Passed FR: %d, Supported FR %s", framerate
- , mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
-
-
- //Perform parameter validation
- if(!isParameterValid(valstr
- , mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED)))
- {
- CAMHAL_LOGDA(" FPS Range is invalid. Ckeck the Frame Rate param ");
- if(!isParameterValid(framerate,
- mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)))
- {
- CAMHAL_LOGEA("Invalid frame rate ");
- return BAD_VALUE;
- }
- }
-
// Variable framerate ranges have higher priority over
// deprecated constant FPS. "KEY_PREVIEW_FPS_RANGE" should
// be cleared by the client in order for constant FPS to get
// applied.
- // If Port FPS needs to be used for configuring , then FPS RANGE should not be set by the APP.
- if ( valstr != NULL)
- {
+ // If Port FPS needs to be used for configuring, then FPS RANGE should not be set by the APP.
+ valstr = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE);
+ framerate = 0;
+ if (valstr != NULL && strlen(valstr)) {
// APP wants to set FPS range
- //Set framerate = MAXFPS
+ // Set framerate = MAXFPS
CAMHAL_LOGDA("APP IS CHANGING FRAME RATE RANGE");
- params.getPreviewFpsRange(&minFPS, &maxFPS);
- if ( ( 0 > minFPS ) || ( 0 > maxFPS ) )
- {
- CAMHAL_LOGEA("ERROR: FPS Range is negative!");
+ params.getPreviewFpsRange(&minFPS, &maxFPS);
+ // Validate VFR
+ if (!isFpsRangeValid(minFPS, maxFPS, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE))) {
+ CAMHAL_LOGEA("Invalid FPS Range");
+ } else {
+ framerate = maxFPS / CameraHal::VFR_SCALE;
+ mParameters.setPreviewFrameRate(framerate);
+ CAMHAL_LOGDB("SET FRAMERATE %d", framerate);
+ CAMHAL_LOGDB("FPS Range = %s", valstr);
+ mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
+ }
+ }
+ if (!framerate) {
+ framerate = params.getPreviewFrameRate();
+ if (!isParameterValid(framerate, params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES))) {
+ CAMHAL_LOGEA("Invalid frame rate");
return BAD_VALUE;
- }
-
- framerate = maxFPS /CameraHal::VFR_SCALE;
-
- }
- else
- {
- if ( framerate != atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)) )
- {
-
- selectFPSRange(framerate, &minFPS, &maxFPS);
- CAMHAL_LOGDB("Select FPS Range %d %d", minFPS, maxFPS);
- }
- else
- {
- if (videoMode) {
- valstr = mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_VIDEO);
- CameraParameters temp;
- temp.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
- temp.getPreviewFpsRange(&minFPS, &maxFPS);
- }
- else {
- valstr = mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_IMAGE);
- CameraParameters temp;
- temp.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
- temp.getPreviewFpsRange(&minFPS, &maxFPS);
- }
-
- framerate = maxFPS / CameraHal::VFR_SCALE;
- }
+ }
+ char tmpBuffer[MAX_PROP_VALUE_LENGTH];
+ sprintf(tmpBuffer, "%d,%d", framerate * CameraHal::VFR_SCALE, framerate * CameraHal::VFR_SCALE);
+ mParameters.setPreviewFrameRate(framerate);
+ CAMHAL_LOGDB("SET FRAMERATE %d", framerate);
+ mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, tmpBuffer);
+ CAMHAL_LOGDB("FPS Range = %s", tmpBuffer);
}
- CAMHAL_LOGDB("FPS Range = %s", valstr);
- CAMHAL_LOGDB("DEFAULT FPS Range = %s", mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
-
- minFPS /= CameraHal::VFR_SCALE;
- maxFPS /= CameraHal::VFR_SCALE;
-
- if ( ( 0 == minFPS ) || ( 0 == maxFPS ) )
- {
- CAMHAL_LOGEA("ERROR: FPS Range is invalid!");
- return BAD_VALUE;
- }
-
- if ( maxFPS < minFPS )
- {
- CAMHAL_LOGEA("ERROR: Max FPS is smaller than Min FPS!");
- return BAD_VALUE;
- }
- CAMHAL_LOGDB("SET FRAMERATE %d", framerate);
- mParameters.setPreviewFrameRate(framerate);
- mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE));
-
- CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS);
- mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS);
- mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS);
-
if ((valstr = params.get(TICameraParameters::KEY_GBCE)) != NULL) {
if (strcmp(mCameraProperties->get(CameraProperties::SUPPORTED_GBCE),
CameraParameters::TRUE) == 0) {
@@ -3244,6 +3179,44 @@ exit:
return ret;
}
+bool CameraHal::isFpsRangeValid(int fpsMin, int fpsMax, const char *supportedFpsRanges)
+{
+ bool ret = false;
+ char supported[MAX_PROP_VALUE_LENGTH];
+ char *pos;
+ int suppFpsRangeArray[2];
+ int i = 0;
+
+ LOG_FUNCTION_NAME;
+
+ if ( NULL == supportedFpsRanges ) {
+ CAMHAL_LOGEA("Invalid supported FPS ranges string");
+ return false;
+ }
+
+ if (fpsMin <= 0 || fpsMax <= 0 || fpsMin > fpsMax) {
+ return false;
+ }
+
+ strncpy(supported, supportedFpsRanges, MAX_PROP_VALUE_LENGTH);
+ pos = strtok(supported, " (,)");
+ while (pos != NULL) {
+ suppFpsRangeArray[i] = atoi(pos);
+ if (i++) {
+ if (fpsMin >= suppFpsRangeArray[0] && fpsMax <= suppFpsRangeArray[1]) {
+ ret = true;
+ break;
+ }
+ i = 0;
+ }
+ pos = strtok(NULL, " (,)");
+ }
+
+ LOG_FUNCTION_NAME_EXIT;
+
+ return ret;
+}
+
bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
{
bool ret = true;
@@ -3412,6 +3385,7 @@ void CameraHal::insertSupportedParams()
p.set(TICameraParameters::KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES));
p.set(TICameraParameters::KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_TOPBOTTOM_SIZES));
p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
+ p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES));
p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE));
p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS));
@@ -3443,7 +3417,6 @@ void CameraHal::insertSupportedParams()
p.set(TICameraParameters::KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_MANUAL_CONVERGENCE_STEP));
p.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED));
p.set(TICameraParameters::KEY_VNF_SUPPORTED, mCameraProperties->get(CameraProperties::VNF_SUPPORTED));
- p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED));
@@ -3508,6 +3481,7 @@ void CameraHal::initDefaultParameters()
//Insert default values
p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)));
+ p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT));
p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT));
p.set(CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY));
@@ -3544,7 +3518,6 @@ void CameraHal::initDefaultParameters()
p.set(CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH));
p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE));
p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE));
- p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE));
@@ -3653,41 +3626,6 @@ status_t CameraHal::storeMetaDataInBuffers(bool enable)
LOG_FUNCTION_NAME_EXIT;
}
-void CameraHal::selectFPSRange(int framerate, int *min_fps, int *max_fps)
-{
- char * ptr;
- char supported[MAX_PROP_VALUE_LENGTH];
- int fpsrangeArray[2];
- int i = 0;
-
- LOG_FUNCTION_NAME;
- size_t size = strlen(mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED))+1;
- strncpy(supported, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED), size);
-
- ptr = strtok (supported," (,)");
-
- while (ptr != NULL)
- {
- fpsrangeArray[i]= atoi(ptr)/CameraHal::VFR_SCALE;
- if (i == 1)
- {
- if (framerate == fpsrangeArray[i])
- {
- CAMHAL_LOGDB("SETTING FPS RANGE min = %d max = %d \n", fpsrangeArray[0], fpsrangeArray[1]);
- *min_fps = fpsrangeArray[0]*CameraHal::VFR_SCALE;
- *max_fps = fpsrangeArray[1]*CameraHal::VFR_SCALE;
- break;
- }
- }
- ptr = strtok (NULL, " (,)");
- i++;
- i%=2;
- }
-
- LOG_FUNCTION_NAME_EXIT;
-
-}
-
bool CameraHal::checkFramerateThr(const CameraParameters &params)
{
static CameraParameters current_Params = mParameters;
diff --git a/camera/CameraParameters.cpp b/camera/CameraParameters.cpp
index 21d4f9a..bb8ad13 100644
--- a/camera/CameraParameters.cpp
+++ b/camera/CameraParameters.cpp
@@ -113,8 +113,6 @@ const char CameraProperties::FOCAL_LENGTH[] = "prop-focal-length";
const char CameraProperties::HOR_ANGLE[] = "prop-horizontal-angle";
const char CameraProperties::VER_ANGLE[] = "prop-vertical-angle";
const char CameraProperties::FRAMERATE_RANGE[] = "prop-framerate-range-default";
-const char CameraProperties::FRAMERATE_RANGE_IMAGE[] = "prop-framerate-range-image-default";
-const char CameraProperties::FRAMERATE_RANGE_VIDEO[]="prop-framerate-range-video-default";
const char CameraProperties::FRAMERATE_RANGE_SUPPORTED[]="prop-framerate-range-values";
const char CameraProperties::SENSOR_ORIENTATION[]= "sensor-orientation";
const char CameraProperties::SENSOR_ORIENTATION_VALUES[]= "sensor-orientation-values";
diff --git a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
index 7825e00..267ef67 100644
--- a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
+++ b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
@@ -507,30 +507,26 @@ status_t OMXCameraAdapter::setParameters(const CameraParameters &params)
params.getPreviewSize(&w, &h);
frameRate = params.getPreviewFrameRate();
- minFramerate = params.getInt(TICameraParameters::KEY_MINFRAMERATE);
- maxFramerate = params.getInt(TICameraParameters::KEY_MAXFRAMERATE);
- if ( ( 0 < minFramerate ) &&
- ( 0 < maxFramerate ) )
- {
- if ( minFramerate > maxFramerate )
- {
- CAMHAL_LOGEA(" Min FPS set higher than MAX. So setting MIN and MAX to the higher value");
- maxFramerate = minFramerate;
- }
+ params.getPreviewFpsRange(&minFramerate, &maxFramerate);
+ minFramerate /= CameraHal::VFR_SCALE;
+ maxFramerate /= CameraHal::VFR_SCALE;
+ if ( ( 0 < minFramerate ) && ( 0 < maxFramerate ) ) {
+ if ( minFramerate > maxFramerate ) {
+ CAMHAL_LOGEA(" Min FPS set higher than MAX. So setting MIN and MAX to the higher value");
+ maxFramerate = minFramerate;
+ }
- if ( 0 >= frameRate )
- {
+ if ( 0 >= frameRate ) {
frameRate = maxFramerate;
- }
+ }
- if( ( cap->mMinFrameRate != minFramerate ) ||
- ( cap->mMaxFrameRate != maxFramerate ) )
- {
+ if ( ( cap->mMinFrameRate != (OMX_U32) minFramerate ) ||
+ ( cap->mMaxFrameRate != (OMX_U32) maxFramerate ) ) {
cap->mMinFrameRate = minFramerate;
cap->mMaxFrameRate = maxFramerate;
setVFramerate(cap->mMinFrameRate, cap->mMaxFrameRate);
- }
}
+ }
if ( 0 < frameRate )
{
diff --git a/camera/OMXCameraAdapter/OMXCapabilities.cpp b/camera/OMXCameraAdapter/OMXCapabilities.cpp
index 80a0cca..a8af939 100644
--- a/camera/OMXCameraAdapter/OMXCapabilities.cpp
+++ b/camera/OMXCameraAdapter/OMXCapabilities.cpp
@@ -37,9 +37,7 @@ namespace android {
static const char PARAM_SEP[] = ",";
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;
+static const char FPS_STR_MAX_LEN = 10;
static const unsigned int MANUAL_EXPOSURE_STEP = 1;
static const unsigned int MANUAL_GAIN_ISO_MIN = 100;
@@ -209,7 +207,9 @@ const CapCodingFormat OMXCameraAdapter::mImageCodingFormat [] = {
const CapFramerate OMXCameraAdapter::mFramerates [] = {
{ 30, "30" },
{ 24, "24" },
+ { 20, "20" },
{ 15, "15" },
+ { 10, "10" },
};
const CapZoom OMXCameraAdapter::mZoomStages [] = {
@@ -412,7 +412,8 @@ status_t OMXCameraAdapter::encodeFramerateCap(OMX_U32 framerateMax,
size_t bufferSize)
{
status_t ret = NO_ERROR;
- char tmpBuffer[FRAMERATE_COUNT];
+ char tmpBuffer[FPS_STR_MAX_LEN];
+ unsigned int param_sep_length = strlen(PARAM_SEP);
LOG_FUNCTION_NAME;
@@ -421,24 +422,28 @@ status_t OMXCameraAdapter::encodeFramerateCap(OMX_U32 framerateMax,
return -EINVAL;
}
- memset(tmpBuffer, '\0', FRAMERATE_COUNT);
- snprintf(tmpBuffer, FRAMERATE_COUNT - 1, "%lu", framerateMax);
+ memset(tmpBuffer, '\0', FPS_STR_MAX_LEN);
+ snprintf(tmpBuffer, FPS_STR_MAX_LEN - 1, "%lu", framerateMax);
strncat(buffer, tmpBuffer, bufferSize - 1);
+ bufferSize -= strlen(tmpBuffer);
for ( unsigned int i = 0; i < capCount; i++ ) {
if ( (framerateMax > cap[i].num) && (framerateMin < cap[i].num) ) {
strncat(buffer, PARAM_SEP, bufferSize - 1);
+ bufferSize -= param_sep_length;
strncat(buffer, cap[i].param, bufferSize - 1);
+ bufferSize -= strlen(cap[i].param);
}
}
- memset(tmpBuffer, '\0', FRAMERATE_COUNT);
+ memset(tmpBuffer, '\0', FPS_STR_MAX_LEN);
if ( FPS_MIN < framerateMin ) {
- snprintf(tmpBuffer, FRAMERATE_COUNT - 1, "%lu", framerateMin);
+ snprintf(tmpBuffer, FPS_STR_MAX_LEN - 1, "%lu", framerateMin);
} else {
- snprintf(tmpBuffer, FRAMERATE_COUNT - 1, "%d", FPS_MIN);
+ snprintf(tmpBuffer, FPS_STR_MAX_LEN - 1, "%d", FPS_MIN);
}
strncat(buffer, PARAM_SEP, bufferSize - 1);
+ bufferSize -= param_sep_length;
strncat(buffer, tmpBuffer, bufferSize - 1);
LOG_FUNCTION_NAME_EXIT;
@@ -447,14 +452,16 @@ status_t OMXCameraAdapter::encodeFramerateCap(OMX_U32 framerateMax,
}
status_t OMXCameraAdapter::encodeVFramerateCap(OMX_TI_CAPTYPE &caps,
+ const CapFramerate *cap,
+ size_t capCount,
+ int & minFixedFps,
+ int & maxFixedFps,
char *buffer,
char *defaultRange,
size_t bufferSize)
{
status_t ret = NO_ERROR;
- int default_index = 0;
unsigned int param_sep_length = strlen(PARAM_SEP);
- char *pos;
LOG_FUNCTION_NAME;
@@ -467,39 +474,66 @@ status_t OMXCameraAdapter::encodeVFramerateCap(OMX_TI_CAPTYPE &caps,
return NO_ERROR;
}
- for (unsigned int i = 0; i < caps.ulPrvVarFPSModesCount; i++) {
- uint32_t minVFR, maxVFR;
- unsigned int current_idx;
+ minFixedFps = -1;
+ maxFixedFps = -1;
- minVFR = caps.tPrvVarFPSModes[i].nVarFPSMin >> VFR_OFFSET;
+ Vector<FpsRange> fpsRanges;
+
+ for ( int i = 0; i < static_cast<int>(caps.ulPrvVarFPSModesCount); ++i ) {
+ uint32_t minVFR = caps.tPrvVarFPSModes[i].nVarFPSMin >> VFR_OFFSET;
if (minVFR < FPS_MIN) {
minVFR = FPS_MIN;
}
- maxVFR = caps.tPrvVarFPSModes[i].nVarFPSMax >> VFR_OFFSET;
+ uint32_t maxVFR = caps.tPrvVarFPSModes[i].nVarFPSMax >> VFR_OFFSET;
- current_idx = strlen(buffer);
- if (current_idx != 0) {
- strncat(buffer, PARAM_SEP, bufferSize - current_idx - 1);
- current_idx += param_sep_length;
+ const FpsRange fpsRange = FpsRange::create(minVFR, maxVFR);
+
+ if ( minFixedFps == -1 || minFixedFps > fpsRange.min() ) {
+ minFixedFps = fpsRange.min();
}
+ if ( maxFixedFps == -1 || maxFixedFps < fpsRange.max() ) {
+ maxFixedFps = fpsRange.max();
+ }
+
+ fpsRanges.add(fpsRange);
+ }
- // choose the max variable framerate as default
- if (minVFR != maxVFR) {
- default_index = current_idx;
+ for ( int i = 0; i < static_cast<int>(capCount); ++i ) {
+ const int fps = cap[i].num;
+
+ if ( fps < minFixedFps || fps > maxFixedFps ) {
+ continue;
}
- snprintf(&buffer[current_idx], bufferSize - current_idx - 1,
- "(%u%s%u)",
- minVFR * CameraHal::VFR_SCALE,
- PARAM_SEP,
- maxVFR * CameraHal::VFR_SCALE);
+ const FpsRange fpsRange = FpsRange::create(fps, fps);
+ fpsRanges.add(fpsRange);
}
- strcpy(defaultRange, &buffer[default_index + 1]);
- if ((pos = strstr(defaultRange, ")")) != NULL) {
- *pos = '\0';
+ fpsRanges.sort(FpsRange::compare);
+
+ for ( int i = 0; i < static_cast<int>(fpsRanges.size()); ++i ) {
+ const FpsRange & fpsRange = fpsRanges.itemAt(i);
+
+ int current_idx = strlen(buffer);
+ if (current_idx != 0) {
+ strncat(buffer, PARAM_SEP, bufferSize - current_idx - 1);
+ current_idx += param_sep_length;
+ }
+
+ snprintf(buffer + current_idx, bufferSize - current_idx - 1,
+ "(%u%s%u)",
+ fpsRange.min() * CameraHal::VFR_SCALE,
+ PARAM_SEP,
+ fpsRange.max() * CameraHal::VFR_SCALE);
}
+ const FpsRange & defaultFpsRange = fpsRanges.itemAt(fpsRanges.size() - 1);
+ snprintf(defaultRange, MAX_PROP_VALUE_LENGTH - 1,
+ "%u%s%u",
+ defaultFpsRange.min() * CameraHal::VFR_SCALE,
+ PARAM_SEP,
+ defaultFpsRange.max() * CameraHal::VFR_SCALE);
+
LOG_FUNCTION_NAME_EXIT;
return ret;
@@ -1025,56 +1059,48 @@ status_t OMXCameraAdapter::insertFramerates(CameraProperties::Properties* params
{
status_t ret = NO_ERROR;
char supported[MAX_PROP_VALUE_LENGTH];
+ char defaultRange[MAX_PROP_VALUE_LENGTH];
+ char *pos;
LOG_FUNCTION_NAME;
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
+ memset(defaultRange, '\0', MAX_PROP_VALUE_LENGTH);
- ret = encodeFramerateCap(caps.xFramerateMax >> VFR_OFFSET,
- caps.xFramerateMin >> VFR_OFFSET,
- mFramerates,
- ARRAY_SIZE(mFramerates),
- supported,
- MAX_PROP_VALUE_LENGTH);
-
+ int minFixedFps;
+ int maxFixedFps;
+ ret = encodeVFramerateCap(caps,
+ mFramerates,
+ ARRAY_SIZE(mFramerates),
+ minFixedFps,
+ maxFixedFps,
+ supported,
+ defaultRange,
+ 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);
+ CAMHAL_LOGEB("Error inserting supported preview framerate ranges 0x%x", ret);
}
- LOG_FUNCTION_NAME_EXIT;
-
- 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;
+ params->set(CameraProperties::FRAMERATE_RANGE_SUPPORTED, supported);
+ CAMHAL_LOGDB("Supported framerate ranges: %s", supported);
+ params->set(CameraProperties::FRAMERATE_RANGE, defaultRange);
+ CAMHAL_LOGDB("Default framerate range: [%s]", defaultRange);
memset(supported, '\0', MAX_PROP_VALUE_LENGTH);
- memset(defaultRange, '\0', MAX_PROP_VALUE_LENGTH);
-
- ret = encodeVFramerateCap(caps,
- supported,
- defaultRange,
- MAX_PROP_VALUE_LENGTH);
+ ret = encodeFramerateCap(maxFixedFps,
+ minFixedFps,
+ mFramerates,
+ ARRAY_SIZE(mFramerates),
+ supported,
+ 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("Supported framerate ranges: %s", supported);
- params->set(CameraProperties::FRAMERATE_RANGE, defaultRange);
- params->set(CameraProperties::FRAMERATE_RANGE_VIDEO, defaultRange);
- params->set(CameraProperties::FRAMERATE_RANGE_IMAGE, defaultRange);
- CAMHAL_LOGDB("Default framerate range: [%s]", defaultRange);
+ CAMHAL_LOGEB("Error inserting supported preview framerates 0x%x", ret);
}
+ params->set(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES, supported);
+ CAMHAL_LOGDB("Supported preview framerates: %s", supported);
+
LOG_FUNCTION_NAME_EXIT;
return ret;
@@ -1987,10 +2013,6 @@ status_t OMXCameraAdapter::insertCapabilities(CameraProperties::Properties* para
}
if ( NO_ERROR == ret ) {
- ret = insertVFramerates(params, caps);
- }
-
- if ( NO_ERROR == ret ) {
ret = insertEVs(params, caps);
}
diff --git a/camera/TICameraParameters.cpp b/camera/TICameraParameters.cpp
index 9d202df..6e66a4c 100644
--- a/camera/TICameraParameters.cpp
+++ b/camera/TICameraParameters.cpp
@@ -75,8 +75,6 @@ const char TICameraParameters::KEY_GLBCE_SUPPORTED[] = "glbce-supported";
const char TICameraParameters::KEY_CURRENT_ISO[] = "current-iso";
const char TICameraParameters::KEY_SENSOR_ORIENTATION[] = "sensor-orientation";
const char TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES[] = "sensor-orientation-values";
-const char TICameraParameters::KEY_MINFRAMERATE[] = "min-framerate";
-const char TICameraParameters::KEY_MAXFRAMERATE[] = "max-framerate";
const char TICameraParameters::KEY_RECORDING_HINT[] = "internal-recording-hint";
const char TICameraParameters::KEY_AUTO_FOCUS_LOCK[] = "auto-focus-lock";
diff --git a/camera/inc/CameraHal.h b/camera/inc/CameraHal.h
index d4c6357..8f70e20 100644
--- a/camera/inc/CameraHal.h
+++ b/camera/inc/CameraHal.h
@@ -128,6 +128,73 @@ class CameraFrame;
class CameraHalEvent;
class DisplayFrame;
+class FpsRange {
+public:
+ static FpsRange create(int min, int max);
+
+ static int compare(const FpsRange * left, const FpsRange * right);
+
+ FpsRange();
+
+ bool operator==(const FpsRange & fpsRange) const;
+
+ bool isNull() const;
+ bool isFixed() const;
+
+ int min() const;
+ int max() const;
+
+private:
+ int mMin;
+ int mMax;
+};
+
+
+inline FpsRange FpsRange::create(const int min, const int max) {
+ FpsRange fpsRange;
+ fpsRange.mMin = min;
+ fpsRange.mMax = max;
+ return fpsRange;
+}
+
+inline int FpsRange::compare(const FpsRange * const left, const FpsRange * const right) {
+ if ( left->max() < right->max() ) {
+ return -1;
+ }
+
+ if ( left->max() > right->max() ) {
+ return 1;
+ }
+
+ if ( left->min() < right->min() ) {
+ return -1;
+ }
+
+ if ( left->min() > right->min() ) {
+ return 1;
+ }
+
+ return 0;
+}
+
+inline FpsRange::FpsRange() : mMin(-1), mMax(-1) {}
+
+inline bool FpsRange::operator==(const FpsRange & fpsRange) const {
+ return mMin == fpsRange.mMin && mMax == fpsRange.mMax;
+}
+
+inline bool FpsRange::isNull() const {
+ return mMin == -1 || mMax == -1;
+}
+
+inline bool FpsRange::isFixed() const {
+ return mMin == mMax;
+}
+
+inline int FpsRange::min() const { return mMin; }
+
+inline int FpsRange::max() const { return mMax; }
+
class CameraArea : public RefBase
{
public:
@@ -1139,6 +1206,10 @@ private:
//instance
bool isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions);
+ //Check if a given variable frame rate range is supported by the current camera
+ //instance
+ bool isFpsRangeValid(int fpsMin, int fpsMax, const char *supportedFpsRanges);
+
//Check if a given parameter is supported by the current camera
// instance
bool isParameterValid(const char *param, const char *supportedParams);
@@ -1158,8 +1229,6 @@ private:
void forceStopPreview();
- void selectFPSRange(int framerate, int *min_fps, int *max_fps);
-
bool checkFramerateThr(const CameraParameters &params);
bool setPreferredPreviewRes(const CameraParameters &params, int width, int height);
void resetPreviewRes(CameraParameters *mParams, int width, int height);
diff --git a/camera/inc/CameraProperties.h b/camera/inc/CameraProperties.h
index 384d35b..cc23ec6 100644
--- a/camera/inc/CameraProperties.h
+++ b/camera/inc/CameraProperties.h
@@ -145,8 +145,6 @@ public:
static const char VNF[];
static const char VNF_SUPPORTED[];
static const char FRAMERATE_RANGE[];
- static const char FRAMERATE_RANGE_IMAGE[];
- static const char FRAMERATE_RANGE_VIDEO[];
static const char FRAMERATE_RANGE_SUPPORTED[];
static const char DEFAULT_VALUE[];
diff --git a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
index 7895c2f..c395819 100644
--- a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
+++ b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
@@ -333,9 +333,9 @@ public:
OMX_CONFIG_FRAMESTABTYPE mVidStabConfig;
OMX_U32 mCapFrame;
OMX_U32 mFrameRate;
- OMX_S32 mMinFrameRate;
- OMX_S32 mMaxFrameRate;
- CameraFrame::FrameType mImageType;
+ OMX_U32 mMinFrameRate;
+ OMX_U32 mMaxFrameRate;
+ CameraFrame::FrameType mImageType;
OMX_TI_STEREOFRAMELAYOUTTYPE mFrameLayoutType;
};
@@ -593,7 +593,7 @@ private:
static status_t encodeISOCap(OMX_U32, const CapISO*, size_t, char*, size_t);
static size_t encodeZoomCap(OMX_S32, const CapZoom*, size_t, char*, size_t);
static status_t encodeFramerateCap(OMX_U32, OMX_U32, const CapFramerate*, size_t, char*, size_t);
- static status_t encodeVFramerateCap(OMX_TI_CAPTYPE&, char*, char*, size_t);
+ static status_t encodeVFramerateCap(OMX_TI_CAPTYPE&, const CapFramerate*, size_t, int&, int&, char*, char*, size_t);
static status_t encodeImageCodingFormatCap(OMX_IMAGE_CODINGTYPE,
const CapCodingFormat *,
size_t,
@@ -615,7 +615,6 @@ private:
static status_t insertImageFormats(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
static status_t insertPreviewFormats(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
static status_t insertFramerates(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
- static status_t insertVFramerates(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
static status_t insertEVs(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
static status_t insertISOModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&);
static status_t insertIPPModes(CameraProperties::Properties*, OMX_TI_CAPTYPE &);
diff --git a/camera/inc/TICameraParameters.h b/camera/inc/TICameraParameters.h
index 2a1a556..4d90db5 100644
--- a/camera/inc/TICameraParameters.h
+++ b/camera/inc/TICameraParameters.h
@@ -72,8 +72,6 @@ static const char KEY_GBCE[];
static const char KEY_GBCE_SUPPORTED[];
static const char KEY_GLBCE[];
static const char KEY_GLBCE_SUPPORTED[];
-static const char KEY_MINFRAMERATE[];
-static const char KEY_MAXFRAMERATE[];
// TI recording hint to notify camera adapters of possible recording
static const char KEY_RECORDING_HINT[];
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-19 08:43:29 +0000