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

DisplayPlane* TngPlaneManager::getPlaneHelper(int dsp, int type){    RETURN_NULL_IF_NOT_INIT();    if (dsp < 0 || dsp > IDisplayDevice::DEVICE_EXTERNAL) {        ETRACE("Invalid display device %d", dsp);        return 0;    }    int index = dsp == IDisplayDevice::DEVICE_PRIMARY ? 0 : 1;    if (type == DisplayPlane::PLANE_PRIMARY ||        type == DisplayPlane::PLANE_CURSOR) {        return getPlane(type, index);    } else if (type == DisplayPlane::PLANE_SPRITE) {        return getAnyPlane(type);    } else if (type == DisplayPlane::PLANE_OVERLAY) {        // use overlay A for pipe A and overlay C for pipe B if possible        DisplayPlane *plane = getPlane(type, index);        if (plane == NULL) {            plane = getPlane(type, !index);        }        return plane;    } else {        ETRACE("invalid plane type %d", type);        return 0;    }}

static struct _ValidateNode * pvrAlloc(struct _WsbmVNodeFuncs * func,                                       int typeId){    CTRACE();    if(typeId == 0) {        struct PsbWsbmValidateNode * vNode = malloc(sizeof(*vNode));        if(!vNode) {            ETRACE("failed to allocate memory");            return NULL;        }        vNode->base.func = func;        vNode->base.type_id = 0;        return &vNode->base;    } else {        struct _ValidateNode * node = malloc(sizeof(*node));        if(!node) {            ETRACE("failed to allocate node");            return NULL;        }        node->func = func;        node->type_id = 1;        return node;    }}

DisplayPlane* TngPlaneManager::allocPlane(int index, int type){    DisplayPlane *plane = 0;    switch (type) {    case DisplayPlane::PLANE_PRIMARY:        plane = new TngPrimaryPlane(index, index);        break;    case DisplayPlane::PLANE_SPRITE:        plane = new TngSpritePlane(index, 0);        break;    case DisplayPlane::PLANE_OVERLAY:        plane = new TngOverlayPlane(index, 0);        break;    case DisplayPlane::PLANE_CURSOR:        plane = new TngCursorPlane(index, index /*disp */);        break;    default:        ETRACE("unsupported type %d", type);        break;    }    if (plane && !plane->initialize(DisplayPlane::MIN_DATA_BUFFER_COUNT)) {        ETRACE("failed to initialize plane.");        DEINIT_AND_DELETE_OBJ(plane);    }    return plane;}

int DisplayPlaneManager::getFreePlanes(int dsp, int type){    RETURN_NULL_IF_NOT_INIT();    if (dsp < 0 || dsp > IDisplayDevice::DEVICE_EXTERNAL) {        ETRACE("Invalid display device %d", dsp);        return 0;    }    if (type < 0 || type >= DisplayPlane::PLANE_MAX) {        ETRACE("Invalid plane type %d", type);        return 0;    }    uint32_t freePlanes = mFreePlanes[type] | mReclaimedPlanes[type];    if (type == DisplayPlane::PLANE_PRIMARY ||        type == DisplayPlane::PLANE_CURSOR) {        return ((freePlanes & (1 << dsp)) == 0) ? 0 : 1;    } else {        int count = 0;        for (int i = 0; i < 32; i++) {            if ((1 << i) & freePlanes) {                count++;            }        }        return count;    }    return 0;}

int psbWsbmWrapTTMBuffer(uint64_t handle, void **buf){    int ret = 0;    struct _WsbmBufferObject *wsbmBuf;    if (!buf) {        ETRACE("invalid parameter");        return -EINVAL;    }    ret = wsbmGenBuffers(mainPool, 1, &wsbmBuf, 0,                        (WSBM_PL_FLAG_VRAM | WSBM_PL_FLAG_TT |                        /*WSBM_PL_FLAG_NO_EVICT |*/ WSBM_PL_FLAG_SHARED));    if (ret) {        ETRACE("wsbmGenBuffers failed with error code %d", ret);        return ret;    }    ret = wsbmBOSetReferenced(wsbmBuf, handle);    if (ret) {        ETRACE("wsbmBOSetReferenced failed with error code %d", ret);        return ret;    }    *buf = (void *)wsbmBuf;    VTRACE("wrap buffer %p for handle %#x", wsbmBuf, handle);    return 0;}

OverlayBackBuffer* OverlayPlaneBase::createBackBuffer(){    CTRACE();    // create back buffer    OverlayBackBuffer *backBuffer = (OverlayBackBuffer *)malloc(sizeof(OverlayBackBuffer));    if (!backBuffer) {        ETRACE("failed to allocate back buffer");        return 0;    }    int size = sizeof(OverlayBackBufferBlk);    int alignment = 64 * 1024;    void *wsbmBufferObject = 0;    bool ret = mWsbm->allocateTTMBuffer(size, alignment, &wsbmBufferObject);    if (ret == false) {        ETRACE("failed to allocate TTM buffer");        return 0;    }    void *virtAddr = mWsbm->getCPUAddress(wsbmBufferObject);    uint32_t gttOffsetInPage = mWsbm->getGttOffset(wsbmBufferObject);    backBuffer->buf = (OverlayBackBufferBlk *)virtAddr;    backBuffer->gttOffsetInPage = gttOffsetInPage;    backBuffer->bufObject = wsbmBufferObject;    VTRACE("cpu %p, gtt %d", virtAddr, gttOffsetInPage);    return backBuffer;}

static int saudio_snd_init_ipc(struct snd_saudio *saudio){	int result = 0;	int32_t i = 0, j = 0;	struct saudio_stream *stream = NULL;	struct saudio_dev_ctrl *dev_ctrl = NULL;	ADEBUG();	for (i = 0; i < SAUDIO_DEV_MAX; i++) {	/* now only support  one device */		dev_ctrl = &saudio->dev_ctrl[i];		result =		    sblock_create(dev_ctrl->dst, dev_ctrl->monitor_channel,				  SAUDIO_MONITOR_BLOCK_COUNT, CMD_BLOCK_SIZE,				  SAUDIO_MONITOR_BLOCK_COUNT, CMD_BLOCK_SIZE);		if (result) {			ETRACE			    ("saudio:monitor channel create  failed result is %d/n",			     result);			goto __nodev;		}		result =		    sblock_create(dev_ctrl->dst, dev_ctrl->channel,				  SAUDIO_CMD_BLOCK_COUNT, CMD_BLOCK_SIZE,				  SAUDIO_CMD_BLOCK_COUNT, CMD_BLOCK_SIZE);		if (result) {			ETRACE			    ("saudio_thread sblock create  failed result is %d/n",			     result);			goto __nodev;		}		pr_debug("saudio_thread sblock create  result is %d/n", result);		for (j = 0; j < SAUDIO_STREAM_MAX; j++) {			stream = &dev_ctrl->stream[j];			result =			    sblock_create(stream->dst, stream->channel,					  SAUDIO_STREAM_BLOCK_COUNT,					  TX_DATA_BLOCK_SIZE,					  SAUDIO_STREAM_BLOCK_COUNT,					  RX_DATA_BLOCK_SIZE);			if (result) {				ETRACE				    ("saudio_thread sblock create  failed result is %d/n",				     result);				goto __nodev;			}			sblock_register_notifier(stream->dst, stream->channel,						 sblock_notifier, stream);			pr_debug("saudio_thread sblock create  result is %d/n",				 result);		}	}	ADEBUG();	return result;__nodev:	ETRACE("initialization failed/n");	return result;}

bool UeventObserver::initialize(){    mListeners.clear();    if (mUeventFd != -1) {        return true;    }    mThread = new UeventObserverThread(this);    if (!mThread.get()) {        ETRACE("failed to create uevent observer thread");        return false;    }    // init uevent socket    struct sockaddr_nl addr;    // set the socket receive buffer to 64K    // NOTE: this is only called for once    int sz = 64 * 1024;    memset(&addr, 0, sizeof(addr));    addr.nl_family = AF_NETLINK;    addr.nl_pid =  pthread_self() | getpid();    addr.nl_groups = 0xffffffff;    mUeventFd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);    if (mUeventFd < 0) {        DEINIT_AND_RETURN_FALSE("failed to create uevent socket");    }    if (setsockopt(mUeventFd, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz))) {        WTRACE("setsockopt() failed");        //return false;    }    if (bind(mUeventFd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {        DEINIT_AND_RETURN_FALSE("failed to bind scoket");        return false;    }    memset(mUeventMessage, 0, UEVENT_MSG_LEN);    int exitFds[2];    if (pipe(exitFds) < 0) {        ETRACE("failed to make pipe");        deinitialize();        return false;    }    mExitRDFd = exitFds[0];    mExitWDFd = exitFds[1];    return true;}

void vp8_translate_parse_status(vp8_Status status){    switch (status)    {    case VP8_UNSUPPORTED_VERSION:        ETRACE("Parser returns VP8_UNSUPPORTED_VERSION");        break;    case VP8_UNSUPPORTED_BITSTREAM:        ETRACE("Parser returns VP8_UNSUPPORTED_BITSTREAM");        break;    case VP8_INVALID_FRAME_SYNC_CODE:        ETRACE("Parser returns VP8_INVALID_FRAME_SYNC_CODE");        break;    case VP8_UNEXPECTED_END_OF_BITSTREAM:        ETRACE("Parser returns VP8_UNEXPECTED_END_OF_BITSTREAM");        break;    case VP8_CORRUPT_FRAME:        ETRACE("Parser returns VP8_CORRUPT_FRAME");        break;    case VP8_MEMORY_ERROR:        ETRACE("Parser returns MEMORY_ERROR");        break;    case VP8_NO_INITIALIZATION:        ETRACE("Parser returns VP8_NO_INITIALIZATION");        break;    case VP8_UNKNOWN_ERROR:        ETRACE("Parser returns VP8_UNKNOWN_ERROR");        break;    }    return;}

int psbWsbmInitialize(int drmFD){    union drm_psb_extension_arg arg;    const char drmExt[] = "psb_ttm_placement_alphadrop";    int ret = 0;    CTRACE();    if (drmFD <= 0) {        ETRACE("invalid drm fd %d", drmFD);        return drmFD;    }    /*init wsbm*/    ret = wsbmInit(wsbmNullThreadFuncs(), &vNodeFuncs);    if (ret) {        ETRACE("failed to initialize Wsbm, error code %d", ret);        return ret;    }    VTRACE("DRM_PSB_EXTENSION %d", DRM_PSB_EXTENSION);    /*get devOffset via drm IOCTL*/    strncpy(arg.extension, drmExt, sizeof(drmExt));    ret = drmCommandWriteRead(drmFD, 6/*DRM_PSB_EXTENSION*/, &arg, sizeof(arg));    if(ret || !arg.rep.exists) {        ETRACE("failed to get device offset, error code %d", ret);        goto out;    }    VTRACE("ioctl offset %#x", arg.rep.driver_ioctl_offset);    mainPool = wsbmTTMPoolInit(drmFD, arg.rep.driver_ioctl_offset);    if(!mainPool) {        ETRACE("failed to initialize TTM Pool");        ret = -EINVAL;        goto out;    }    VTRACE("Wsbm initialization succeeded. mainPool %p", mainPool);    return 0;out:    psbWsbmTakedown();    return ret;}

voidEventDispatcher::SetDragMessage(BMessage& message,	ServerBitmap* bitmap, const BPoint& offsetFromCursor){	ETRACE(("EventDispatcher::SetDragMessage()/n"));	BAutolock _(this);	if (fLastButtons == 0) {		// mouse buttons has already been released or was never pressed		bitmap->ReleaseReference();		return;	}	if (fDragBitmap != bitmap) {		if (fDragBitmap)			fDragBitmap->ReleaseReference();		fDragBitmap = bitmap;		if (fDragBitmap != NULL)			fDragBitmap->AcquireReference();	}	fHWInterface->SetDragBitmap(bitmap, offsetFromCursor);	fDragMessage = message;	fDraggingMessage = true;	fDragOffset = offsetFromCursor;}

bool FDHandler::AddFd(int fd) {  if (fd < 0) {    ETRACE("Cannot add negative fd: %d", fd);    return false;  }  auto it = fds_.find(fd);  if (it != fds_.end()) {    ETRACE("FD already being watched: %d/n", it->first);    return false;  }  fds_.emplace(fd, FDWatch());  return true;}

void TngSpritePlane::setZOrderConfig(ZOrderConfig& zorderConfig,                                          void *nativeConfig){    if (!nativeConfig) {        ETRACE("Invalid parameter, no native config");        return;    }    mAbovePrimary = false;    int primaryIndex = -1;    int spriteIndex = -1;    // only consider force bottom when overlay is active    for (size_t i = 0; i < zorderConfig.size(); i++) {        DisplayPlane *plane = zorderConfig[i]->plane;        if (plane->getType() == DisplayPlane::PLANE_PRIMARY)            primaryIndex = i;        if (plane->getType() == DisplayPlane::PLANE_SPRITE) {            spriteIndex = i;        }    }    // if has overlay plane which is below primary plane    if (spriteIndex > primaryIndex) {        mAbovePrimary = true;    }    struct intel_dc_plane_zorder *zorder =        (struct intel_dc_plane_zorder *)nativeConfig;    zorder->abovePrimary = mAbovePrimary ? 1 : 0;}

    static intvaudio_thread (void* data){#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)    daemonize();#else    daemonize("vaudio-fe");#endif    data = (void*) vaudio;    while (!vaudio_thread_aborted) {	down (&vaudio_thread_sem);	if ( (vaudio_thread_init_now & 2) ) {	    vaudio_thread_init_now &= ~2;	    snd_card_free(vaudio_card);	    if (vaudio_snd_probe() < 0) {		ETRACE ("virtual audio ALSA card initialization failed/n");	    }	}	if ( (vaudio_thread_init_now & 1) ) {	    vaudio_thread_init_now &= ~1;	    vaudio_snd_init_card(data);	}    }    complete_and_exit(&vaudio_thread_completion, 0);	/*NOTREACHED*/    return 0;}

bool UeventObserver::threadLoop(){    if (mUeventFd == -1) {        ETRACE("invalid uEvent file descriptor");        return false;    }    struct pollfd fds[2];    int nr;    fds[0].fd = mUeventFd;    fds[0].events = POLLIN;    fds[0].revents = 0;    fds[1].fd = mExitRDFd;    fds[1].events = POLLIN;    fds[1].revents = 0;    nr = poll(fds, 2, -1);    if (nr > 0 && fds[0].revents == POLLIN) {        int count = recv(mUeventFd, mUeventMessage, UEVENT_MSG_LEN - 2, 0);        if (count > 0) {            onUevent();        }    } else if (fds[1].revents) {        close(mExitRDFd);        mExitRDFd = -1;        ITRACE("exiting wait");        return false;    }    // always looping    return true;}

boolEventDispatcher::_AddTokens(BMessage* message, EventTarget* target,	uint32 eventMask, BMessage* nextMouseMoved, int32* _viewToken){	_RemoveTokens(message);	int32 count = target->CountListeners();	int32 added = 0;	for (int32 i = 0; i < count; i++) {		event_listener* listener = target->ListenerAt(i);		if ((listener->EffectiveEventMask() & eventMask) == 0)			continue;		if (nextMouseMoved != NULL && message->what == B_MOUSE_MOVED			&& (listener->EffectiveOptions() & B_NO_POINTER_HISTORY) != 0			&& message != nextMouseMoved			&& _viewToken != NULL) {			if (listener->token == *_viewToken) {				// focus view doesn't want to get pointer history				*_viewToken = B_NULL_TOKEN;			}			continue;		}		ETRACE(("  add token %ld/n", listener->token));		if (message->AddInt32(kTokenName, listener->token) == B_OK)			added++;	}	return added != 0;}

void UeventObserver::onUevent(){    char *msg = mUeventMessage;    const char *envelope = DrmConfig::getUeventEnvelope();    if (strncmp(msg, envelope, strlen(envelope)) != 0)        return;    msg += strlen(msg) + 1;    UeventListener *listener;    String8 key;    while (*msg) {        key = String8(msg);        if (mListeners.indexOfKey(key) >= 0) {            DTRACE("received Uevent: %s", msg);            listener = mListeners.valueFor(key);            if (listener) {                listener->func(listener->data);            } else {                ETRACE("no listener for uevent %s", msg);            }        }        msg += strlen(msg) + 1;    }}

Decode_Status VideoDecoderVP8::decode(VideoDecodeBuffer *buffer) {    Decode_Status status;    vbp_data_vp8 *data = NULL;    if (buffer == NULL) {        ETRACE("VideoDecodeBuffer is NULL.");        return DECODE_INVALID_DATA;    }    status = VideoDecoderBase::parseBuffer(                 buffer->data,                 buffer->size,                 false,                 (void**)&data);    CHECK_STATUS("VideoDecoderBase::parseBuffer");    mShowFrame = data->codec_data->show_frame;    if (!mVAStarted) {        status = startVA(data);        CHECK_STATUS("startVA");    }    VideoDecoderBase::setRotationDegrees(buffer->rotationDegrees);    status = decodeFrame(buffer, data);    return status;}

bool DisplayPlaneManager::initialize(){    int i, j;    if (mInitialized) {        WTRACE("object has been initialized");        return true;    }    // calculate total plane number and free plane bitmaps    mPlaneCount[DisplayPlane::PLANE_SPRITE] = mSpritePlaneCount;    mPlaneCount[DisplayPlane::PLANE_OVERLAY] = mOverlayPlaneCount;    mPlaneCount[DisplayPlane::PLANE_PRIMARY] = mPrimaryPlaneCount;    mPlaneCount[DisplayPlane::PLANE_CURSOR] = mCursorPlaneCount;    mTotalPlaneCount = mSpritePlaneCount+ mOverlayPlaneCount+ mPrimaryPlaneCount + mCursorPlaneCount;    if (mTotalPlaneCount == 0) {        ETRACE("plane count is not initialized");        return false;    }    for (i = 0; i < DisplayPlane::PLANE_MAX; i++) {        mFreePlanes[i] = ((1 << mPlaneCount[i]) - 1);    }    // allocate plane pools    for (i = 0; i < DisplayPlane::PLANE_MAX; i++) {        if (mPlaneCount[i]) {            mPlanes[i].setCapacity(mPlaneCount[i]);            for (j = 0; j < mPlaneCount[i]; j++) {                DisplayPlane* plane = allocPlane(j, i);                if (!plane) {                    ETRACE("failed to allocate plane %d, type %d", j, i);                    DEINIT_AND_RETURN_FALSE();                }                mPlanes[i].push_back(plane);            }        }    }    mInitialized = true;    return true;}

static int saudio_ctrl_thread(void *data){	int result = 0;	struct snd_saudio *saudio = (struct snd_saudio *)data;	ADEBUG();	result = saudio_snd_init_ipc(saudio);	if (result) {		printk(KERN_ERR "saudio:saudio_snd_init_ipc error %d/n",		       result);		return -1;	}	while (!kthread_should_stop()) {		printk(KERN_INFO		       "%s,saudio: waiting for modem boot handshake,dst %d,channel %d/n",		       __func__, saudio->dst, saudio->channel);		saudio_snd_wait_modem_restart(saudio);		saudio->in_init = 1;		printk(KERN_INFO		       "%s,saudio: modem boot and handshake ok,dst %d, channel %d/n",		       __func__, saudio->dst, saudio->channel);		saudio_snd_card_free(saudio);		printk(KERN_INFO		       "saudio_ctrl_thread flush work queue in dst %d, channel %d/n",		       saudio->dst, saudio->channel);		flush_workqueue(saudio->queue);		saudio->in_init = 0;		printk(KERN_INFO		       "saudio_ctrl_thread flush work queue out,dst %d, channel %d/n",		       saudio->dst, saudio->channel);		if(saudio_snd_notify_modem_clear(saudio)) {			printk(KERN_ERR " saudio_ctrl_thread modem error again when notify modem clear /n");		    continue;		}		saudio_clear_ctrl_cmd(saudio);		if(!saudio->card) {			result = saudio_snd_init_card(saudio);			printk(KERN_INFO			       "saudio: snd card init reulst %d, dst %d, channel %d/n",			       result, saudio->dst, saudio->channel);		}		mutex_lock(&saudio->mutex);		saudio->state = 1;		mutex_unlock(&saudio->mutex);	}	ETRACE("saudio_ctrl_thread  create  ok/n");	return 0;}

voidEventDispatcher::RemoveTemporaryListener(EventTarget& target, int32 token){	BAutolock _(this);	ETRACE(("events: remove temporary listener token %ld/n", token));	if (target.RemoveTemporaryListener(token) && target.IsEmpty())		fTargets.RemoveItem(&target);}

uint32_t psbWsbmGetKBufHandle(void *buf){    if (!buf) {        ETRACE("invalid ttm buffer");        return 0;    }    return (wsbmKBufHandle(wsbmKBuf((struct _WsbmBufferObject *)buf)));}

int main(int argc, char **argv){	int 	i_fd, w_fd;	char	f_name[255];	int	res, ie_size = 256 * (sizeof(struct inotify_event) + 16);		/* + len */	struct inotify_event *ie = malloc(ie_size);	I = stdout;	if( argc < 2 )  {		TRACE(0,"./ino file-for-watch/n");		return -1;	}	// FIXME	snprintf(f_name, 255, argv[1]);	/* init inotify subsystem */	i_fd = inotify_init();	if( i_fd < 0 ) {		ETRACE("[ERR] Cannot init inotify. errno: ");		return -1;	}	w_fd = inotify_add_watch(i_fd, f_name, IN_MODIFY|IN_ATTRIB);	if( w_fd < 0 ) {		ETRACE("[ERR] Cannot inotify fd event. errno: ");		return -1;	}	TRACE(0, "name of file for inotify %s/n", f_name);	do {		res = read(i_fd, ie, ie_size);		TRACE(0, "%s(): readed %d bytes/n", __func__, res);		if(ie->mask & IN_MODIFY) {			TRACE(0, "fd:%02d/tIN_MODIFY/n", ie->wd);		}	} while(1);	return 0;}