自学教程：C++ DBC_ASSERT函数代码示例

// 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_ERRORTYPEIFM_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;}

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

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__);}

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);}

/* *  ======== 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);        }    }}

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);        }    }}