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