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

void
EventDispatcher::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 int
vaudio_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;
}