static uint32_t UpnpServiceParser_StateToXml(UpnpStateVariable *state, char *xml, uint32_t len)
{
RETURN_VAL_IF_FAIL(state, 0);
RETURN_VAL_IF_FAIL(xml, 0);
do
{
char buf[1024 + 1];
memset(buf, 0, 1024 + 1);
tiny_snprintf(buf, 1024, "<stateVariable sendEvents=\"%s\">", DataType_BooleanToString(state->sendEvents));
strcat(xml, buf);
memset(buf, 0, 1024 + 1);
tiny_snprintf(buf, 1024, "<name>%s</name>", state->definition.name);
strcat(xml, buf);
memset(buf, 0, 1024 + 1);
tiny_snprintf(buf, 1024, "<dataType>%s</dataType>", state->definition.dataType.name);
strcat(xml, buf);
strcat(xml, "</stateVariable>");
} while (0);
return strlen(xml);
}
// Get the next valid Opus frame.
bool opus_get_frame(rbstream_p mFp, ssize_t *offset, void *buffer, uint32_t *size)
{
size_t frame_size = 0;
uint8_t *buf = (uint8_t *) buffer;
for (;;) {
ssize_t n = _source_read_at(mFp, *offset, buffer, OPUS_PACKET_HEADER_LEN);
RETURN_VAL_IF_FAIL((n == OPUS_PACKET_HEADER_LEN), false);
if (OPUS_PACKET_SYNC_VERIFY(buf)) {
frame_size = OPUS_PACKET_GETSIZE(buf);
break;
}
// Lost sync.
ssize_t pos = *offset;
RETURN_VAL_IF_FAIL(opus_resync(mFp, &pos), false);
*offset = pos;
rbs_seek_ext(mFp, *offset, SEEK_SET);
// Try again with the new position.
}
ssize_t n = _source_read_at(mFp, *offset, buffer, frame_size);
RETURN_VAL_IF_FAIL((n == (ssize_t) frame_size), false);
*size = frame_size;
*offset += frame_size;
rbs_seek_ext(mFp, *offset, SEEK_SET);
return true;
}
static size_t _pull(size_t size, size_t least, rbstream_p rbsp)
{
RETURN_VAL_IF_FAIL(rbsp != NULL, SIZE_ZERO);
RETURN_VAL_IF_FAIL(rbsp->input_func != NULL, SIZE_ZERO);
medvdbg("[%s] size %lu, least %lu\n", __FUNCTION__, size, least);
if (least > size) {
// Large size ring-buffer is needed or you should dequeue read-data from ring-buffer in time.
medvdbg("[%s] WARNING!!! least[%lu] > size[%lu]\n", __FUNCTION__, least, size);
least = size;
RETURN_VAL_IF_FAIL(least > SIZE_ZERO, SIZE_ZERO); // ring-buffer is full.
}
size_t wlen = SIZE_ZERO;
size_t len;
do {
len = (rbsp->input_func)(rbsp->data, rbsp);
if (len == SIZE_ZERO) {
medvdbg("[%s] WARNING!!! no more data, wlen[%lu], least[%lu], size[%lu]\n", __FUNCTION__, wlen, least, size);
break;
}
wlen += len;
} while (wlen < least);
medvdbg("[%s] done, wlen %lu\n", __FUNCTION__, wlen);
return wlen;
}
static TinyRet UpnpDeviceParser_SetURLBase(UpnpDevice *thiz, const char *deviceUrl)
{
TinyRet ret = TINY_RET_OK;
RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
RETURN_VAL_IF_FAIL(deviceUrl, TINY_RET_E_ARG_NULL);
do
{
char url_base[TINY_URL_LEN];
char ip[TINY_IP_LEN];
uint16_t port = 0;
char uri[512];
memset(ip, 0, TINY_IP_LEN);
memset(uri, 0, 512);
ret = url_split(deviceUrl, ip, TINY_IP_LEN, &port, uri, 512);
if (RET_FAILED(ret))
{
break;
}
tiny_snprintf(url_base, TINY_URL_LEN, "http://%s:%d", ip, port);
UpnpDevice_SetURLBase(thiz, url_base);
} while (0);
return ret;
}
UpnpObject * UpnpObjectList_GetObject(UpnpObjectList *thiz, const char *usn)
{
RETURN_VAL_IF_FAIL(thiz, NULL);
RETURN_VAL_IF_FAIL(usn, NULL);
return (UpnpObject *)TinyMap_GetValue(&thiz->objects, usn);
}
TinyRet TcpClient_Send(TcpClient *thiz, const char *bytes, uint32_t size, uint32_t timeout)
{
TinyRet ret = TINY_RET_OK;
RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
RETURN_VAL_IF_FAIL(bytes, TINY_RET_E_ARG_NULL);
do
{
int sent = 0;
if (thiz->status != TCP_CLIENT_CONNECTED)
{
ret = TINY_RET_E_SOCKET_DISCONNECTED;
break;
}
ret = tiny_tcp_waiting_for_write(thiz->socket_fd, timeout);
if (RET_FAILED(ret))
{
break;
}
sent = tiny_tcp_write(thiz->socket_fd, bytes, size);
ret = (sent > 0) ? TINY_RET_OK : TINY_RET_E_SOCKET_WRITE;
} while (false);
return ret;
}
int _frame_decoder(audio_decoder_p decoder, pcm_data_p pcm)
{
switch (decoder->audio_type) {
case AUDIO_TYPE_MP3: {
tPVMP3DecoderExternal tmp_ext = *((tPVMP3DecoderExternal *) decoder->dec_ext);
tPVMP3DecoderExternal *mp3_ext = &tmp_ext;
mp3_ext->inputBufferUsedLength = 0;
ERROR_CODE errorCode = pvmp3_framedecoder(mp3_ext, decoder->dec_mem);
medvdbg("[%s] Line %d, pvmp3_framedecoder, errorCode %d\n", __FUNCTION__, __LINE__, errorCode);
RETURN_VAL_IF_FAIL((errorCode == NO_DECODING_ERROR), AUDIO_DECODER_ERROR);
pcm->length = mp3_ext->outputFrameSize;
pcm->samples = mp3_ext->pOutputBuffer;
pcm->channels = mp3_ext->num_channels;
pcm->samplerate = mp3_ext->samplingRate;
break;
}
case AUDIO_TYPE_AAC: {
tPVMP4AudioDecoderExternal *aac_ext = (tPVMP4AudioDecoderExternal *) decoder->dec_ext;
aac_ext->inputBufferUsedLength = 0;
aac_ext->remainderBits = 0;
Int decoderErr = PVMP4AudioDecodeFrame(aac_ext, decoder->dec_mem);
medvdbg("[%s] Line %d, PVMP4AudioDecodeFrame, decoderErr %d\n", __FUNCTION__, __LINE__, decoderErr);
RETURN_VAL_IF_FAIL((decoderErr == MP4AUDEC_SUCCESS), AUDIO_DECODER_ERROR);
pcm->length = aac_ext->frameLength * aac_ext->desiredChannels;
pcm->samples = aac_ext->pOutputBuffer;
pcm->channels = aac_ext->desiredChannels;
pcm->samplerate = aac_ext->samplingRate;
break;
}
#ifdef CONFIG_CODEC_LIBOPUS
case AUDIO_TYPE_OPUS: {
opus_dec_external_t *opus_ext = (opus_dec_external_t *) decoder->dec_ext;
Int err = opus_frameDecode(opus_ext, decoder->dec_mem);
medvdbg("[%s] Line %d, opus_frameDecode, err %d\n", __FUNCTION__, __LINE__, err);
RETURN_VAL_IF_FAIL((err == OPUS_OK), AUDIO_DECODER_ERROR);
pcm->length = opus_ext->outputFrameSize * opus_ext->desiredChannels;
pcm->samples = opus_ext->pOutputBuffer;
pcm->channels = opus_ext->desiredChannels;
pcm->samplerate = opus_ext->desiredSampleRate;
break;
}
#endif
default:
// No decoding, return failure.
return AUDIO_DECODER_ERROR;
}
return AUDIO_DECODER_OK;
}
int audio_decoder_init(audio_decoder_p decoder, size_t rbuf_size)
{
assert(decoder != NULL);
priv_data_p priv = (priv_data_p) malloc(sizeof(priv_data_t));
RETURN_VAL_IF_FAIL((priv != NULL), AUDIO_DECODER_ERROR);
// init private data
priv->mCurrentPos = 0;
priv->mFixedHeader = 0;
// init decoder data
decoder->cb_data = NULL;
decoder->input_func = NULL;
decoder->dec_ext = NULL;
decoder->dec_mem = NULL;
decoder->priv_data = priv;
// init ring-buffer and open it as a stream
rb_init(&decoder->ringbuffer, rbuf_size);
decoder->rbsp = rbs_open(&decoder->ringbuffer, _input_callback, (void *)decoder);
RETURN_VAL_IF_FAIL((decoder->rbsp != NULL), AUDIO_DECODER_ERROR);
rbs_ctrl(decoder->rbsp, OPTION_ALLOW_TO_DEQUEUE, 1);
return AUDIO_DECODER_OK;
}
TinyRet UpnpActionInvoker_Invoke(UpnpActionInvoker *thiz, UpnpAction *action, UpnpError *error)
{
TinyRet ret = TINY_RET_OK;
RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
RETURN_VAL_IF_FAIL(action, TINY_RET_E_ARG_NULL);
RETURN_VAL_IF_FAIL(error, TINY_RET_E_ARG_NULL);
return UpnpHttpClient_Post(&thiz->http->client, action, error, UPNP_TIMEOUT);
}
TinyRet TcpClient_Connect(TcpClient *thiz, const char *ip, uint16_t port, uint32_t timeout)
{
TinyRet ret = TINY_RET_OK;
RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
RETURN_VAL_IF_FAIL(ip, TINY_RET_E_ARG_NULL);
LOG_D(TAG, "TcpClient_Connect: %s:%d timeout:%d", ip, port, timeout);
do
{
if (thiz->status != TCP_CLIENT_DISCONNECT)
{
ret = TINY_RET_E_SOCKET_CONNECTED;
break;
}
ret = tiny_tcp_open(&thiz->socket_fd, false);
if (RET_FAILED(ret))
{
break;
}
ret = tiny_tcp_async_connect(thiz->socket_fd, ip, port);
if (RET_FAILED(ret))
{
break;
}
thiz->status = TCP_CLIENT_CONNECTING;
if (ret == TINY_RET_PENDING)
{
ret = tiny_tcp_waiting_for_connected(thiz->socket_fd, timeout);
if (RET_FAILED(ret))
{
tiny_tcp_close(thiz->socket_fd);
break;
}
}
thiz->status = TCP_CLIENT_CONNECTED;
strncpy(thiz->server_ip, ip, TINY_IP_LEN);
thiz->server_port = port;
tiny_socket_get_ip(thiz->socket_fd, thiz->self_ip, TINY_IP_LEN);
thiz->self_port = tiny_socket_get_port(thiz->socket_fd);
}
while (false);
thiz->status = RET_SUCCEEDED(ret) ? TCP_CLIENT_CONNECTED : TCP_CLIENT_DISCONNECT;
return ret;
}
GdkPixbuf*
gt_resource_donwloader_download_image_finish(GtResourceDownloader* self,
GAsyncResult* result, GError** error)
{
RETURN_VAL_IF_FAIL(GT_IS_RESOURCE_DOWNLOADER(self), NULL);
RETURN_VAL_IF_FAIL(G_IS_ASYNC_RESULT(result), NULL);
GdkPixbuf* ret = g_task_propagate_pointer(G_TASK(result), error);
return ret;
}
TinyRet TcpClient_StartRecv(TcpClient *thiz, TcpClientReceiveListener listener, void *ctx, uint32_t timeout)
{
TinyRet ret = TINY_RET_OK;
char * buf = NULL;
int size = 0;
RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
RETURN_VAL_IF_FAIL(listener, TINY_RET_E_ARG_NULL);
do
{
if (thiz->status != TCP_CLIENT_CONNECTED)
{
ret = TINY_RET_E_SOCKET_DISCONNECTED;
break;
}
ret = tiny_tcp_waiting_for_read(thiz->socket_fd, timeout);
if (RET_FAILED(ret))
{
break;
}
buf = (char *)tiny_malloc(thiz->recv_buf_size);
if (buf == NULL)
{
ret = TINY_RET_E_OUT_OF_MEMORY;
break;
}
while (true)
{
memset(buf, 0, thiz->recv_buf_size);
size = tiny_tcp_read(thiz->socket_fd, buf, thiz->recv_buf_size);
if (size <= 0)
{
ret = TINY_RET_E_SOCKET_READ;
break;
}
listener(thiz, buf, size, ctx);
}
}
while (false);
if (buf != NULL)
{
tiny_free(buf);
}
return ret;
}
static uint32_t UpnpServiceParser_ActionToXml(UpnpAction *action, char *xml, uint32_t len)
{
RETURN_VAL_IF_FAIL(action, 0);
RETURN_VAL_IF_FAIL(xml, 0);
do
{
uint32_t i = 0;
uint32_t count = 0;
strcat(xml, "<action>");
{
char name[1024];
memset(name, 0, 1024);
tiny_snprintf(name, 1024, "<name>%s</name>", UpnpAction_GetName(action));
strcat(xml, name);
}
strcat(xml, "<argumentList>");
count = UpnpAction_GetArgumentCount(action);
for (i = 0; i < count; ++i)
{
UpnpArgument * arg = UpnpAction_GetArgumentAt(action, i);
char name[1024];
char direction[1024];
char relatedStateVariable[1024];
memset(name, 0, 1024);
memset(direction, 0, 1024);
memset(relatedStateVariable, 0, 1024);
tiny_snprintf(name, 1024, "<name>%s</name>", UpnpArgument_GetName(arg));
tiny_snprintf(direction, 1024, "<direction>%s</direction>", UpnpArgumentDirection_ToString(UpnpArgument_GetDirection(arg)));
tiny_snprintf(relatedStateVariable, 1024, "<relatedStateVariable>%s</relatedStateVariable>",
UpnpArgument_GetRelatedStateVariable(arg));
strcat(xml, "<argument>");
strcat(xml, name);
strcat(xml, direction);
strcat(xml, relatedStateVariable);
strcat(xml, "</argument>");
}
strcat(xml, "</argumentList>");
strcat(xml, "</action>");
} while (0);
return strlen(xml);
}
uint32_t UpnpServiceParser_ToXml(UpnpService *service, char *xml, uint32_t len)
{
RETURN_VAL_IF_FAIL(service, 0);
RETURN_VAL_IF_FAIL(xml, 0);
do
{
uint32_t i = 0;
uint32_t count = 0;
strcat(xml,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
"<scpd xmlns=\"urn:schemas-upnp-org:service-1-0\">"
"<specVersion>"
"<major>1</major>"
"<minor>0</minor>"
"</specVersion>");
/* <actionList> */
strcat(xml, "<actionList>");
count = UpnpService_GetActionCount(service);
for (i = 0; i < count; ++i)
{
UpnpAction *action = UpnpService_GetActionAt(service, i);
char buf[1024 * 4];
memset(buf, 0, 1024 * 4);
UpnpServiceParser_ActionToXml(action, buf, 1024 * 4);
strcat(xml, buf);
}
strcat(xml, "</actionList>");
/* <stateVariableList> */
strcat(xml, "<serviceStateTable>");
count = UpnpService_GetStateVariableCount(service);
for (i = 0; i < count; ++i)
{
UpnpStateVariable * state = UpnpService_GetStateVariableAt(service, i);
char buf[1024 * 4];
memset(buf, 0, 1024 * 4);
UpnpServiceParser_StateToXml(state, buf, 1024 * 4);
strcat(xml, buf);
}
strcat(xml, "</serviceStateTable>");
strcat(xml, "</scpd>");
} while (0);
return strlen(xml);
}
int tiny_udp_write(int fd, const char *ip, uint16_t port, const char *buf, uint32_t len)
{
struct sockaddr_in receiver_addr;
int addr_len = sizeof(receiver_addr);
RETURN_VAL_IF_FAIL(ip, 0);
RETURN_VAL_IF_FAIL(buf, 0);
memset(&receiver_addr, 0, sizeof(receiver_addr));
receiver_addr.sin_family = AF_INET;
receiver_addr.sin_addr.s_addr = inet_addr(ip);
receiver_addr.sin_port = htons(port);
return sendto(fd, buf, len, 0, (struct sockaddr *)&receiver_addr, addr_len);
}
// Initialize the MP3 reader.
int mp3_init(audio_decoder_p decoder, void *dec_ext)
{
decoder->dec_ext = calloc(1, sizeof(tPVMP3DecoderExternal));
RETURN_VAL_IF_FAIL((decoder->dec_ext != NULL), AUDIO_DECODER_ERROR);
decoder->dec_mem = calloc(1, pvmp3_decoderMemRequirements());
RETURN_VAL_IF_FAIL((decoder->dec_mem != NULL), AUDIO_DECODER_ERROR);
*((tPVMP3DecoderExternal *) decoder->dec_ext) = *((tPVMP3DecoderExternal *) dec_ext);
pvmp3_resetDecoder(decoder->dec_mem);
pvmp3_InitDecoder((tPVMP3DecoderExternal *) decoder->dec_ext, decoder->dec_mem);
return AUDIO_DECODER_OK;
}
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;
}
// Initialize the Opus reader.
int opus_init(audio_decoder_p decoder, void *dec_ext)
{
decoder->dec_ext = calloc(1, sizeof(opus_dec_external_t));
RETURN_VAL_IF_FAIL((decoder->dec_ext != NULL), AUDIO_DECODER_ERROR);
decoder->dec_mem = calloc(1, opus_decoderMemRequirements());
RETURN_VAL_IF_FAIL((decoder->dec_mem != NULL), AUDIO_DECODER_ERROR);
*((opus_dec_external_t *) decoder->dec_ext) = *((opus_dec_external_t *) dec_ext);
opus_resetDecoder(decoder->dec_mem);
int err = opus_initDecoder((opus_dec_external_t *) decoder->dec_ext, decoder->dec_mem);
RETURN_VAL_IF_FAIL((err == OPUS_OK), AUDIO_DECODER_ERROR);
return AUDIO_DECODER_OK;
}
// Initialize the aac reader.
int aac_init(audio_decoder_p decoder, void *dec_ext)
{
decoder->dec_ext = calloc(1, sizeof(tPVMP4AudioDecoderExternal));
RETURN_VAL_IF_FAIL((decoder->dec_ext != NULL), AUDIO_DECODER_ERROR);
decoder->dec_mem = calloc(1, PVMP4AudioDecoderGetMemRequirements());
RETURN_VAL_IF_FAIL((decoder->dec_mem != NULL), AUDIO_DECODER_ERROR);
*((tPVMP4AudioDecoderExternal *) decoder->dec_ext) = *((tPVMP4AudioDecoderExternal *) dec_ext);
PVMP4AudioDecoderResetBuffer(decoder->dec_mem);
Int err = PVMP4AudioDecoderInitLibrary((tPVMP4AudioDecoderExternal *) decoder->dec_ext, decoder->dec_mem);
RETURN_VAL_IF_FAIL((err == MP4AUDEC_SUCCESS), AUDIO_DECODER_ERROR);
return AUDIO_DECODER_OK;
}
bool VaapiDecoderH264::storeDecodedPicture(VaapiPictureH264 * pic)
{
VaapiFrameStore *frameStore;
// Check if picture is the second field and the first field is still in DPB
if (m_prevFrame && !m_prevFrame->hasFrame()) {
RETURN_VAL_IF_FAIL(m_prevFrame->m_numBuffers == 1, false);
m_prevFrame->addPicture(m_currentPicture);
m_currentPicture = NULL;
return true;
}
// Create new frame store, and split fields if necessary
frameStore = new VaapiFrameStore(pic);
if (!frameStore)
return false;
m_prevFrame = frameStore;
if (m_prevFrame && m_prevFrame->hasFrame())
m_currentPicture = NULL;
if (!m_DPBManager->addDPB(m_prevFrame, pic))
return false;
return true;
}
TinyRet TcpServer_Construct(TcpServer *thiz)
{
TinyRet ret = TINY_RET_OK;
RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
do
{
memset(thiz, 0, sizeof(TcpServer));
thiz->running = false;
thiz->listen_port = 0;
thiz->conn_id = 0;
ret = TinyThread_Construct(&thiz->thread);
if (RET_FAILED(ret))
{
break;
}
ret = TcpConnPool_Construct(&thiz->conn_pool);
if (RET_FAILED(ret))
{
break;
}
}
while (0);
return ret;
}
bool CtCondition_NotifyAll(CtCondition *thiz)
{
bool ret = true;
RETURN_VAL_IF_FAIL(thiz, false);
#ifdef _WIN32
SetEvent(thiz->job);
#else
CtMutex_Lock(&thiz->mutex);
do
{
thiz->is_ready = true;
if (pthread_cond_broadcast(&thiz->job) != 0)
{
ret = false;
break;
}
ret = true;
}
while (0);
CtMutex_Unlock(&thiz->mutex);
#endif
return ret;
}
bool CtThread_Join(CtThread *thiz)
{
RETURN_VAL_IF_FAIL(thiz, false);
if (thiz->status == ThreadRunning)
{
LOG_D(TAG, "CtThread_Join: %s", thiz->name);
#ifdef _WIN32
if (thiz->thread_handler != INVALID_HANDLE_VALUE)
{
WaitForSingleObject(thiz->thread_handler, INFINITE);
CloseHandle(thiz->thread_handler);
thiz->thread_handler = INVALID_HANDLE_VALUE;
}
#else
void *status = NULL;
if (thiz->thread_handler != 0)
{
pthread_join(thiz->thread_id, &status);
thiz->thread_handler = 0;
}
#endif
thiz->status = ThreadStop;
}
return true;
}
CtRet CtThread_Initialize(CtThread *thiz, ThreadLoop loop, void *param, const char *name)
{
RETURN_VAL_IF_FAIL(thiz, CT_RET_E_ARG_NULL);
if (name != NULL)
{
strncpy(thiz->name, name, THREAD_NAME_LEN);
}
else
{
strncpy(thiz->name, THREAD_UNNAMED, THREAD_NAME_LEN);
}
thiz->loop = loop;
thiz->thread_param = param;
thiz->status = ThreadInit;
#ifdef _WIN32
thiz->thread_handler = NULL;
thiz->thread_id = 0;
#else /* Linux */
thiz->thread_handler = 0;
thiz->thread_id = 0;
#endif /* _WIN32 */
return CT_RET_OK;
}
guint64
utils_timestamp_file(const gchar* filename, GError** error)
{
RETURN_VAL_IF_FAIL(!utils_str_empty(filename), 0);
GError* err = NULL; /* NOTE: Doesn't need to be freed because we propagate it */
if (g_file_test(filename, G_FILE_TEST_EXISTS))
{
GTimeVal time;
g_autoptr(GFile) file = g_file_new_for_path(filename);
g_autoptr(GFileInfo) info = g_file_query_info(file,
G_FILE_ATTRIBUTE_TIME_MODIFIED, G_FILE_QUERY_INFO_NONE,
NULL, &err);
if (err)
{
WARNING("Could not timestamp file because: %s", err->message);
g_propagate_prefixed_error(error, err, "Could not timestamp file because: ");
return 0;
}
g_file_info_get_modification_time(info, &time);
return time.tv_sec;
}
RETURN_VAL_IF_REACHED(0);
}
static ssize_t _source_read_at(rbstream_p fp, ssize_t offset, void *data, size_t size)
{
int retVal = rbs_seek(fp, offset, SEEK_SET);
RETURN_VAL_IF_FAIL((retVal == OK), SIZE_ZERO);
return rbs_read(data, 1, size, fp);
}
size_t rbs_read(void *ptr, size_t size, size_t nmemb, rbstream_p rbsp)
{
medvdbg("[%s] ptr %p nmemb %lu\n", __FUNCTION__, ptr, nmemb);
RETURN_VAL_IF_FAIL(ptr != NULL, SIZE_ZERO);
RETURN_VAL_IF_FAIL(rbsp != NULL, SIZE_ZERO);
// only size:1 supported
assert(size == 1);
size_t len = size * nmemb;
size_t read = SIZE_ZERO;
while (read < len) {
void *_ptr = (void *) ((uint8_t *) ptr + read);
size_t need = len - read;
size_t offset = rbsp->cur_pos - rbsp->rd_size;
// read data desired
size_t rlen = rb_read_ext(rbsp->rbp, _ptr, need, offset);
read += rlen;
rbsp->cur_pos += rlen; // increase cur_pos
if (read < len) {
// need to read more data
size_t least = len - read;
size_t avail = rb_avail(rbsp->rbp);
if (least > avail) {
// need to dequeue data
if (RBS_OPTION_TEST(rbsp, OPTION_ALLOW_TO_DEQUEUE)) {
offset = rbsp->cur_pos - rbsp->rd_size;
size_t _len = MINIMUM(offset, (least - avail));
size_t _rlen = rb_read(rbsp->rbp, NULL, _len);
assert(_rlen == _len);
rbsp->rd_size += _rlen;
}
}
// pull stream data, then it's available to read more.
if (_pull(rb_avail(rbsp->rbp), least, rbsp) == SIZE_ZERO) {
// pull data failed
break;
}
}
}
medvdbg("[%s] done, read %lu\n", __FUNCTION__, read);
return read;
}
int rbs_seek(rbstream_p rbsp, ssize_t offset, int whence)
{
medvdbg("[%s] offset %ld, whence %d\n", __FUNCTION__, offset, whence);
RETURN_VAL_IF_FAIL(rbsp != NULL, ERROR);
switch (whence) {
case SEEK_SET:
// checking underflow
RETURN_VAL_IF_FAIL(((size_t) offset >= rbsp->rd_size), ERROR);
while ((size_t) offset > rbsp->wr_size) {
size_t least = (size_t) offset - rbsp->wr_size;
size_t wlen;
// pull stream data, then wr_size will be increased
wlen = _pull(rb_avail(rbsp->rbp), least, rbsp);
if ((size_t) offset > rbsp->wr_size) {
// not enough
if (rb_avail(rbsp->rbp) == SIZE_ZERO) {
// ring-buffer is full
RETURN_VAL_IF_FAIL((RBS_OPTION_TEST(rbsp, OPTION_ALLOW_TO_DEQUEUE)), ERROR); // overflow
// dequeue minimal data from ring-buffer
size_t len = rbsp->wr_size - rbsp->rd_size;
least = (size_t) offset - rbsp->wr_size;
len = MINIMUM(len, least);
size_t rlen = rb_read(rbsp->rbp, NULL, len);
assert(rlen == len);
rbsp->rd_size += rlen;
} else {
RETURN_VAL_IF_FAIL((wlen != SIZE_ZERO), ERROR); // EOS
}
// request more data
continue;
}
// got enough data
break;
}
rbsp->cur_pos = (size_t) offset;
break;
}
return OK;
}
CtRet CtSelector_Construct(CtSelector *thiz)
{
RETURN_VAL_IF_FAIL(thiz, CT_RET_E_ARG_NULL);
memset(thiz, 0, sizeof(CtSelector));
return CT_RET_OK;
}
CtRet CtThread_Construct(CtThread *thiz)
{
RETURN_VAL_IF_FAIL(thiz, CT_RET_E_ARG_NULL);
memset(thiz, 0, sizeof(CtThread));
return CT_RET_OK;
}
