int SecCamera::getSnapshot(int xth)
{
    int index;
    int skipFirstNFrames = xth;

    LOG_TIME_START(0); // skip frames
    while (skipFirstNFrames) {
        LOGV("skipFrames %d", skipFirstNFrames);
        _v4l2Cam->waitFrame();
        index = _v4l2Cam->dqBuf();
        _v4l2Cam->qBuf(index);
        skipFirstNFrames--;
    }

    _v4l2Cam->waitFrame();
    index = _v4l2Cam->dqBuf();
    LOG_TIME_END(0);

    LOG_TIME_START(1);
    _v4l2Cam->startStream(false);
    LOG_TIME_END(1);

    LOG_CAMERA("%s: get frame after skip %d(%lu), stopStream(%lu)",
               __func__, xth, LOG_TIME(0), LOG_TIME(1));

    return 0;
}
int SecCamera::startSnapshot(size_t* captureSize)
{
    LOG_TIME_START(0);
    stopPreview();
    LOG_TIME_END(0);

    int ret;
    LOG_TIME_START(1); // prepare
    ret = _v4l2Cam->setupBufs(_snapshotWidth, _snapshotHeight, _snapshotPixfmt,
                              1, 1);
    CHECK_EQ(ret, 1);

    ret = _v4l2Cam->mapBuf(0);
    CHECK_EQ(ret, 0);

    _v4l2Cam->qBuf(0);
    _v4l2Cam->startStream(true);
    LOG_TIME_END(1);

    LOG_CAMERA("%s: stopPreview(%lu), prepare(%lu) us",
               __func__, LOG_TIME(0), LOG_TIME(1));

    _v4l2Cam->mapBufInfo(0, NULL, captureSize);

    return 0;
}
示例#3
0
static void *surface_thread(void *arg)
{
	ASurface *surface = (ASurface *)arg;
	void *stream;
	AndroidSurfaceInfo src, dst;
	size_t size;
	LOG_TIME_DEFINE(buff);
	LOG_TIME_DEFINE(decode);

	running = 1;
	while(running == 1) {
		struct jpeg_frame *jpeg;
		LOG_TIME_START(buff);
		size = get_image_buffer(&stream);
		jpeg = stream;

		g_clear_screen_client = jpeg->encode_time;
		LOGD("Jerry: final g_clear_screen_client = %d",
				g_clear_screen_client);

		LOG_D("surface get buffer time delay: %d ms\n", (int)(timestamp() - jpeg->timestamp));
		src.bits = stream + sizeof(struct jpeg_frame);
		LOG_TIME_END(buff);

		if((size > 0) && running)
		{
			LOG_TIME_START(decode);
			lib_ASurface_lock(surface, &dst);
			lib_ASurface_scaleToFullScreen_skia(surface, &src, &dst, size - sizeof(struct jpeg_frame));
			lib_ASurface_unlockAndPost(surface);
			if(first_frame)
			{
				char msg[128];
				first_frame = 0;
				frame_count = 0;
				last_time = timestamp();
				sprintf(msg, "surface:%d:%d", jpeg->width, jpeg->height);
			}
			cal_fps();
			LOG_TIME_END(decode);
			LOG_D("surface display time delay: %d ms, decode and display = %ld ms\n", (int)(timestamp() - jpeg->timestamp), LOG_TIME(decode) / 1000);
			release_image_buffer();
		}

//		LOG_D("------get buff = %ld us, decode and display = %ld us-----\n",
//				LOG_TIME(buff), LOG_TIME(decode));
		g_clear_screen_client = 0;
	}

	return ((void *)0);
}
示例#4
0
static TinyRet DDD_ParseXml(UpnpDevice *thiz, TinyXml *xml)
{
    LOG_TIME_BEGIN(TAG, DDD_ParseXml);
    TinyRet ret = TINY_RET_OK;

    RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
    RETURN_VAL_IF_FAIL(xml, TINY_RET_E_ARG_NULL);

    do
    {
        TinyXmlNode *root = TinyXml_GetRoot(xml);
        if (root == NULL)
        {
            LOG_D(TAG, "Root Not Found");
            ret = TINY_RET_E_XML_INVALID;
            break;
        }

        if (!str_equal(TinyXmlNode_GetName(root), DDD_ROOT, true))
        {
            LOG_D(TAG, "Root Tag is invalid: %s", TinyXmlNode_GetName(root));
            ret = TINY_RET_E_XML_INVALID;
            break;
        }

        ret = DDD_LoadSpecVersion(thiz, root);
        if (RET_FAILED(ret))
        {
            LOG_D(TAG, "LoadSpecVersion failed");
            break;
        }

        ret = DDD_LoadDevice(thiz, root);
        if (RET_FAILED(ret))
        {
            LOG_D(TAG, "LoadDevice failed");
            break;
        }

        /* <URLBase> is optional */
        DDD_LoadUrlBase(thiz, root);

    } while (0);

    LOG_TIME_END(TAG, DDD_ParseXml);

    return ret;
}
示例#5
0
static TinyRet SDD_ParseXml(UpnpService *thiz, TinyXml *xml)
{
    LOG_TIME_BEGIN(TAG, SDD_ParseXml);
    TinyRet ret = TINY_RET_OK;

    RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
    RETURN_VAL_IF_FAIL(xml, TINY_RET_E_ARG_NULL);

    do
    {
        TinyXmlNode *root = TinyXml_GetRoot(xml);
        if (root == NULL)
        {
            ret = TINY_RET_E_XML_INVALID;
            break;
        }

        if (!str_equal(TinyXmlNode_GetName(root), SDD_ROOT_SCPD, true))
        {
            ret = TINY_RET_E_XML_INVALID;
            break;
        }

        ret = SDD_LoadSpecVersion(thiz, root);
        if (RET_FAILED(ret))
        {
            break;
        }
        
        ret = SDD_LoadServiceStateTable(thiz, root);
        if (RET_FAILED(ret))
        {
            break;
        }

        ret = SDD_LoadActionList(thiz, root);
        if (RET_FAILED(ret))
        {
            break;
        }
    } while (0);

    LOG_TIME_END(TAG, SDD_ParseXml);

    return ret;
}
示例#6
0
TinyRet UpnpDeviceParser_Parse(const char *url, UpnpDevice *device, uint32_t timeout)
{
    LOG_TIME_BEGIN(TAG, DDD_Parse);
    TinyRet ret = TINY_RET_OK;
    HttpClient *client = NULL;
    HttpMessage *request = NULL;
    HttpMessage *response = NULL;

    RETURN_VAL_IF_FAIL(device, TINY_RET_E_ARG_NULL);
    RETURN_VAL_IF_FAIL(url, TINY_RET_E_ARG_NULL);

    do
    {
        ret = UpnpDeviceParser_SetURLBase(device, url);
        if (RET_FAILED(ret))
        {
            LOG_D(TAG, "UpnpDevice_SetUrlBase failed: %s", tiny_ret_to_str(ret));
            break;
        }

        client = HttpClient_New();
        if (client == NULL)
        {
            ret = TINY_RET_E_NEW;
            break;
        }

        request = HttpMessage_New();
        if (request == NULL)
        {
            ret = TINY_RET_E_NEW;
            break;
        }

        response = HttpMessage_New();
        if (response == NULL)
        {
            ret = TINY_RET_E_NEW;
            break;
        }

        do
        {
            TinyXml *xml;

            ret = HttpMessage_SetRequest(request, "GET", url);
            if (RET_FAILED(ret))
            {
                LOG_D(TAG, "HttpMessage_Set_GET failed: %s", tiny_ret_to_str(ret));
                break;
            }

            ret = HttpClient_Execute(client, request, response, timeout);
            if (RET_FAILED(ret))
            {
                LOG_D(TAG, "HttpClient_Execute failed: %s", tiny_ret_to_str(ret));
                break;
            }

            if (HttpMessage_GetStatusCode(response) != HTTP_STATUS_OK)
            {
                LOG_D(TAG, "HttpMessage_GetStatusCode failed: %d %s",
                    HttpMessage_GetStatusCode(response),
                    HttpMessage_GetStatus(response));
                break;
            }

            xml = TinyXml_New();
            if (xml == NULL)
            {
                LOG_D(TAG, "Out of memory");
                ret = TINY_RET_E_NEW;
                break;
            }

            do
            {
                ret = TinyXml_Parse(xml, HttpMessage_GetContentObject(response), HttpMessage_GetContentSize(response));
                if (RET_FAILED(ret))
                {
                    LOG_D(TAG, "TinyXml_Parse failed: %s", tiny_ret_to_str(ret));
                    break;
                }

                ret = DDD_ParseXml(device, xml);
                if (RET_FAILED(ret))
                {
                    LOG_D(TAG, "DDD_ParseXml failed: %s", tiny_ret_to_str(ret));
                    break;
                }
            } while (0);

            TinyXml_Delete(xml);
        } while (0);
    } while (0);

    if (client != NULL)
    {
        HttpClient_Delete(client);
    }

    if (response != NULL)
    {
        HttpMessage_Delete(response);
    }

    if (request != NULL)
    {
        HttpMessage_Delete(request);
    }

    LOG_TIME_END(TAG, DDD_Parse);
    return ret;
}