OMX_ERRORTYPE EnableDataFlow::freeHandles()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
DBGT_ASSERT(NULL != mArmIvProc, "mArmIvProc is NULL");
DBGT_ASSERT(NULL != mSwJpegEnc, "mSwJpegEnc is NULL");
DBGT_PTRACE("Sending ArmIv to unloaded State");
err = mOmxUtils.interface()->GetpOMX_FreeHandle()(mArmIvProc);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("GetpOMX_FreeHandle ArmIVProc failed err = %d", err);
DBGT_EPILOG("");
return err;
}
mArmIvProc = NULL ;
DBGT_PTRACE("Sending SwJpegEnc to unloaded State");
err = mOmxUtils.interface()->GetpOMX_FreeHandle()(mSwJpegEnc);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("GetpOMX_FreeHandle SwJpegenc failed err = %d", err);
DBGT_EPILOG("");
return err;
}
mSwJpegEnc = NULL ;
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE EnableDataFlow::setupTunneling()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
//make tunnel between output port1 of ARMIV Proc and input port of SW JPEG Enc
DBGT_PTRACE("ARM IV port: %lu SW JPEG ENcport: %lu", mParamArmIvOutput.nPortIndex, mParamSwJpegInput.nPortIndex);
err = (mOmxUtils.interface()->GetpOMX_SetupTunnel())(mArmIvProc, mParamArmIvOutput.nPortIndex,
mSwJpegEnc, mParamSwJpegInput.nPortIndex);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL(" OMX_SetupTunnel failed between ARMIV Proc and SW JPEGEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
//make tunnel between Output port of SWJPEGENC with input port 0 of EXIF MIxer
DBGT_PTRACE("SW JPEG ENcport: %lu EXIF Mixer POrt: %lu", mParamSwJpegOutput.nPortIndex, mParamExifInput.nPortIndex);
err = (mOmxUtils.interface()->GetpOMX_SetupTunnel())(mSwJpegEnc, mParamSwJpegOutput.nPortIndex,
mExifMixer, mParamExifInput.nPortIndex);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL(" OMX_SetupTunnel failed between SWJPEGENC and EXIFMIXER err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE DeviceRotation::doConfiguration()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
if(mSTECamera->mPictureInfo.swapParams()) {
err = mSTECamera->getThumbnailHandler()->configure(mSTECamera->mThumbnailInfo,
mSTECamera->mPreviewInfo);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("configure() failed err = %d", err);
DBGT_EPILOG("");
return err;
}
err = mSTECamera->ReconfigureStill(mSTECamera->mPictureInfo, false);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("ReconfigureStill() failed err = %d", err);
DBGT_EPILOG("");
return err;
}
}
err = setupRotationProcessing();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("setupRotationProcessing() err = %d", err);
DBGT_EPILOG("");
return err;
}
mSTECamera->mPictureInfo.resetSwapParams();
mSTECamera->mThumbnailInfo.resetSwapParams();
DBGT_EPILOG("");
return err;
}
int STENativeWindow::dequeueBuffer(buffer_handle_t **ppBuffer, int *pStride)
{
DBGT_PROLOG("");
if (!mInitialized) {
DBGT_CRITICAL("mInitialized = %d", mInitialized);
DBGT_EPILOG("");
return -1;
}
int stride;
status_t error = mPreviewWindow->dequeue_buffer(
mPreviewWindow,
ppBuffer,
&stride);
if (OK != error) {
DBGT_CRITICAL("error = %d", error);
DBGT_EPILOG("");
return -1;
}
if (pStride) {
*pStride = stride;
}
DBGT_EPILOG("");
return 0;
}
OMX_ERRORTYPE FixedFocusHandler::setUpFocus(const char* const aFocus)
{
DBGT_PROLOG("Focus: %s", aFocus);
DBGT_ASSERT(NULL != aFocus, "Focus is NULL");
OMX_ERRORTYPE err = OMX_ErrorNone;
//Setting Focus Control
OmxUtils::StructContainer<OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE> focusControl;
focusControl.ptr()->nPortIndex = OMX_ALL;
err = OMX_GetConfig(mSTECamera->mCam, (OMX_INDEXTYPE)(OMX_IndexConfigFocusControl), focusControl.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
focusControl.ptr()->eFocusControl = OMX_IMAGE_FocusControlOff;
focusControl.ptr()->nFocusStepIndex = 0;
focusControl.ptr()->nFocusSteps = 100;
DBGT_PTRACE("Setting Control %u", focusControl.ptr()->eFocusControl);
err = OMX_SetConfig(mSTECamera->mCam, (OMX_INDEXTYPE)(OMX_IndexConfigFocusControl), focusControl.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE EnableDataFlow::resetComponents()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
DBGT_PTRACE("Sending Command StateIdle to SwJpegEnc");
err = OMX_SendCommand(mSwJpegEnc, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Sending OMX_StateIdle failed for SwJpegEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_PTRACE("Sending Command StateIdle to ArmIv");
err = OMX_SendCommand(mArmIvProc, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Sending OMX_StateIdle failed for ArmIVProc err = %d", err);
DBGT_EPILOG("");
return err;
}
mStateArmIvSem.wait();
mStateSWJpegSem.wait();
DBGT_PTRACE("Sending Command StateLoaded to ArmIv");
err = OMX_SendCommand(mArmIvProc, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Sending OMX_StateLoaded failed for ArmIVProc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_PTRACE("Sending Command StateLoaded to SwJpegEnc");
err = OMX_SendCommand(mSwJpegEnc, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Sending OMX_StateLoaded failed for SwJpegEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
err = freeBuffers();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Free buffers err = %d", err);
DBGT_EPILOG("");
return err;
}
mStateSWJpegSem.wait();
mStateArmIvSem.wait();
DBGT_EPILOG("");
return err;
}
int STENativeWindow::init(
int width,
int height,
int pixelFormat,
int usage)
{
DBGT_PROLOG("");
if (mPreviewWindow == NULL) {
DBGT_CRITICAL("mPreviewWindow = %p", mPreviewWindow);
DBGT_EPILOG("");
return -1;
}
if (mInitialized)
{
DBGT_EPILOG("");
return 0;
}
status_t error
= mPreviewWindow->set_buffers_geometry(
mPreviewWindow,
width,
height,
pixelFormat);
if (OK != error) {
DBGT_CRITICAL("error = %d", error);
DBGT_EPILOG("");
return -1;
}
error = mPreviewWindow->get_min_undequeued_buffer_count(
mPreviewWindow, &mMinUndequeuedCount);
if (OK != error) {
DBGT_CRITICAL("error = %d", error);
DBGT_EPILOG("");
return -1;
}
error = mPreviewWindow->set_usage(
mPreviewWindow,
usage);
if (OK != error) {
DBGT_CRITICAL("error = %d", error);
DBGT_EPILOG("");
return -1;
}
mInitialized = true;
DBGT_EPILOG("");
return 0;
}
OMX_ERRORTYPE EnableDataFlow::sendComponentToExecuting()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
DBGT_PTRACE("Sending Command StateIdle to ArmIv");
err = OMX_SendCommand(mArmIvProc, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_CommandStateSet IDLE failed for mArmIvProc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_PTRACE("Sending Command StateIdle to SWJpeg");
err = OMX_SendCommand(mSwJpegEnc, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_CommandStateSet IDLE failed for mSwJpegEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
mStateArmIvSem.wait();
mStateSWJpegSem.wait();
DBGT_PTRACE("Sending Command StateExecuting to ArmIv");
err = OMX_SendCommand(mArmIvProc, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_CommandStateSet EXECUTING failed for mArmIvProc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_PTRACE("Sending Command StateExecuting to SWJpeg");
err = OMX_SendCommand(mSwJpegEnc, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_CommandStateSet EXECUTING failed for mSwJpegEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
mStateArmIvSem.wait();
mStateSWJpegSem.wait();
DBGT_EPILOG("");
return err;
}
STEOMXCodecsPlugin::STEOMXCodecsPlugin() {
DBGT_PROLOG();
OMX_ERRORTYPE err = OMX_ErrorNone;
mHandle = dlopen(STEOMXINT_SO_FILE, RTLD_NOW);
if ( NULL == mHandle ) {
DBGT_CRITICAL("dlopen() failed %s", dlerror());
goto dl_close;
}
DBGT_PINFO("dlopen passed");
typedef OMXCoreInterface* (*pGetCoreInterface)();
pGetCoreInterface temp;
temp = (pGetCoreInterface)dlsym(mHandle, "GetOMXCoreInterface");
mInterface = (*temp)();
if (mInterface == NULL) {
DBGT_CRITICAL("dlsym(GetOMXCoreInterface) failed, err=%s", dlerror());
goto dl_close;
}
err = (mInterface->GetpOMX_Init())();
if (err != OMX_ErrorNone) {
DBGT_CRITICAL("GetpOMX_Init failed, err=%s",
OMX_TYPE_TO_STR(OMX_ERRORTYPE, err));
goto clean_interface;
}
DBGT_PINFO("GetpOMX_Init passed for interface=%p", mInterface);
DBGT_EPILOG();
return;
clean_interface:
mInterface = NULL;
dl_close:
dlclose(mHandle);
mHandle = NULL ;
DBGT_EPILOG("error, %s %s", mHandle?"":"mHandle=NULL",
mInterface?"":"mInterface=NULL");
return;
}
OMX_ERRORTYPE DeviceHwRotation::setupRotationProcessing()
{
DBGT_PROLOG("");
DBGT_ASSERT(NULL != mSTECamera->mCam, "Camera Handle is Null");
int rotation = mSTECamera->mPictureInfo.getRotation();
DBGT_ASSERT(180 != rotation, "Invalid rotation for Hw Processing");
OMX_ERRORTYPE err = OMX_ErrorNone;
/*Setup Hardware Processing*/
OmxUtils::StructContainer<OMX_SYMBIAN_CONFIG_ORIENTATIONTYPE> stillOrientationConfig;
stillOrientationConfig.ptr()->nPortIndex = paramPortVPB1.nPortIndex;
err = OMX_GetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EOrientationScene), stillOrientationConfig.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Orientation Scene OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
if (0 == rotation) {
stillOrientationConfig.ptr()->eOrientation = OMX_SYMBIAN_OrientationRowTopColumnLeft;
} else if (90 == rotation) { /*< Frame is 90 degrees CW rotated */
stillOrientationConfig.ptr()->eOrientation = OMX_SYMBIAN_OrientationRowRightColumnTop;
} else if (270 == rotation) { /*< Frame is 270 degrees CW rotated */
stillOrientationConfig.ptr()->eOrientation = OMX_SYMBIAN_OrientationRowLeftColumnBottom;
} else
DBGT_CRITICAL("Cant Happen");
err = OMX_SetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EOrientationScene), stillOrientationConfig.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Orientation Scene OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
/*Setup Software Processing*/
mSTECamera->mISPImageOmxBuffInfo.mSwRotation = NULL;
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE EnableDataFlow::configure(const ImageInfo &aThumbnailInfo,
const ImageInfo &aPreviewInfo)
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
/* check whether mArmIvProc and mSwJpegEnc are in executing state or not,
* if not, send them to executing first.
* This being the case when without doing setParameters(), startPreview()
* is called. As thumbnailhandler is setup for disableDataFlow, when a
* setParameters() is done with some valid thumbnail size, enableDataFlow's
* sendComponentToExecuting() is not called leading to a deadlock.
*/
OMX_STATETYPE armIvProcState, swJpegEncState;
OMX_GetState(mArmIvProc, &armIvProcState);
OMX_GetState(mSwJpegEnc, &swJpegEncState);
if(OMX_StateExecuting != armIvProcState || OMX_StateExecuting != swJpegEncState){
err = sendComponentToExecuting();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("sendComponentToExecuting failed err = %d", err);
DBGT_EPILOG("");
return err;
}
}
err = configPorts(aThumbnailInfo, aPreviewInfo);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("configPorts() failed err = %d", err);
DBGT_EPILOG("");
return err;
}
err = enablePorts();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("enablePorts failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
/**
* Undo MMIO initializations.
* @param slot indicates which camera to de-init
* @return OMX_ErrorNone or other OMX error codes
*/
OMX_ERRORTYPE CSiaPlatformManager::deinit(
enumExtCameraSlot slot)
{
OMX_ERRORTYPE error=OMX_ErrorNone;
//-------------------------------------------------------
// PowerOff the sensor
//-------------------------------------------------------
error = MMIO_Camera::powerSensor(OMX_FALSE);
if (error) {
DBGT_PTRACE("ERROR in MMIO_Camera::powerSensor(OFF) !");
return error;
}
#ifndef MMIO_ENABLE_NEW_IF
//-------------------------------------------------------
// Switch OFF extClk
//-------------------------------------------------------
error = MMIO_Camera::setExtClk(OMX_FALSE);
if (error) {
DBGT_PTRACE("ERROR in MMIO_Camera::setExtClk(OFF) !");
return error;
}
#endif //MMIO_ENABLE_NEW_IF
//-------------------------------------------------------
// Desinit board
//-------------------------------------------------------
error = MMIO_Camera::desinitBoard();
if (error) {
DBGT_PTRACE("ERROR in MMIO_Camera::deinitBoard !");
return error;
}
//-------------------------------------------------------
// Release driver
//-------------------------------------------------------
#ifdef MMIO_ENABLE_NEW_IF
error = MMIO_Camera::releaseDriver();
if (error) {
DBGT_CRITICAL("ERROR in MMIO_Camera::releaseDriver!");
}
#else
if(slot ==ePrimaryExtCamera)
error = MMIO_Camera::releasePrimaryCameraHWInterface();
else
error = MMIO_Camera::releaseSecondaryCameraHWInterface();
if (error) {
DBGT_PTRACE("ERROR in MMIO_Camera::releasePrimary/SecondaryCameraHWInterface !");
}
#endif
return error;
}
int STENativeWindow::setBufferCount(int count)
{
DBGT_PROLOG("");
if (!mInitialized || count < mMinUndequeuedCount) {
DBGT_CRITICAL("mInitialized = %d, count = %d", mInitialized, count);
DBGT_EPILOG("");
return -1;
}
status_t error = mPreviewWindow->set_buffer_count(
mPreviewWindow, count);
if (OK != error) {
DBGT_CRITICAL("error = %d", error);
DBGT_EPILOG("");
return -1;
}
DBGT_EPILOG("");
return 0;
}
OMX_ERRORTYPE EnableDataFlow::setAutoRotate(OMX_BOOL aEnaleAutoRotate)
{
DBGT_PROLOG("aEnaleAutoRotate: %d", aEnaleAutoRotate);
DBGT_ASSERT(NULL != mArmIvProc, "mArmIvProc is NULL");
DBGT_ASSERT(1 == mParamArmIvOutput.nPortIndex, "mParamArmIvOutput.nPortIndex is invalid");
OMX_ERRORTYPE err = OMX_ErrorNone;
OMX_INDEXTYPE index;
OmxUtils::StructContainer<OMX_SYMBIAN_CONFIG_BOOLEANTYPE> autoRotate;
err = OMX_GetExtensionIndex(mArmIvProc, (char *)OMX_SYMBIAN_INDEX_CONFIG_COMMON_AUTOROTATIONCONTROL_NAME, &index);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Still Auto Rotation OMX_GetExtensionIndex failed err = %d", err);
DBGT_EPILOG("");
return err;
}
autoRotate.ptr()->nPortIndex = mParamArmIvOutput.nPortIndex;
err = OMX_GetConfig(mArmIvProc, index, autoRotate.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Auto Rotation OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
autoRotate.ptr()->bEnabled = aEnaleAutoRotate;
err = OMX_SetConfig(mArmIvProc, index, autoRotate.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Auto Rotation OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
int STENativeWindow::lockBuffer(buffer_handle_t &pBuffer)
{
DBGT_PROLOG("");
if (!mInitialized) {
DBGT_CRITICAL("mInitialized = %d", mInitialized);
DBGT_EPILOG("");
return -1;
}
status_t error = mPreviewWindow->lock_buffer(
mPreviewWindow,
&pBuffer);
if (OK != error) {
DBGT_CRITICAL("error = %d", error);
DBGT_EPILOG("");
return -1;
}
DBGT_EPILOG("");
return 0;
}
int STENativeWindow::setCrop(int left, int top, int right, int bottom)
{
DBGT_PROLOG("");
if (!mInitialized) {
DBGT_CRITICAL("mInitialized = %d", mInitialized);
DBGT_EPILOG("");
return -1;
}
status_t error = mPreviewWindow->set_crop(
mPreviewWindow,
left, top,
right, bottom);
if (OK != error) {
DBGT_CRITICAL("error = %d", error);
DBGT_EPILOG("");
return -1;
}
DBGT_EPILOG("");
return 0;
}
OMX_ERRORTYPE ImageRotHandler::setAutoRotate(OMX_HANDLETYPE aHandle, int aPort, OMX_BOOL aEnaleAutoRotate)
{
DBGT_PROLOG("aHandle: %p aPort: %d aEnaleAutoRotate: %d", aHandle, aPort, aEnaleAutoRotate);
DBGT_ASSERT(NULL != aHandle, "aHandle is NULL");
OMX_ERRORTYPE err = OMX_ErrorNone;
OMX_INDEXTYPE index;
OmxUtils::StructContainer<OMX_SYMBIAN_CONFIG_BOOLEANTYPE> autoRotate;
err = OMX_GetExtensionIndex(aHandle, (char *)OMX_SYMBIAN_INDEX_CONFIG_COMMON_AUTOROTATIONCONTROL_NAME, &index);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Still Auto Rotation OMX_GetExtensionIndex failed err = %d", err);
DBGT_EPILOG("");
return err;
}
autoRotate.ptr()->nPortIndex = aPort;
err = OMX_GetConfig(aHandle, index, autoRotate.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Auto Rotation OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
autoRotate.ptr()->bEnabled = aEnaleAutoRotate;
err = OMX_SetConfig(aHandle, index, autoRotate.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Auto Rotation OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE FocusHandler::doFocus()
{
DBGT_PROLOG("");
mSTECamera->mAutoFocusThreadData->mEnabled = OMX_TRUE;
OmxUtils::StructContainer<OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE> focusControl;
focusControl.ptr()->nPortIndex = OMX_ALL;
DBGT_ASSERT(OMX_IMAGE_FocusControlOff != g_STECamFocusProp[mFocusModeIndex].eFocusType,
"Focussing not permitted in this mode");
OMX_ERRORTYPE err = OMX_ErrorNone;
err = mSTECamera->mOmxReqCbHandler.enable(OmxReqCbHandler::EAutoFocusLock);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Enable reqcb failed err = %d", err);
DBGT_EPILOG("");
return err;
}
err = OMX_GetConfig(mSTECamera->mCam, (OMX_INDEXTYPE)(OMX_IndexConfigFocusControl), focusControl.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
focusControl.ptr()->eFocusControl = OMX_IMAGE_FocusControlOn;
err = OMX_SetConfig(mSTECamera->mCam, (OMX_INDEXTYPE)(OMX_IndexConfigFocusControl), focusControl.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE DeviceSwRotation::setupRotationProcessing()
{
DBGT_PROLOG("");
DBGT_ASSERT(NULL != mSTECamera->mCam, "Camera Handle is Null");
int rotation = mSTECamera->mPictureInfo.getRotation();
DBGT_ASSERT(rotation == 180, "Invalid rotation for Sw Processing");
OMX_ERRORTYPE err = OMX_ErrorNone;
/*Setup Hardware Processing*/
OmxUtils::StructContainer<OMX_SYMBIAN_CONFIG_ORIENTATIONTYPE> stillOrientationConfig;
stillOrientationConfig.ptr()->nPortIndex = paramPortVPB1.nPortIndex;
err = OMX_GetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EOrientationScene), stillOrientationConfig.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Orientation Scene OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
stillOrientationConfig.ptr()->eOrientation = OMX_SYMBIAN_OrientationRowBottomColumnRight;
err = OMX_SetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EOrientationScene), stillOrientationConfig.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Orientation Scene OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
/*Setup Software Processing*/
mSTECamera->mISPImageOmxBuffInfo.mSwRotation = CamSwRoutines::YUV420MB_180_rotation_inplace;
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE ImageRotHandler::doConfigAutoRotate(OMX_BOOL aEnaleAutoRotate)
{
DBGT_PROLOG("aEnaleAutoRotate: %d", aEnaleAutoRotate);
OMX_ERRORTYPE err = OMX_ErrorNone;
err = setAutoRotate(mSTECamera->mISPProc, paramISPoutput.nPortIndex, aEnaleAutoRotate);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("SetAutoRotate failed for mISPProc err = %d", err);
DBGT_EPILOG("");
return err;
}
err = mSTECamera->mEnableDataFlow->setAutoRotate(aEnaleAutoRotate);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("SetAutoRotate failed for mISPProc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE FocusHandler::cancelFocus()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
OmxUtils::StructContainer<OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE> focusControl;
focusControl.ptr()->nPortIndex = OMX_ALL;
err = OMX_GetConfig(mSTECamera->mCam, (OMX_INDEXTYPE)(OMX_IndexConfigFocusControl), focusControl.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
setupFocusControl(focusControl.ref());
err = OMX_SetConfig(mSTECamera->mCam, (OMX_INDEXTYPE)(OMX_IndexConfigFocusControl), focusControl.ptr());
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_SetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
err = getFocusStatus();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("getFocusStatus failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE EnableDataFlow::release()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
err = disablePorts();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("disablePorts() failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE DeviceSwRotation::handleBuffer(const OMX_BUFFERHEADERTYPE* const aOmxBuffHdr)
{
DBGT_PROLOG("aOmxBuffHdr: %p", aOmxBuffHdr);
mSTECamera->doPictureSwRotProcessing(aOmxBuffHdr, mSTECamera->mISPImageOmxBuffInfo.m_pMMHwBuffer);
OMX_ERRORTYPE err = updateExtraDataOrientation(aOmxBuffHdr);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("updateExtraDataOrientation failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE ExifRotation::doConfiguration()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
err = setupRotationProcessing();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("setupRotationProcessing() err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE DeviceRotation::configAutoRotate()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
// Configure ISPproc and ARMIV for auto-rotation:on
err = doConfigAutoRotate(OMX_TRUE);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("doConfigAutoRotate failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE EnableDataFlow::handleBuffer(OMX_U32 aFilledLen, OMX_U32 aFlags)
{
DBGT_PROLOG("aFilledLen: 0x%08x aFlags: 0x%08x", (unsigned int)aFilledLen, (unsigned int)aFlags);
OMX_ERRORTYPE err = OMX_ErrorNone;
mArmIvInBuffer->nFilledLen = aFilledLen;
mArmIvInBuffer->nFlags = aFlags;
err = OMX_EmptyThisBuffer(mArmIvProc, mArmIvInBuffer);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_EmptyThisBuffer failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE EnableDataFlow::freeBuffers()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
if (NULL != mArmIvInBuffer) {
err = OMX_FreeBuffer(mArmIvProc, (OMX_U32)( 0 ), mArmIvInBuffer);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_FreeBuffer failed for ArmIVProc input port err = %d", err);
DBGT_EPILOG("");
return err;
}
mArmIvInBuffer = NULL;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE FocusHandler::getFocusStatus()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
if(OMX_IMAGE_FocusControlOff != g_STECamFocusProp[mFocusModeIndex].eFocusType)
err = OMX_GetConfig(mSTECamera->mCam, mSTECamera->mOmxILExtIndex->getIndex(OmxILExtIndex::EFocusStatus), &mExtFocusStatus.mFocusStatus);
else
DBGT_PINFO("Autofocus not done in this mode: OMX_IMAGE_FocusControlOff");
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_GetConfig failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE ExifRotation::handleBuffer(const OMX_BUFFERHEADERTYPE* const aOmxBuffHdr)
{
DBGT_PROLOG("aOmxBuffHdr: %p", aOmxBuffHdr);
OMX_ERRORTYPE err = OMX_ErrorNone;
int rotation = mSTECamera->mPictureInfo.getRotation();
DBGT_PROLOG("rotation = %d", rotation);
if (180 == rotation) {
err = updateExtraDataOrientation(aOmxBuffHdr);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("updateExtraDataOrientation failed err = %d", err);
DBGT_EPILOG("");
return err;
}
}
DBGT_EPILOG("");
return err;
}
OMX_ERRORTYPE EnableDataFlow::useBuffer()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
DBGT_PTRACE("\n Calling OMX_SetConfig before OMX_UseBuffer ArmIV Chunk\n");
err = OMX_SetConfig(mArmIvProc, (OMX_INDEXTYPE)OMX_OsiIndexConfigSharedChunkMetadata, &mChunkData_ArmIvProc);
if (err != OMX_ErrorNone) {
DBGT_PTRACE("OMX_SetConfig Failed \n");
}
mArmIvInBuffer = NULL;
DBGT_PTRACE("usebuffer mArmIvProc ");
err = OMX_UseBuffer(mArmIvProc, // hComponent
&mArmIvInBuffer, // address where ptr to buffer header will be stored
0, // port index (for port for which buffer is provided)
(void *)(&mArmIvOmxBuffInfo), // App. private data = pointer to beginning of allocated data
// to have a context when component returns with a callback (i.e. to know
// what to free etc.
(OMX_U32)(mParamArmIvInput.nBufferSize), // buffer size
(OMX_U8 *)(mArmIvOmxBuffInfo.mMMHwBufferInfo.iLogAddr) // buffer data ptr
);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_UseBuffer failed for mArmIvProc port 0 failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_ASSERT(NULL != mArmIvInBuffer->pBuffer, "Buffer is NULL");
mArmIvOmxBuffInfo.mCamMemoryBase.get()->setOmxBufferHeaderType(mArmIvInBuffer);
DBGT_EPILOG("");
return err;
}
