C++ TRACE_1函数代码示例

/****************************************************************************
Name          : plms_mds_callback

Description   : This callback routine will be called by MDS on event arrival

Arguments     : info - pointer to the mds callback info

Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE

Notes         : None.
*****************************************************************************/
SaUint32T plms_mds_callback(struct ncsmds_callback_info *info)
{
	uns32 rc = NCSCC_RC_SUCCESS;
	PLMS_CB *cb = plms_cb;

	assert(info != NULL);

	switch (info->i_op) {
		case MDS_CALLBACK_COPY:
			rc = plms_mds_cpy(info);
			break;
		case MDS_CALLBACK_ENC:
			rc = plms_mds_enc(&info->info.enc, &cb->edu_hdl);
			break;
		case MDS_CALLBACK_DEC:
			rc = plms_mds_dec(&info->info.dec,&cb->edu_hdl);
			break;
		case MDS_CALLBACK_ENC_FLAT:
			if (1) {        /*Set to zero for righorous testing of byteorderr
				   enc/dec. */
				rc = plms_mds_enc_flat( info,&cb->edu_hdl);
			} else {
				rc = plms_mds_enc( &info->info.enc_flat,&cb->edu_hdl);
			}
			break;
		case MDS_CALLBACK_DEC_FLAT:
			if (1) {        /*Set to zero for righorous testing of byteorderr
				    enc/dec. */
				rc = plms_mds_dec_flat( info,&cb->edu_hdl);
			} else {
				rc = plms_mds_dec( &info->info.dec_flat,&cb->edu_hdl);
			}
			break;
		case MDS_CALLBACK_RECEIVE:
			rc = plms_mds_rcv(&(info->info.receive));
			break;
		case MDS_CALLBACK_SVC_EVENT:
			rc = plms_mds_svc_evt(&(info->info.svc_evt));
			break;
		case MDS_CALLBACK_QUIESCED_ACK:
			rc = plms_proc_quiesced_ack_evt();
			break;
		case MDS_CALLBACK_DIRECT_RECEIVE:
			rc = NCSCC_RC_FAILURE;
			TRACE_1("MDS_CALLBACK_DIRECT_RECEIVE - do nothing");
			break;
		default:
			LOG_ER("Illegal type of MDS message");
			rc = NCSCC_RC_FAILURE;
			break;
	}
	return rc;
}

/*!
 * \param *dc The DecodingContext containing macroblock array we want to freed.
 *
 * This function free **mb_array, which is an array of pointers to macroblock elements.
 * mb_array is in a DecodingContext structure. There can only be one mb_array at a time.
 * Please note that in order to avoid memory leak, this function begin by calling freeMbArrayContent().
 */
void freeMbArray(DecodingContext_t *dc)
{
    if (dc->mb_array != NULL)
    {
        freeMbArrayContent(dc);

        free(dc->mb_array);
        dc->mb_array = NULL;

        TRACE_1(MB, ">> mb_array freed\n");
    }
}

/****************************************************************************
 * Name          : gld_mds_glnd_down
 *
 * Description   : MDS indicated that a glnd has gone down
 *
 * Arguments     : evt  - Event structure
 *
 * Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
 *
 * Notes         : None.
 *****************************************************************************/
