// MPEG2Dec_Port::checkIndexParamVideoPortFormat() is automatically called by the VFM when setting
// the video parameter of the port.
// This function checks the parameters that the user wants to set, regarding the OMX specification
// and regarding the capabilities of the components (in terms of Nomadik spec).
OMX_ERRORTYPE MPEG2Dec_Port::checkIndexParamVideoPortFormat(OMX_VIDEO_PARAM_PORTFORMATTYPE *pt)
{
OstTraceInt0(TRACE_FLOW,"Enter MPEG2Dec_Port::checkIndexParamVideoPortFormat");
DBC_ASSERT(mParamPortDefinition.nPortIndex==pt->nPortIndex);
DBC_ASSERT(pt->nPortIndex==VPB+0 || pt->nPortIndex==VPB+1);
if (pt->nPortIndex==VPB+0)
{
// input port
RETURN_XXX_IF_WRONG_OST(pt->eCompressionFormat==OMX_VIDEO_CodingMPEG2, OMX_ErrorBadParameter);
RETURN_XXX_IF_WRONG_OST(pt->eColorFormat==OMX_COLOR_FormatUnused, OMX_ErrorBadParameter);
// nothing to be check on pt->nIndex
}
else
{
// output port
RETURN_XXX_IF_WRONG_OST(pt->eCompressionFormat==OMX_VIDEO_CodingUnused, OMX_ErrorBadParameter);
RETURN_XXX_IF_WRONG_OST( pt->eColorFormat==(OMX_COLOR_FORMATTYPE)OMX_COLOR_FormatYUV420PackedSemiPlanar
|| pt->eColorFormat==OMX_COLOR_FormatYUV420Planar,OMX_ErrorBadParameter);
// nothing to be check on pt->nIndex
}
OstTraceInt0(TRACE_FLOW,"Exit MPEG2Dec_Port::checkIndexParamVideoPortFormat");
return OMX_ErrorNone;
}
OMX_ERRORTYPE JPEGEnc_ArmNmfProcessingComponent::emptyThisBuffer(OMX_BUFFERHEADERTYPE* pBuffer)
{
OstTraceFiltInst3(TRACE_API, "JPEGEnc_ArmNmfProcessingComponent : In emptyThisBuffer pBuffer->pBuffer (0x%x) pBuffer->nFilledLen (%d) pBuffer->nFlags (%d) \n",(OMX_U32)pBuffer->pBuffer,pBuffer->nFilledLen,pBuffer->nFlags);
if ((pProxyComponent->mParam.outputCompressionFormat == OMX_IMAGE_CodingJPEG)&&(pBuffer->nFlags & OMX_BUFFERFLAG_EXTRADATA))
{
pBuffer->nFlags = pBuffer->nFlags & (~OMX_BUFFERFLAG_EXTRADATA);
}
if(pProxyComponent->mParam.outputCompressionFormat == OMX_IMAGE_CodingEXIF)
{
t_cm_system_address sysAddr1,sysAddr2;
sysAddr1.logical = (t_uint32 )mHeaderBufferDesc.nLogicalAddress;
DBC_ASSERT(sysAddr1.logical);
sysAddr2.logical = (t_uint32 )mEXIFHeaderBufferDesc.nLogicalAddress;
DBC_ASSERT(sysAddr2.logical);
OstTraceFiltInst1(TRACE_FLOW, "In JPEGEnc_ArmNmfProcessingComponent : In emptyThisBuffer calling addEXIFHeader <line no %d> ",__LINE__);
processingComp.addEXIFHeader(pProxyComponent,pBuffer,(OMX_U8 **)&(sysAddr1.logical),(OMX_U8 **)&(sysAddr2.logical),
&(mEXIFHeaderBufferDesc.nSize),mHeaderBufferDesc.nSize);
}
OstTraceFiltInst1(TRACE_API, "In JPEGEnc_ArmNmfProcessingComponent : emptyThisBuffer done <line no %d> ",__LINE__);
return NmfHost_ProcessingComponent::emptyThisBuffer(pBuffer);
}
void SpeechProcNmf_ProcessingComp::cleanMpcMemory(void)
{
OMX_ERRORTYPE error = OMX_ErrorNone;
if(mMemorySampleRate != 0)
{
error = ENS::freeMpcMemory(mMemorySampleRate);
DBC_ASSERT(error == OMX_ErrorNone);
mMemorySampleRate = 0;
}
if(mMemoryTimeAlign != 0)
{
error = ENS::freeMpcMemory(mMemoryTimeAlign);
DBC_ASSERT(error == OMX_ErrorNone);
mMemoryTimeAlign = 0;
}
if(mDownlinkHybridbuffer != NULL)
{
delete mDownlinkHybridbuffer;
mDownlinkHybridbuffer = NULL;
}
if(mUplinkHybridbuffer != NULL)
{
delete mUplinkHybridbuffer;
mUplinkHybridbuffer = NULL;
}
}
// FIXME: bufferAllocInfo, portPrivateInfo pPortPoolid could be removed when pAppPrivate mechanism deprecated
ENS_API_EXPORT OMX_ERRORTYPE NmfHost_ProcessingComponent::freeBufferVisual(OMX_U32 nPortIndex,
OMX_U32 nBufferIndex,
OMX_BOOL bBufferAllocated,
void *bufferAllocInfo,
void *portPrivateInfo)
{
if (nPortIndex>=mENSComponent.getPortCount() || mENSComponent.getPort(nPortIndex)==0) {
return OMX_ErrorBadPortIndex;
}
// No need to reset shared chunk as done by the freeBuffer of the port
OMX_ERRORTYPE error;
ENS_Port *port = mENSComponent.getPort(nPortIndex);
MMHwBuffer *sharedChunk = port->getSharedChunk();
if (sharedChunk) {
DBC_ASSERT(sharedChunk==portPrivateInfo);
if (nBufferIndex == 0) { // ER342234
if (bBufferAllocated) {
error = MMHwBuffer::Destroy(sharedChunk);
DBC_ASSERT(error == OMX_ErrorNone);
} else {
error = MMHwBuffer::Close(sharedChunk);
DBC_ASSERT(error == OMX_ErrorNone);
}
port->setSharedChunk(0);
}
}
return OMX_ErrorNone;
}
//
// suppose that in case of OMX_ALL, ALL port are enabled
//
ENS_API_EXPORT void NmfHostMpc_ProcessingComponent::disablePortIndication(OMX_U32 portIndex, OMX_BOOL &deferEventHandler) {
OMX_ERRORTYPE error;
if(portIndex == OMX_ALL) {
for (OMX_U32 i = 0; i < mENSComponent.getPortCount(); i++) {
ENS_Port * port = static_cast<ENS_Port *>(mENSComponent.getPort(i));
DBC_ASSERT(port!=0);
if (port->useProprietaryCommunication() == OMX_FALSE &&
port->getDomain() != OMX_PortDomainOther &&
port->isMpc())
{
error = stopNmfSharedBuf(i);
if (error != OMX_ErrorNone) {
mENSComponent.eventHandler(OMX_EventError, (OMX_U32)error, i);
return;
}
}
}
} else {
if (portIndex>=mENSComponent.getPortCount() || mENSComponent.getPort(portIndex)==0) {
mENSComponent.eventHandler(OMX_EventError, (OMX_U32)OMX_ErrorBadPortIndex, 0);
}
ENS_Port * port = static_cast<ENS_Port *>(mENSComponent.getPort(portIndex));
DBC_ASSERT(port!=0);
if (port->useProprietaryCommunication() == OMX_FALSE &&
port->getDomain() != OMX_PortDomainOther &&
port->isMpc())
{
error = stopNmfSharedBuf(portIndex);
if (error != OMX_ErrorNone) {
mENSComponent.eventHandler(OMX_EventError, (OMX_U32)error, portIndex);
return;
}
}
}
error = doSpecificEventHandler_cb(OMX_EventCmdComplete, OMX_CommandPortDisable, portIndex, deferEventHandler);
if (error != OMX_ErrorNone) {
mENSComponent.eventHandler(OMX_EventError, (OMX_U32)error, 0);
return;
}
// No longer deleted sharedbuffer, as deleting them may lead to lose NMF messages,
// because in hybrid component, event messages are routed by NMF-ARM and buffers (for MPC port) are routed by NMF-DSP.
// As there is no synchro between those 2 paths, we no longer delete NMF-DSP path.
}
OMX_ERRORTYPE
IFM_HostNmfProcessingComp::freeBuffer(
OMX_U32 nPortIndex,
OMX_U32 nBufferIndex,
OMX_BOOL bBufferAllocated,
void *bufferAllocInfo,
void *portPrivateInfo){
IN0("\n");
ENS_Port * port = mENSComponent.getPort(nPortIndex);
OMX_PARAM_PORTDEFINITIONTYPE portdef;
OMX_VERSIONTYPE version = {{0, 0, 0, 0}};
getOmxIlSpecVersion(&version);
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion = version;
port->getParameter(OMX_IndexParamPortDefinition, &portdef);
if(portdef.eDomain == OMX_PortDomainVideo){
//will free depending on bBufferAllocated
//freeBufferVisual(nPortIndex,nBufferIndex,bBufferAllocated,NULL,portPrivateInfo);
OMX_ERRORTYPE error;
ENS_Port *port = mENSComponent.getPort(nPortIndex);
MMHwBuffer *sharedChunk = (MMHwBuffer *)port->getSharedChunk();
if (sharedChunk) {
if (nBufferIndex == port->getBufferCountActual()-1) {
if (bBufferAllocated) {
error = MMHwBuffer::Destroy(sharedChunk);
DBC_ASSERT(error == OMX_ErrorNone);
} else {
error = MMHwBuffer::Close(sharedChunk);
DBC_ASSERT(error == OMX_ErrorNone);
}
port->setSharedChunk(0);
}
}//else DBC_ASSERT(0);
/* whatever : delete the sharedBuffer as in both case (allocation or use) it is allocated*/
delete (SharedBuffer *)portPrivateInfo;
}
else /* clock domain */
{
freeBufferHeap(nPortIndex,nBufferIndex,bBufferAllocated,bufferAllocInfo,portPrivateInfo);
}
OUTR(" ",OMX_ErrorNone);
return OMX_ErrorNone;
}
// Set the default value of the port. This function is used by the construct() function of the proxy
// when creating a new instance of the proxy
void MPEG2Dec_Port::setDefault()
{
OstTraceInt0(TRACE_FLOW,"Enter MPEG2Dec_Port::setDefault");
DBC_ASSERT(mParamPortDefinition.eDomain==OMX_PortDomainVideo);
//MPEG2Dec_Proxy *comp = getProxy();
mParamPortDefinition.format.video.cMIMEType = (char *)"video/MPEG2";
mParamPortDefinition.format.video.pNativeRender = 0;
mParamPortDefinition.format.video.nFrameHeight = 16; // from OMX spec 1.1.1
mParamPortDefinition.format.video.nFrameWidth = 16; // from OMX spec 1.1.1
mParamPortDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
mParamPortDefinition.format.video.pNativeWindow = 0;
switch (mParamPortDefinition.nPortIndex)
{
case 0:
DBC_ASSERT(mParamPortDefinition.eDir==OMX_DirInput);
mParamPortDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG2;
mParamPortDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
mParamPortDefinition.format.video.nBitrate = 64000; // from OMX spec 1.1.1
mParamPortDefinition.format.video.xFramerate = 15; // from OMX spec 1.1.1
mParamPortDefinition.format.video.nStride = 0; // unused for compressed data
mParamPortDefinition.format.video.nSliceHeight = 1; // unused for compressed data
//comp->mParam.setProfileLevel(OMX_VIDEO_MPEG2ProfileSimple, OMX_VIDEO_MPEG2LevelLL); // from OMX spec 1.1.1
break;
case 1:
DBC_ASSERT(mParamPortDefinition.eDir==OMX_DirOutput);
mParamPortDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
mParamPortDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
mParamPortDefinition.format.video.nBitrate = 0;
mParamPortDefinition.format.video.xFramerate = 0;
mParamPortDefinition.format.video.nStride = (mParamPortDefinition.format.video.nFrameWidth * 3) / 2; // corresponds to a raw in OMX_COLOR_FormatYUV420Planar
mParamPortDefinition.format.video.nSliceHeight = 1; // a single raw in the buffer is required. FIXME
break;
default:
DBC_ASSERT(0==1);
}
// mParamPortDefinition.nBufferCountActual updated by the component when buffers are allocated
// mParamPortDefinition.nBufferCountMin set at the creation of the port (check constructor of the proxy)
// mParamPortDefinition.bEnabled set by the component
// mParamPortDefinition.bPopulated set by the component
mParamPortDefinition.bBuffersContiguous = OMX_TRUE;
mParamPortDefinition.nBufferAlignment = 0x100;
mParamPortDefinition.nBufferSize = getBufferSize();
mParamPortDefinition.nBufferCountMin = getBufferCountMin();
OstTraceInt0(TRACE_FLOW,"Exit MPEG2Dec_Port::setDefault");
}
/*
* ======== rmm_delete ========
*/
void rmm_delete(struct rmm_target_obj *target)
{
struct rmm_ovly_sect *ovly_section;
struct rmm_header *hptr;
struct rmm_header *next;
u32 i;
DBC_REQUIRE(target);
kfree(target->seg_tab);
if (target->ovly_list) {
while ((ovly_section = (struct rmm_ovly_sect *)lst_get_head
(target->ovly_list))) {
kfree(ovly_section);
}
DBC_ASSERT(LST_IS_EMPTY(target->ovly_list));
kfree(target->ovly_list);
}
if (target->free_list != NULL) {
/* Free elements on freelist */
for (i = 0; i < target->num_segs; i++) {
hptr = next = target->free_list[i];
while (next) {
hptr = next;
next = hptr->next;
kfree(hptr);
}
}
kfree(target->free_list);
}
kfree(target);
}
ENS_API_EXPORT OMX_ERRORTYPE NmfMpc_ProcessingComponent::allocateBuffer(
OMX_U32 nPortIndex,
OMX_U32 nBufferIndex,
OMX_U32 nSizeBytes,
OMX_U8 **ppData,
void **bufferAllocInfo,
void **portPrivateInfo)
{
OMX_ERRORTYPE error;
error = doBufferAllocation(nPortIndex, nBufferIndex, nSizeBytes, ppData, bufferAllocInfo);
if (error != OMX_ErrorNone) return error;
DBC_ASSERT(bufferAllocInfo != 0);
OMX_U32 bufPhysicalAddr = getBufferPhysicalAddress(*bufferAllocInfo, *ppData, nSizeBytes);
OMX_U32 bufMpcAddress = getBufferMpcAddress(*bufferAllocInfo);
SharedBuffer *sharedBuf = new SharedBuffer(mENSComponent.getNMFDomainHandle(),
nSizeBytes, *ppData, bufPhysicalAddr, bufMpcAddress, *bufferAllocInfo, error);
if (sharedBuf == 0) return OMX_ErrorInsufficientResources;
if (error != OMX_ErrorNone) return error;
*portPrivateInfo = sharedBuf;
return OMX_ErrorNone;
}
OMX_ERRORTYPE MPEG4Enc_ArmNmf_ProcessingComponent::configure()
{
OstTraceFiltInst0(TRACE_API, "=> MPEG4Enc_ArmNmf_ProcessingComponent::configure()");
OMX_ERRORTYPE error;
if(pProxyComponent->mSendParamToArmNmf.get())
{
error = configureAlgo();
OstTraceFiltInst1(TRACE_FLOW, "MPEG4ENC_ARM_MPC : Return value of configureAlgo() API : 0x%x \n",error);
DBC_ASSERT(error==OMX_ErrorNone);
setparamitf.setParameter(ID_VEC_MPEG4,mParamBufferDesc);
//Pass LinkList desc to DataDep
//>iDdep.setNeeds(mChannelId,mLinkListBufferDesc,mDebugBufferDesc);
//Pass Param desc to DataDep
//>iDdep.setParameter(mChannelId,ID_VEC_MPEG4,mParamBufferDesc);
pProxyComponent->mSendParamToArmNmf.reset();
}
OstTraceFiltInst0(TRACE_API, "<= MPEG4Enc_ArmNmf_ProcessingComponent::configure()");
return OMX_ErrorNone;
}
/*
* ======== strm_free_buffer ========
* Purpose:
* Frees the buffers allocated for a stream.
*/
int strm_free_buffer(struct strm_res_object *strmres, u8 ** ap_buffer,
u32 num_bufs, struct process_context *pr_ctxt)
{
int status = 0;
u32 i = 0;
struct strm_object *stream_obj = strmres->stream;
DBC_REQUIRE(refs > 0);
DBC_REQUIRE(ap_buffer != NULL);
if (!stream_obj)
status = -EFAULT;
if (!status) {
for (i = 0; i < num_bufs; i++) {
DBC_ASSERT(stream_obj->xlator != NULL);
status =
cmm_xlator_free_buf(stream_obj->xlator,
ap_buffer[i]);
if (status)
break;
ap_buffer[i] = NULL;
}
}
drv_proc_update_strm_res(num_bufs - i, strmres);
return status;
}
/*
* ======== cmm_xlator_free_buf ========
* Purpose:
* Free the given SM buffer and descriptor.
* Does not free virtual memory.
*/
int cmm_xlator_free_buf(struct cmm_xlatorobject *xlator, void *pBufVa)
{
struct cmm_xlator *xlator_obj = (struct cmm_xlator *)xlator;
int status = -EPERM;
void *buf_pa = NULL;
DBC_REQUIRE(refs > 0);
DBC_REQUIRE(pBufVa != NULL);
DBC_REQUIRE(xlator_obj->ul_seg_id > 0);
if (xlator_obj) {
/* convert Va to Pa so we can free it. */
buf_pa = cmm_xlator_translate(xlator, pBufVa, CMM_VA2PA);
if (buf_pa) {
status = cmm_free_buf(xlator_obj->hcmm_mgr, buf_pa,
xlator_obj->ul_seg_id);
if (DSP_FAILED(status)) {
/* Uh oh, this shouldn't happen. Descriptor
* gone! */
DBC_ASSERT(false); /* CMM is leaking mem */
}
}
}
return status;
}
/*
* ======== dev_brd_write_fxn ========
* Purpose:
* Exported function to be used as the COD write function. This function
* is passed a handle to a DEV_hObject, then calls the
* device's bridge_brd_write() function.
*/
u32 dev_brd_write_fxn(void *pArb, u32 ulDspAddr, void *pHostBuf,
u32 ul_num_bytes, u32 nMemSpace)
{
struct dev_object *dev_obj = (struct dev_object *)pArb;
u32 ul_written = 0;
int status;
DBC_REQUIRE(refs > 0);
DBC_REQUIRE(pHostBuf != NULL); /* Required of BrdWrite(). */
if (dev_obj) {
/* Require of BrdWrite() */
DBC_ASSERT(dev_obj->hwmd_context != NULL);
status =
(*dev_obj->wmd_interface.
pfn_brd_write) (dev_obj->hwmd_context, pHostBuf, ulDspAddr,
ul_num_bytes, nMemSpace);
/* Special case of getting the address only */
if (ul_num_bytes == 0)
ul_num_bytes = 1;
if (DSP_SUCCEEDED(status))
ul_written = ul_num_bytes;
}
return ul_written;
}
// Automatically called by the VFM when the parameter of the port are set.
// It returns the minimum sizeof the buffer
OMX_U32 MPEG2Dec_Port::getBufferSize() const
{
OstTraceInt0(TRACE_FLOW,"Enter MPEG2Dec_Port::getBufferSize");
OMX_U32 default_return = 256;
switch (getDirection())
{
case OMX_DirInput:
//+CR369244
if(VFM_SocCapabilityMgt::getMPEG4DecInputBuffSize())
{
default_return = VFM_SocCapabilityMgt::getMPEG4DecInputBuffSize();
}
break;
case OMX_DirOutput:
default_return = (getFrameWidth()*(getFrameHeight() + 16)*3)/2; // Need 16 more pixel in height for some interleaved streams
break;
default:
DBC_ASSERT(0==1);
}
#ifdef PACKET_VIDEO_SUPPORT
if(mSuggestedBufferSize != 0) {
default_return = mSuggestedBufferSize;
}
#endif
OstTraceInt0(TRACE_FLOW,"Exit MPEG2Dec_Port::getBufferSize");
return default_return;
}
ENS_API_EXPORT OMX_ERRORTYPE NmfMpc_ProcessingComponent::freeBuffer(
OMX_U32 nPortIndex,
OMX_U32 nBufferIndex,
OMX_BOOL bBufferAllocated,
void *bufferAllocInfo,
void *portPrivateInfo)
{
if (nPortIndex>=mENSComponent.getPortCount() || mENSComponent.getPort(nPortIndex)==0) {
return OMX_ErrorBadPortIndex;
}
OMX_ERRORTYPE error;
SharedBuffer *sharedBuf = static_cast<SharedBuffer *>(portPrivateInfo);
if (bBufferAllocated) {
error = doBufferDeAllocation(nPortIndex, nBufferIndex, bufferAllocInfo);
if(error != OMX_ErrorNone) return error;
} else if (useBufferNeedsMemcpy()){
error = doBufferDeAllocation(nPortIndex, nBufferIndex, (void*)sharedBuf->getBufferAllocInfo());
if(error != OMX_ErrorNone) return error;
} else {
ENS_Port *port = mENSComponent.getPort(nPortIndex);
MMHwBuffer *sharedChunk = (MMHwBuffer *)port->getSharedChunk();
if (sharedChunk && (nBufferIndex == 0)) { // ER342234
error = MMHwBuffer::Close(sharedChunk);
DBC_ASSERT(error == OMX_ErrorNone);
port->setSharedChunk(0);
}
}
delete sharedBuf;
return OMX_ErrorNone;
}
void JPEGEnc_ArmNmfProcessingComponent::set_pJecOther_parameters(JPEGEnc_Proxy *jpegenc, ts_ddep_sec_jpeg_param_desc_ *ps_ddep_sec_jpeg_param_desc, t_uint32 header_size_in_bytes, t_uint8 *headerBufferAddress, t_uint8* thumbnailImageBufferAddress, t_uint8* runLevelBufferAddress)
{
OstTraceFiltInst1(TRACE_API, "In JPEGEnc_ArmNmfProcessingComponent : In set_pJecOther_parameters <line no %d> ",__LINE__);
t_cm_system_address sysAddr;
sysAddr.logical = (t_uint32 )(t_uint32 )mHeaderBufferDesc.nLogicalAddress;;
DBC_ASSERT(sysAddr.logical);
ps_ddep_sec_jpeg_param_desc->s_header_buf.addr_header_buffer = (t_ahb_address)headerBufferAddress;
nNumber_arm = pProxyComponent->mParam.nNumber_param;
if(pProxyComponent->mParam.outputCompressionFormat == OMX_IMAGE_CodingJPEG)
{
memcpy((t_uint8 *)&ps_ddep_sec_jpeg_param_desc->header_buffer, (t_uint8 *)sysAddr.logical, header_size_in_bytes);
ps_ddep_sec_jpeg_param_desc->s_header_buf.header_size = header_size_in_bytes;
}
if(pProxyComponent->mParam.outputCompressionFormat == OMX_IMAGE_CodingEXIF)
{
ps_ddep_sec_jpeg_param_desc->s_header_buf.header_size = EXIF_HEADER + mHeaderBufferDesc.nSize; //size in bytes!
}
OstTraceFiltInst2(TRACE_FLOW, "In JPEGEnc_ArmNmfProcessingComponent : In set_pJecOther_parameters header Size : 0x%x <line no %d> ",ps_ddep_sec_jpeg_param_desc->s_header_buf.header_size,__LINE__);
//ps_ddep_sec_jpeg_param_desc->s_header_buf.header_size = header_size_in_bytes;// Puneet *8; //size in bits!
ps_ddep_sec_jpeg_param_desc->s_out_fram_buffer.addr_dest_buffer = (t_ahb_address)thumbnailImageBufferAddress;
ps_ddep_sec_jpeg_param_desc->s_internal_buffer.addr_jpeg_run_level_buffer = (t_ahb_address)runLevelBufferAddress;
ps_ddep_sec_jpeg_param_desc->s_in_out_frame_parameters.restart_mcu_count = jpegenc->mParam.getRestartInterval();
ps_ddep_sec_jpeg_param_desc->s_ddep_in_param.nSliceHeight = (OMX_U16)jpegenc->getSliceHeight();
ps_ddep_sec_jpeg_param_desc->s_ddep_in_param.nStride = (OMX_U16)jpegenc->getStride();
OstTraceFiltInst1(TRACE_API, "In JPEGEnc_ArmNmfProcessingComponent : set_pJecOther_parameters DONE <line no %d> ",__LINE__);
}
ENS_API_EXPORT OMX_ERRORTYPE NmfHostMpc_ProcessingComponent::emptyThisBuffer(OMX_BUFFERHEADERTYPE* pBuffer)
{
OMX_U32 portIndex = pBuffer->nInputPortIndex;
if (portIndex>=mENSComponent.getPortCount() || mENSComponent.getPort(pBuffer->nInputPortIndex)==0) {
return OMX_ErrorBadPortIndex;
}
ENS_Port * port = static_cast<ENS_Port *>(mENSComponent.getPort(pBuffer->nInputPortIndex));
if(port->isMpc())
{
SharedBuffer *sharedbuffer = static_cast<SharedBuffer *>(pBuffer->pInputPortPrivate);
DBC_ASSERT(pBuffer->nFilledLen <= pBuffer->nAllocLen);
sharedbuffer->updateMPCHeader();
mIemptyThisBufferMpc[pBuffer->nInputPortIndex].emptyThisBuffer(sharedbuffer->getMPCHeader());
}
else
{
mIemptyThisBuffer[pBuffer->nInputPortIndex].emptyThisBuffer(pBuffer);
}
return OMX_ErrorNone;
}
SCF_STATE CAM_SM::ZSLHDRCapture(s_scf_event const *e)
{
switch (e->sig) {
case SCF_STATE_ENTRY_SIG:
{
ENTRY;
MSG0("HDR: CAM_SM::ZSLHDRCapture- SCF_STATE_ENTRY_SIG\n");
pResourceSharerManager->mRSPing.Ping(0);
return 0;
}
case Q_PONG_SIG:
{
((COmxCamera*)&mENSComponent)->eStateZSLHDR = ZSLHDRState_TakeCapture;
MSG0("HDR: CAM_SM::ZSLHDRCapture - Q_PONG_SIG\n");
pOpModeMgr->ConfigCapturing[RawCapturePort] = OMX_TRUE;
pOpModeMgr->UpdateCurrentOpMode();
OMX_ERRORTYPE err = OMX_ErrorNone;
err = pOpModeMgr->Compute_NumberOfBuffersForStill();
if (OMX_ErrorNone != err)
{
DBC_ASSERT(0);
}
MSG1("HDR: pOpModeMgr->NumberOfBuffersForStill = %d\n", pOpModeMgr->NumberOfBuffersForStill);
pGrabControl->startBurstCapture(CAMERA_PORT_OUT1, pOpModeMgr->NumberOfBuffersForStill);
p3AComponentManager->setMode(SW3A_MODE_SET_HDR_CAPTURE, 0);
SCF_TRANSIT_TO(&CAM_SM::ProcessPendingEvents);
return 0;
}
case SCF_STATE_EXIT_SIG: EXIT; return 0;
default: break;
}
return SCF_STATE_PTR(&CAM_SM::ProcessPendingEvents);
}
SCF_STATE CAM_SM::TimeNudge_FlashEnabledStartSw3A(s_scf_event const * e)
{
switch (e->sig)
{
case SCF_STATE_ENTRY_SIG:
{
ENTRY;
MSG0("CAM_SM::TimeNudge_FlashEnabledStartSw3A- SCF_STATE_ENTRY_SIG\n");
pResourceSharerManager->mRSPing.Ping(0);
return 0;
}
case Q_PONG_SIG:
{
MSG0("CAM_SM::TimeNudge_FlashEnabledStartSw3A - Q_PONG_SIG\n");
extradataCircularBuffer_init();
pIspctlCom->writePE(SystemSetup_e_GrabMode_Ctrl_Byte0, GrabMode_e_FORCE_OK);
return 0;
}
case EVT_ISPCTL_INFO_SIG:
{
MSG0("CAM_SM::TimeNudge_FlashEnabledStartSw3A - EVT_ISPCTL_INFO_SIG\n");
p3AComponentManager->setMode(SW3A_MODE_SET_TIME_NUDGE, 0);
DBC_ASSERT(p3AComponentManager->whatNextAfterStart == NULL);
p3AComponentManager->whatNextAfterStart = SCF_STATE_PTR(&CAM_SM::TimeNudge_StartHiddenCapture);
SCF_TRANSIT_TO(&CAM_SM::SW3A_Start);
return 0;
}
case SCF_STATE_EXIT_SIG: EXIT; return 0;
default: break;
}
return SCF_STATE_PTR(&CAM_SM::EnteringOpMode);
}
SCF_STATE CAM_SM::TimeNudge_StartCapture(s_scf_event const *e) {
switch (e->sig) {
case SCF_STATE_ENTRY_SIG:
{
ENTRY;
MSG0("CAM_SM::TimeNudge_StartCapture-SCF_STATE_ENTRY_SIG\n");
pResourceSharerManager->mRSPing.Ping(0);
return 0;
}
case Q_PONG_SIG:
{
MSG0("CAM_SM::TimeNudge_StartCapture-Q_PONG_SIG\n");
OstTraceFiltStatic0(TRACE_DEBUG, "CAM_SM::TimeNudge_StartCapture-SCF_STATE_ENTRY_SIG", (&mENSComponent));
/* check that we have enough buffers on port (nFrameBefore + nFrameLimit needed) */
/* NB : nFrameBefore + 1 should be enough but it is not supported right now */
camport * vpb1 = (camport *) mENSComponent.getPort(CAMERA_PORT_OUT1);
t_sw3A_FlashDirective flashDirective = p3AComponentManager->mFlashController.getDirective();
if(flashDirective.flashState == SW3A_FLASH_MAINFLASH)
{
//clear Extradata circular buffers
extradataCircularBuffer_init();
}
if ((OMX_TRUE == pOpModeMgr->IsTimeNudgeEnabled())
&& (vpb1->getParamPortDefinition().nBufferCountActual < (pOpModeMgr->GetFrameBefore()+pOpModeMgr->GetBurstFrameLimit()))) {
MSG0("CAM_SM::TimeNudge_StartCapture-OMX_ErrorBadParameter\n");
OstTraceFiltStatic0(TRACE_DEBUG, "CAM_SM::TimeNudge_StartCapture-OMX_ErrorBadParameter", (&mENSComponent));
mENSComponent.eventHandler(OMX_EventError, (OMX_U32)OMX_ErrorBadParameter, 0);
return 0;
}
pOpModeMgr->captureRequest[CAMERA_PORT_OUT1] ++;
OMX_ERRORTYPE err = OMX_ErrorNone;
err = pOpModeMgr->Compute_NumberOfBuffersForStill();
if (OMX_ErrorNone != err)
{
DBC_ASSERT(0);
}
if (1 == pOpModeMgr->NumberOfBuffersForStill)
{
pGrabControl->setStartOneShotCapture(CAMERA_PORT_OUT1);
}
else
{
pGrabControl->startBurstCapture(CAMERA_PORT_OUT1, (t_uint16)pOpModeMgr->NumberOfBuffersForStill);
}
SCF_PSTATE next;
SM_POP_STATE(next);
SCF_TRANSIT_TO_PSTATE(next);
return 0;
}
case SCF_STATE_EXIT_SIG: EXIT; return 0;
default: break;
}
return SCF_STATE_PTR(&CAM_SM::EnteringOpMode);
}
/*
* ======== cmm_create ========
* Purpose:
* Create a communication memory manager object.
*/
int cmm_create(OUT struct cmm_object **ph_cmm_mgr,
struct dev_object *hdev_obj,
IN CONST struct cmm_mgrattrs *pMgrAttrs)
{
struct cmm_object *cmm_obj = NULL;
int status = 0;
struct util_sysinfo sys_info;
DBC_REQUIRE(refs > 0);
DBC_REQUIRE(ph_cmm_mgr != NULL);
*ph_cmm_mgr = NULL;
/* create, zero, and tag a cmm mgr object */
cmm_obj = kzalloc(sizeof(struct cmm_object), GFP_KERNEL);
if (cmm_obj != NULL) {
if (pMgrAttrs == NULL)
pMgrAttrs = &cmm_dfltmgrattrs; /* set defaults */
/* 4 bytes minimum */
DBC_ASSERT(pMgrAttrs->ul_min_block_size >= 4);
/* save away smallest block allocation for this cmm mgr */
cmm_obj->ul_min_block_size = pMgrAttrs->ul_min_block_size;
/* save away the systems memory page size */
sys_info.dw_page_size = PAGE_SIZE;
sys_info.dw_allocation_granularity = PAGE_SIZE;
sys_info.dw_number_of_processors = 1;
if (DSP_SUCCEEDED(status)) {
cmm_obj->dw_page_size = sys_info.dw_page_size;
} else {
cmm_obj->dw_page_size = 0;
status = -EPERM;
}
/* Note: DSP SM seg table(aDSPSMSegTab[]) zero'd by
* MEM_ALLOC_OBJECT */
if (DSP_SUCCEEDED(status)) {
/* create node free list */
cmm_obj->node_free_list_head =
kzalloc(sizeof(struct lst_list),
GFP_KERNEL);
if (cmm_obj->node_free_list_head == NULL)
status = -ENOMEM;
else
INIT_LIST_HEAD(&cmm_obj->
node_free_list_head->head);
}
if (DSP_SUCCEEDED(status))
mutex_init(&cmm_obj->cmm_lock);
if (DSP_SUCCEEDED(status))
*ph_cmm_mgr = cmm_obj;
else
cmm_destroy(cmm_obj, true);
} else {
status = -ENOMEM;
}
return status;
}
inline void VFM_NmfHost_ProcessingComponent::vfm_assert_static(int condition, int line, OMX_BOOL isFatal, int param1, int param2)
{
if (!condition) {
OstTraceInt3(TRACE_ERROR, "VFM: VFM_NmfHost_ProcessingComponent: vfm_assert_static: VIDEOTRACE Error line %d, param1=%d param2=%d\n", line, param1, param2);
if (isFatal) {
DBC_ASSERT(0==1);
}
}
}
inline void H264Dec_Proxy::h264dec_assert_static(int condition, int line, OMX_BOOL isFatal)
{
if (!condition) {
OstTraceInt1(TRACE_ERROR, "H264DEC: proxy_ddep: H264Dec_Proxy: h264dec_assert: error line %d", line);
if (isFatal) {
DBC_ASSERT(0==1);
}
}
}
/*
* ======== bridge_chnl_create ========
* Create a channel manager object, responsible for opening new channels
* and closing old ones for a given board.
*/
int bridge_chnl_create(OUT struct chnl_mgr **phChnlMgr,
struct dev_object *hdev_obj,
IN CONST struct chnl_mgrattrs *pMgrAttrs)
{
int status = 0;
struct chnl_mgr *chnl_mgr_obj = NULL;
u8 max_channels;
/* Check DBC requirements: */
DBC_REQUIRE(phChnlMgr != NULL);
DBC_REQUIRE(pMgrAttrs != NULL);
DBC_REQUIRE(pMgrAttrs->max_channels > 0);
DBC_REQUIRE(pMgrAttrs->max_channels <= CHNL_MAXCHANNELS);
DBC_REQUIRE(pMgrAttrs->word_size != 0);
/* Allocate channel manager object */
chnl_mgr_obj = kzalloc(sizeof(struct chnl_mgr), GFP_KERNEL);
if (chnl_mgr_obj) {
/* The max_channels attr must equal the # of supported
* chnls for each transport(# chnls for PCPY = DDMA =
* ZCPY): i.e. pMgrAttrs->max_channels = CHNL_MAXCHANNELS =
* DDMA_MAXDDMACHNLS = DDMA_MAXZCPYCHNLS. */
DBC_ASSERT(pMgrAttrs->max_channels == CHNL_MAXCHANNELS);
max_channels = CHNL_MAXCHANNELS + CHNL_MAXCHANNELS * CHNL_PCPY;
/* Create array of channels: */
chnl_mgr_obj->ap_channel = kzalloc(sizeof(struct chnl_object *)
* max_channels, GFP_KERNEL);
if (chnl_mgr_obj->ap_channel) {
/* Initialize chnl_mgr object: */
/* Shared memory driver. */
chnl_mgr_obj->dw_type = CHNL_TYPESM;
chnl_mgr_obj->word_size = pMgrAttrs->word_size;
/* total # chnls supported */
chnl_mgr_obj->max_channels = max_channels;
chnl_mgr_obj->open_channels = 0;
chnl_mgr_obj->dw_output_mask = 0;
chnl_mgr_obj->dw_last_output = 0;
chnl_mgr_obj->hdev_obj = hdev_obj;
if (DSP_SUCCEEDED(status))
spin_lock_init(&chnl_mgr_obj->chnl_mgr_lock);
} else {
status = -ENOMEM;
}
} else {
status = -ENOMEM;
}
if (DSP_FAILED(status)) {
bridge_chnl_destroy(chnl_mgr_obj);
*phChnlMgr = NULL;
} else {
/* Return channel manager object to caller... */
*phChnlMgr = chnl_mgr_obj;
}
return status;
}
/*
* ======== bridge_chnl_cancel_io ========
* Return all I/O requests to the client which have not yet been
* transferred. The channel's I/O completion object is
* signalled, and all the I/O requests are queued as IOC's, with the
* status field set to CHNL_IOCSTATCANCEL.
* This call is typically used in abort situations, and is a prelude to
* chnl_close();
*/
int bridge_chnl_cancel_io(struct chnl_object *chnl_obj)
{
int status = 0;
struct chnl_object *pchnl = (struct chnl_object *)chnl_obj;
u32 chnl_id = -1;
s8 chnl_mode;
struct chnl_irp *chnl_packet_obj;
struct chnl_mgr *chnl_mgr_obj = NULL;
/* Check args: */
if (pchnl && pchnl->chnl_mgr_obj) {
chnl_id = pchnl->chnl_id;
chnl_mode = pchnl->chnl_mode;
chnl_mgr_obj = pchnl->chnl_mgr_obj;
} else {
status = -EFAULT;
}
if (DSP_FAILED(status))
goto func_end;
/* Mark this channel as cancelled, to prevent further IORequests or
* IORequests or dispatching. */
spin_lock_bh(&chnl_mgr_obj->chnl_mgr_lock);
pchnl->dw_state |= CHNL_STATECANCEL;
if (LST_IS_EMPTY(pchnl->pio_requests))
goto func_cont;
if (pchnl->chnl_type == CHNL_PCPY) {
/* Indicate we have no more buffers available for transfer: */
if (CHNL_IS_INPUT(pchnl->chnl_mode)) {
io_cancel_chnl(chnl_mgr_obj->hio_mgr, chnl_id);
} else {
/* Record that we no longer have output buffers
* available: */
chnl_mgr_obj->dw_output_mask &= ~(1 << chnl_id);
}
}
/* Move all IOR's to IOC queue: */
while (!LST_IS_EMPTY(pchnl->pio_requests)) {
chnl_packet_obj =
(struct chnl_irp *)lst_get_head(pchnl->pio_requests);
if (chnl_packet_obj) {
chnl_packet_obj->byte_size = 0;
chnl_packet_obj->status |= CHNL_IOCSTATCANCEL;
lst_put_tail(pchnl->pio_completions,
(struct list_head *)chnl_packet_obj);
pchnl->cio_cs++;
pchnl->cio_reqs--;
DBC_ASSERT(pchnl->cio_reqs >= 0);
}
}
func_cont:
spin_unlock_bh(&chnl_mgr_obj->chnl_mgr_lock);
func_end:
return status;
}
/*
* ======== bridge_chnl_create ========
* Create a channel manager object, responsible for opening new channels
* and closing old ones for a given board.
*/
int bridge_chnl_create(struct chnl_mgr **channel_mgr,
struct dev_object *hdev_obj,
const struct chnl_mgrattrs *mgr_attrts)
{
int status = 0;
struct chnl_mgr *chnl_mgr_obj = NULL;
u8 max_channels;
/* Check DBC requirements: */
DBC_REQUIRE(channel_mgr != NULL);
DBC_REQUIRE(mgr_attrts != NULL);
DBC_REQUIRE(mgr_attrts->max_channels > 0);
DBC_REQUIRE(mgr_attrts->max_channels <= CHNL_MAXCHANNELS);
DBC_REQUIRE(mgr_attrts->word_size != 0);
/* Allocate channel manager object */
chnl_mgr_obj = kzalloc(sizeof(struct chnl_mgr), GFP_KERNEL);
if (chnl_mgr_obj) {
/*
* The max_channels attr must equal the # of supported chnls for
* each transport(# chnls for PCPY = DDMA = ZCPY): i.e.
* mgr_attrts->max_channels = CHNL_MAXCHANNELS =
* DDMA_MAXDDMACHNLS = DDMA_MAXZCPYCHNLS.
*/
DBC_ASSERT(mgr_attrts->max_channels == CHNL_MAXCHANNELS);
max_channels = CHNL_MAXCHANNELS + CHNL_MAXCHANNELS * CHNL_PCPY;
/* Create array of channels */
chnl_mgr_obj->ap_channel = kzalloc(sizeof(struct chnl_object *)
* max_channels, GFP_KERNEL);
if (chnl_mgr_obj->ap_channel) {
/* Initialize chnl_mgr object */
chnl_mgr_obj->dw_type = CHNL_TYPESM;
chnl_mgr_obj->word_size = mgr_attrts->word_size;
/* Total # chnls supported */
chnl_mgr_obj->max_channels = max_channels;
chnl_mgr_obj->open_channels = 0;
chnl_mgr_obj->dw_output_mask = 0;
chnl_mgr_obj->dw_last_output = 0;
chnl_mgr_obj->hdev_obj = hdev_obj;
spin_lock_init(&chnl_mgr_obj->chnl_mgr_lock);
} else {
status = -ENOMEM;
}
} else {
status = -ENOMEM;
}
if (status) {
bridge_chnl_destroy(chnl_mgr_obj);
*channel_mgr = NULL;
} else {
/* Return channel manager object to caller... */
*channel_mgr = chnl_mgr_obj;
}
return status;
}
SCF_STATE CAM_SM::PowerUp_STC_CheckCoin(s_scf_event const *e) {
switch (e->sig) {
case SCF_STATE_ENTRY_SIG:
{
ENTRY;
MSG0("PowerUp_STC_CheckCoin-SCF_STATE_ENTRY_SIG\n");
OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_CheckCoin-SCF_STATE_ENTRY_SIG", (&mENSComponent));
// Get coin value
pIspctlCom->queuePE(Sensor_Tuning_Status_e_Coin_SubBlock_Status_Byte0,0);
pIspctlCom->readQueue();
return 0;
}
case EVT_ISPCTL_LIST_INFO_SIG:
{
MSG0("PowerUp_STC_CheckCoin-EVT_ISPCTL_LIST_INFO_SIG\n");
OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_CheckCoin-EVT_ISPCTL_LIST_INFO_SIG", (&mENSComponent));
if (e->type.ispctlInfo.info_id != ISP_READLIST_DONE) break;
//#if defined (OSI_DEBUG)
for(t_uint16 i=0; i < e->type.ispctlInfo.number_of_pe; i++) {
MSG4(" PE[%d] 0x%X (%s) = 0x%lX\n", i, e->type.ispctlInfo.Listvalue[i].pe_addr, pSensor->GetPeName(e->type.ispctlInfo.Listvalue[i].pe_addr), e->type.ispctlInfo.Listvalue[i].pe_data );
//OstTraceFiltStatic4(TRACE_DEBUG, " PE[%d] 0x%X (%s) = 0x%lX", (&mENSComponent), i, e->type.ispctlInfo.Listvalue[i].pe_addr, CXp70::GetPeName(e->type.ispctlInfo.Listvalue[i].pe_addr), e->type.ispctlInfo.Listvalue[i].pe_data );
}
//#endif
if( (Coin_te)e->type.ispctlInfo.Listvalue[0].pe_data == iStatusCoin) {
// Coin state has not changed yet
if(iStatusCoinRetriesCount>=10) {
MSG0("***** Coin state unchanged, too many attempts *****\n");
OstTraceFiltStatic0(TRACE_DEBUG, "***** Coin state unchanged, too many attempts *****", (&mENSComponent));
DBC_ASSERT(0);
return 0;
}
MSG1(" Coin state unchanged (state=%d) => try again\n", (int)iStatusCoin);
OstTraceFiltStatic1(TRACE_DEBUG, "Coin state unchanged (state=%d) => try again", (&mENSComponent), (int)iStatusCoin);
iStatusCoinRetriesCount++;
pIspctlCom->queuePE(Sensor_Tuning_Status_e_Coin_SubBlock_Status_Byte0,0);
pIspctlCom->readQueue();
}
else {
// Coin state changed => we can read the block ID value
iStatusCoin = (Coin_te) e->type.ispctlInfo.Listvalue[0].pe_data;
MSG1(" Coin state unchanged (state=%d) => read Block ID value\n", (int)iStatusCoin);
OstTraceFiltStatic1(TRACE_DEBUG, "Coin state unchanged (state=%d) => read Block ID value", (&mENSComponent), (int)iStatusCoin);
iStatusCoinRetriesCount = 0;
SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_ReadId);
}
return 0;
}
case SCF_STATE_EXIT_SIG:
{
EXIT;
return 0;
}
default: break;
}
return SCF_STATE_PTR(&COM_SM::SHARED_ControlingISPState_Boot);
}
void MPEG2Dec_Port::mpeg2dec_port_assert(OMX_ERRORTYPE omxError, OMX_U32 line, OMX_BOOL isFatal)
{
if (OMX_ErrorNone != omxError)
{
OstTraceInt2(TRACE_ERROR, "MPEG2Dec_Port : errorType : 0x%x error line no %d\n", omxError,line);
if (isFatal)
{
DBC_ASSERT(0==1);
}
}
}
ENS_API_EXPORT SharedBuffer * NmfHostMpc_ProcessingComponent::getSharedBuffer(t_uint32 dspBufferHdrArmAddress, bool enableCopy)
{
ARMSharedBuffer_t *arm_shared_buffer = (ARMSharedBuffer_t *)dspBufferHdrArmAddress;
SharedBuffer *sharedbuffer = (SharedBuffer *)(arm_shared_buffer->hostClassAddr);
if (sharedbuffer == 0) {
DBC_ASSERT(0);
return 0;
}
sharedbuffer->updateOMXHeader(enableCopy);
return sharedbuffer;
}
void JPEGEnc_ArmNmfProcessingComponent::jpegenc_armnmf_assert(OMX_ERRORTYPE omxError, OMX_U32 line, OMX_BOOL isFatal)
{
if (OMX_ErrorNone != omxError)
{
OstTraceInt2(TRACE_ERROR, "JPEGENC_ARM_NMF : errorType : 0x%x error line no %d\n", omxError,line);
if (isFatal)
{
DBC_ASSERT(0==1);
}
}
}
