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

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