static uint32_t gld_mds_glnd_down(GLSV_GLD_EVT *evt)
{
	GLSV_GLD_CB *gld_cb = evt->gld_cb;
	GLSV_GLD_GLND_DETAILS *node_details = NULL;
	GLSV_GLD_RSC_INFO *rsc_info;
	uint32_t node_id;
	uint32_t rc = NCSCC_RC_FAILURE;
	TRACE_ENTER2("mds identification %u",gld_cb->my_dest_id );

	node_id = m_NCS_NODE_ID_FROM_MDS_DEST(evt->info.glnd_mds_info.mds_dest_id);

	if ((evt == GLSV_GLD_EVT_NULL) || (gld_cb == NULL))
		goto end;

	memcpy(&evt->fr_dest_id, &evt->info.glnd_mds_info.mds_dest_id, sizeof(MDS_DEST)
	    );

	if ((node_details = (GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details,
									   (uint8_t *)&node_id)) == NULL) {
		TRACE_1("Resource details is empty for glnd on node_id %u ", node_id);
		rc = NCSCC_RC_SUCCESS;
		goto end;
	}
	node_details->status = GLND_RESTART_STATE;

	TRACE("EVT Processing MDS GLND DOWN: node_id %u", node_details->node_id);
	memcpy(&node_details->restart_timer.mdest_id, &node_details->dest_id, sizeof(MDS_DEST));

	/* Start GLSV_GLD_GLND_RESTART_TIMEOUT timer */
	gld_start_tmr(gld_cb, &node_details->restart_timer, GLD_TMR_NODE_RESTART_TIMEOUT, GLD_NODE_RESTART_TIMEOUT, 0);

	/* Check whether this node is master for any resource, if yes send the status to all
	   the
	   non master nodes */
	if (gld_cb->ha_state == SA_AMF_HA_ACTIVE) {
		/* Check whether this node is master for any resource, if yes send the status to all the non master nodes */
		rsc_info = gld_cb->rsc_info;
		while (rsc_info != NULL) {
			if (rsc_info->node_list) {
				if (rsc_info->node_list->node_id == node_details->node_id)
					gld_snd_master_status(gld_cb, rsc_info, GLND_RESOURCE_MASTER_RESTARTED);
			}
			rsc_info = rsc_info->next;
		}

		/* If this node is non master for any resource, then send node status to the master */
		gld_process_send_non_master_status(gld_cb, node_details, GLND_RESTART_STATE);

	}
 end:
	TRACE_LEAVE2("Return value: %u", rc);
	return rc;
}

void launchServer( void )
{
    TRACE_2( SERVER , "lanchServer()");

    TRACE_1( SERVER , "Start server on port %d..." , portCli );

    pthread_create( &serverCliThread , NULL , ( void * )&createServer , &portCli );

    /* We have to increment the thread count by 2, because we don't use createThread() function. */
    incrementThreadCount( 2 );

}

uint8_t *read_ebml_data_binary(Bitstream_t *bitstr, EbmlElement_t *element,
                               FILE *xml, const char *name)
{
    TRACE_2(MKV, "read_ebml_data_binary2(%i bytes)", element->size);

    uint8_t *value = new uint8_t [element->size+1];
    if (value)
    {
        for (int i = 0; i < element->size; i++)
            value[i] = read_bits(bitstr, 8);
        value[element->size] = '\0';

        if (name)
        {
#if ENABLE_DEBUG
            TRACE_1(MKV, "* %s  = 0x", name);

            if (element->size > 1023)
                TRACE_1(MKV, "* %s  = (first 1024B) 0x", name);
            else
                TRACE_1(MKV, "* %s  = 0x", name);
            for (int i = 0; i < element->size && i < 1024; i++)
                printf("%02X", value[i]);
#endif // ENABLE_DEBUG

            if (xml)
            {
                if (element->size > 1023)
                    fprintf(xml, "  <%s>(first 1024B) 0x", name);
                else
                    fprintf(xml, "  <%s>0x", name);
                for (int i = 0; i < element->size && i < 1024; i++)
                    fprintf(xml, "%02X", value[i]);
                fprintf(xml, "</%s>\n", name);
            }
        }
    }

    return value;
}

static int mp3_indexer_track(MediaFile_t *media, mp3_t *mp3)
{
    TRACE_1(MP3, BLD_GREEN "mp3_indexer_track()" CLR_RESET);
    int retcode = FAILURE;

    // Write track metadata (samples have been written already)
    if (media && media->tracks_audio[0])
    {
        MediaStream_t *track = media->tracks_audio[0];
        track->stream_type = stream_AUDIO;

        if (mp3->mpeg_layer == 1)
            track->stream_codec = CODEC_MPEG_L1;
        else if (mp3->mpeg_layer == 2)
            track->stream_codec = CODEC_MPEG_L2;
        else
            track->stream_codec = CODEC_MPEG_L3;

        if (mp3->audio_channels == 0)
        {
            track->channel_count = 2;
            //track->channel_mode = CHAN_STEREO;
        }
        else if (mp3->audio_channels == 1)
        {
            track->channel_count = 2;
            //track->channel_mode = CHAN_STEREO_JOINT;
        }
        else if (mp3->audio_channels == 2)
        {
            track->channel_count = 2;
            //track->channel_mode = CHAN_DUAL;
        }
        else if (mp3->audio_channels == 3)
        {
            track->channel_count = 1;
            //track->channel_mode = CHAN_MONO;
        }

        track->sampling_rate = mp3->audio_samplingrate;
        track->bit_per_sample = 16;

        // SAMPLES
        track->stream_packetized = false;
        track->frame_count = mp3->sample_count;
        track->stream_size = mp3->sample_size_total;

        retcode = SUCCESS;
    }

    return retcode;
}

// -----------------------------------------------------------------------------
// CXIMPSrvSessionAdapter::~CXIMPSrvSessionAdapter()
// -----------------------------------------------------------------------------
//
EXPORT_C CXIMPSrvSessionAdapter::~CXIMPSrvSessionAdapter()
    {
    delete iMessage;
    
    iServer.SessionDied();
    delete iSessionImp;

    TRACE_1( _L("CXIMPSrvSessionAdapter[%d]::~CXIMPSrvSessionAdapter()"),
                 this );
    #if _BullseyeCoverage
    cov_write();
    #endif
    }

/****************************************************************************
 * Name          : mqd_tmr_stop
 *
 * Description   : This function which is used to stop the MQD Timer
 *
 * Arguments     : tmr      - Timer needs to be stoped.
 *
 * Return Values : None.
 *
 * Notes         : None.
 *****************************************************************************/
void mqd_tmr_stop(MQD_TMR *tmr)
{
	TRACE_1("The timer stopped");
	if (tmr->is_active == true) {
		m_NCS_TMR_STOP(tmr->tmr_id);
		tmr->is_active = false;
	}
	if (tmr->tmr_id != TMR_T_NULL) {
		m_NCS_TMR_DESTROY(tmr->tmr_id);
		tmr->tmr_id = TMR_T_NULL;
	}
	return;
}

/****************************************************************************\
 PROCEDURE NAME : mqd_quisced_process

 DESCRIPTION    : This routine process the Quisced ack event.

 ARGUMENTS      : pMqd - MQD Control block pointer
                  quisced_info - MQD_QUISCED_STATE_INFO structure pointer

 RETURNS        : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
\*****************************************************************************/
static uint32_t mqd_quisced_process(MQD_CB *pMqd, MQD_QUISCED_STATE_INFO *quisced_info)
{
	SaAisErrorT saErr = SA_AIS_OK;
	uint32_t rc = NCSCC_RC_SUCCESS;
	TRACE_ENTER();

	if (pMqd && pMqd->is_quisced_set) {
		pMqd->ha_state = SA_AMF_HA_QUIESCED;
		rc = mqd_mbcsv_chgrole(pMqd);
		if (rc != NCSCC_RC_SUCCESS) {
			TRACE_4("Quiesced Processing at MQD ,MBCSV Changerole failed");
			return rc;
		}
		saAmfResponse(pMqd->amf_hdl, quisced_info->invocation, saErr);
		pMqd->is_quisced_set = false;
		TRACE_1("Quisced Processing at MQD is successfull");
	} else
		TRACE_1("Received Unsolicited Quisced Ack at MQD");

	TRACE_LEAVE();
	return rc;
}

/****************************************************************************
 * Name          : mqd_tmr_start
 *
 * Description   : This function which is used to start the MQD Timer
 *
 *****************************************************************************/
uint32_t mqd_tmr_start(MQD_TMR *tmr, SaTimeT duration)
{
	TRACE_1("The timer started with the duration as %u", (uint32_t)duration);
	if (tmr->tmr_id == TMR_T_NULL) {
		m_NCS_TMR_CREATE(tmr->tmr_id, duration, mqd_timer_expiry, (void *)tmr);
	}

	if (tmr->is_active == false) {
		m_NCS_TMR_START(tmr->tmr_id, (uint32_t)duration, mqd_timer_expiry, (void *)tmr);
		tmr->is_active = true;
	}

	return (NCSCC_RC_SUCCESS);
}

// ---------------------------------------------------------------------------
// COperationSubscribePresentityPresence::RequestCompletedL()
// ---------------------------------------------------------------------------
//
void COperationSubscribePresentityPresence::RequestCompletedL()
    {
    TRACE(_L("COperationSubscribePresentityPresence::RequestCompletedL()" ) );
    CXIMPOperationBase::RequestCompletedL();

    if( iStatusObj->ResultCode() == KErrNone )
        {
        if( iSubscriptionStatus == CPresentityPresenceSubscriptionItem::ENotSubscribedAtAll )
            {
            TRACE(_L("COperationSubscribePresentityPresence::RequestCompletedL() ENotSubscribedAtAll" ) );
            MXIMPBase* object = NULL; 
            iObjCollection->GetByType( object, MXIMPIdentity::KInterfaceId );
            if( object )
                {
                TRACE(_L("COperationSubscribePresentityPresence::RequestCompletedL() identity change" ) );
                delete iIdentity;
                iIdentity = TXIMPGetImpClassOrPanic< CXIMPIdentityImp >::From( *object );

                // Got altered identity. If it differs from original
                // we'll create a new subscription item and close the old.
                CPresentityPresenceSubscriptionItem& altSubItem = 
                    iMyHost->PresenceDataAccess().PresenceDataCache().PresentityPresenceSubscriptionItemLC( *iIdentity );

                iSubItem->Close();
                iSubItem = &altSubItem;

                CleanupStack::Pop(); // altSubItem                    
                }            
            }
            
        if( iSubscriptionStatus == CPresentityPresenceSubscriptionItem::ENotSubscribedAtAll ||
            iSubscriptionStatus == CPresentityPresenceSubscriptionItem::ESubscribedForOtherCtxOnly )
            {
            TRACE(_L("COperationSubscribePresentityPresence::RequestCompletedL() calling iSubItem->AddSubscriberL" ) );
            TInt error ( KErrNone );
            TRAP( error, iSubItem->AddSubscriberL( iContext ) );
            TRACE_1( _L("COperationSubscribePresentityPresence::RequestCompletedL():  iSubItem->AddSubscriberL : error =%d"), error );
            }
            
        iContext->SetPresenceInfoFilterL( MXIMPPscContext::EPresentityPresenceFilter,
                iPif, iIdentity );
        iPif = NULL;
        iSubItem->SetSubscriptionPif( iMergedPif );
        iMergedPif = NULL;

        SynthesiseEventL();
        }
    }

SaAisErrorT ntfsv_filter_attr_change_alloc(SaNtfAttributeChangeNotificationFilterT *filter,
														SaUint16T numSourceIndicators)
{
	SaAisErrorT rc = SA_AIS_OK;

	filter->sourceIndicators = NULL;
	filter->numSourceIndicators = numSourceIndicators;
	if (numSourceIndicators != 0) {
	filter->sourceIndicators = (SaNtfSourceIndicatorT *) malloc(numSourceIndicators * sizeof(SaNtfSourceIndicatorT));
	if (filter->sourceIndicators == NULL) {
		TRACE_1("Out of memory in SourceIndicators field");
		rc = SA_AIS_ERR_NO_MEMORY;
		}
	}
	return rc;
}

SaAisErrorT ntfsv_filter_obj_cr_del_alloc(SaNtfObjectCreateDeleteNotificationFilterT *filter,
														SaUint16T numSourceIndicators)
{
	SaAisErrorT rc = SA_AIS_OK;

	filter->sourceIndicators = NULL;
	filter->numSourceIndicators = numSourceIndicators;
	if (numSourceIndicators != 0) {
	filter->sourceIndicators = (SaNtfSourceIndicatorT *) malloc(numSourceIndicators * sizeof(SaNtfSourceIndicatorT));
	if (filter->sourceIndicators == NULL) {
		TRACE_1("Out of memory in SourceIndicators field");
		rc = SA_AIS_ERR_NO_MEMORY;
		}
	}
	return rc;
}

int64_t read_ebml_data_int(Bitstream_t *bitstr, EbmlElement_t *element,
                           FILE *xml, const char *name)
{
    TRACE_2(MKV, "read_ebml_data_int2(%i bits)", element->size*8);
    int64_t value = (int64_t)read_bits_64(bitstr, element->size*8);

    if (name)
    {
        TRACE_1(MKV, "* %s  = %lli", name, value);
        if (xml)
        {
            fprintf(xml, "  <%s>%" PRId64 "</%s>\n", name, value, name);
        }
    }

    return value;
}

uint64_t read_ebml_data_uint_UID(Bitstream_t *bitstr, EbmlElement_t *element,
                                 FILE *xml, const char *name)
{
    TRACE_2(MKV, "read_ebml_data_uint_UID(%i bits)", element->size*8);
    uint64_t value = read_bits_64(bitstr, element->size * 8);

    if (name)
    {
        TRACE_1(MKV, "* %08X  = %llu", name, value);
        if (xml)
        {
            fprintf(xml, "  <%s>0x%" PRIX64 "</%s>\n", name, value, name);
        }
    }

    return value;
}