react-native-queue-player 1.0.0

package/android/src/main/cpp/third_party/crosstools/cross_util.c

@@ -0,0 +1,753 @@
+/*
+ * Misc utilities
+ *
+ * (c) Philippe, philippe_44@outlook.com
+ * base64 (c) 1995-2001 Kungliga Tekniska H�gskolan (Royal Institute of Technology, Stockholm, Sweden)
+ *
+ * See LICENSE file
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "platform.h"
+#include "cross_util.h"
+
+#if LINUX || OSX || FREEBSD || SUNOS
+#include <ctype.h>
+#if OSX
+#include <sys/time.h>
+#endif
+#endif
+
+#ifdef HAS_PTHREAD
+#define mutex_lock(m) pthread_mutex_lock(m)
+#define mutex_unlock(m) pthread_mutex_unlock(m)
+#elif defined(_WIN32)
+#define mutex_lock(m) WaitForSingleObject(*m, INFINITE)
+#define mutex_unlock(m) ReleaseMutex(*m)
+#else
+#define mutex_lock(m) 
+#define mutex_unlock(m)
+#endif
+
+#include "platform.h"
+#include "cross_util.h"
+#include "cross_log.h"
+
+/*----------------------------------------------------------------------------*/
+/* globals */
+/*----------------------------------------------------------------------------*/
+extern log_level	util_loglevel;
+
+/*----------------------------------------------------------------------------*/
+/* locals */
+/*----------------------------------------------------------------------------*/
+static __attribute__((unused)) log_level *loglevel = &util_loglevel;
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* Queue management															  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+void queue_init(cross_queue_t *queue, bool mutex, void (*cleanup)(void*)) {
+	queue->cleanup = cleanup;
+	queue->head.item = NULL;
+	queue->mutex = NULL;
+	if (mutex) {
+#ifdef HAS_PTHREAD
+		queue->mutex = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
+		pthread_mutex_init(queue->mutex, NULL);
+#elif defined(_WIN32)
+		queue->mutex = (HANDLE*) malloc(sizeof(HANDLE));
+		*queue->mutex = CreateMutex(NULL, FALSE, NULL);
+#endif
+	}
+}
+
+/*----------------------------------------------------------------------------*/
+void queue_lock(cross_queue_t* queue) {
+	if (queue->mutex) mutex_lock(queue->mutex);
+}
+
+/*----------------------------------------------------------------------------*/
+void queue_unlock(cross_queue_t* queue) {
+	if (queue->mutex) mutex_unlock(queue->mutex);
+}
+
+/*----------------------------------------------------------------------------*/
+void queue_insert(cross_queue_t *queue, void *item) {
+	struct _cross_queue_s *list;
+
+	if (queue->mutex) mutex_lock(queue->mutex);
+	list = &queue->head;
+
+	while (list->item) list = list->next;
+	list->item = item;
+	list->next = malloc(sizeof(struct _cross_queue_s));
+	list->next->item = NULL;
+
+	if (queue->mutex) mutex_unlock(queue->mutex);
+}
+
+/*----------------------------------------------------------------------------*/
+void queue_insert_first(cross_queue_t* queue, void* item) {
+	struct _cross_queue_s* next;
+
+	if (queue->mutex) mutex_lock(queue->mutex);
+
+	next = malloc(sizeof(struct _cross_queue_s));
+	memcpy(next, &queue->head, sizeof(struct _cross_queue_s));
+	queue->head.item = item;
+	queue->head.next = next;
+
+	if (queue->mutex) mutex_unlock(queue->mutex);
+}
+
+/*----------------------------------------------------------------------------*/
+void *queue_extract(cross_queue_t *queue) {
+	if (queue->mutex) mutex_lock(queue->mutex);
+	
+	void *item = queue->head.item;
+
+	// if there an item, there is a valid next
+	if (item) {
+		struct _cross_queue_s *next = queue->head.next;
+		queue->head.item = next->item;
+		queue->head.next = next->next;
+		free(next);
+	}
+
+	if (queue->mutex) mutex_unlock(queue->mutex);
+
+	return item;
+}
+
+/*----------------------------------------------------------------------------*/
+bool queue_extract_item(cross_queue_t* queue, void* item) {
+	bool success = item == NULL;
+	if (queue->mutex) mutex_lock(queue->mutex);
+
+	for (struct _cross_queue_s* walker = &queue->head; item && walker->item; walker = walker->next) {
+		if (walker->item != item) continue;
+
+		// if there is an item, there is always a next
+		void* removed = walker->next;
+		memcpy(walker, walker->next, sizeof(struct _cross_queue_s));
+		free(removed);
+
+		success = true;
+		break;
+	}
+
+	if (queue->mutex) mutex_unlock(queue->mutex);
+	return success;
+}
+
+size_t	queue_count(cross_queue_t* queue) {
+	if (queue->mutex) mutex_lock(queue->mutex);
+
+	size_t count = 0;
+	for (struct _cross_queue_s* walker = &queue->head; walker->item; count++) {
+		walker = walker->next;
+	}
+	
+	if (queue->mutex) mutex_unlock(queue->mutex);
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+void* queue_walk_start(cross_queue_t* queue) {
+	if (queue->mutex) mutex_lock(queue->mutex);
+	queue->walker = &queue->head;
+	queue->walk = true;
+	return queue->walker->item;
+}
+
+/*----------------------------------------------------------------------------*/
+void queue_walk_end(cross_queue_t* queue) {
+	if (queue->mutex) mutex_unlock(queue->mutex);
+}
+
+/*----------------------------------------------------------------------------*/
+void* queue_walk_next(cross_queue_t* queue) {
+	if (queue->walker->item && queue->walk) queue->walker = queue->walker->next;
+	queue->walk = true;
+	return queue->walker->item;
+}
+
+/*----------------------------------------------------------------------------*/
+void* queue_walk_extract(cross_queue_t* queue) {
+	void* item = queue->walker->item;
+
+	void* removed = queue->walker->next;
+	memcpy(queue->walker, queue->walker->next, sizeof(struct _cross_queue_s));
+	free(removed);
+	
+	queue->walk = false;
+	return item;
+}
+
+/*----------------------------------------------------------------------------*/
+void queue_flush(cross_queue_t *queue) {
+	struct _cross_queue_s *walker;
+
+	if (queue->mutex) mutex_lock(queue->mutex);
+
+	walker = &queue->head;
+
+	while (walker->item) {
+		struct _cross_queue_s *next = walker->next;
+		if (queue->cleanup)	queue->cleanup(walker->item);
+		if (walker != &queue->head) { NFREE(walker); }
+		walker = next;
+	}
+
+	if (walker != &queue->head) free(walker);
+	queue->head.item = NULL;
+
+	if (queue->mutex) {
+		mutex_unlock(queue->mutex);
+#ifdef HAS_PTHREAD
+		pthread_mutex_destroy(queue->mutex);
+#else 
+		CloseHandle(*queue->mutex);
+#endif
+		free(queue->mutex);
+	}
+}
+
+/*----------------------------------------------------------------------------*/
+void queue_free_item(cross_queue_t* queue, void* item) {
+	if (queue->cleanup)	(*(queue->cleanup))(item);
+}
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* LIST management															  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+cross_list_t* list_push(cross_list_t *item, cross_list_t **list) {
+  if (*list) item->next = *list;
+  else item->next = NULL;
+
+  *list = item;
+
+  return item;
+}
+
+/*---------------------------------------------------------------------------*/
+cross_list_t* list_add_tail(cross_list_t *item, cross_list_t **list) {
+  if (*list) {
+	struct cross_list_s *p = *list;
+	while (p->next) p = p->next;
+	item->next = p->next;
+	p->next = item;
+  } else {
+	item->next = NULL;
+	*list = item;
+  }
+
+  return item;
+}
+
+/*---------------------------------------------------------------------------*/
+cross_list_t* list_add_ordered(cross_list_t *item, cross_list_t **list, int (*compare)(void *a, void *b)) {
+  if (*list) {
+	struct cross_list_s *p = *list;
+	while (p->next && compare(p->next, item) <= 0) p = p->next;
+	item->next = p->next;
+	p->next = item;
+  } else {
+	item->next = NULL;
+	*list = item;
+  }
+
+  return item;
+}
+
+/*---------------------------------------------------------------------------*/
+cross_list_t* list_pop(cross_list_t **list) {
+  if (*list) {
+	cross_list_t *item = *list;
+	*list = item->next;
+	return item;
+  } else return NULL;
+}
+
+/*---------------------------------------------------------------------------*/
+cross_list_t* list_remove(cross_list_t *item, cross_list_t **list) {
+  if (item != *list) {
+	struct cross_list_s *p = *list;
+	while (p && p->next != item) p = p->next;
+	if (p) p->next = item->next;
+	item->next = NULL;
+  } else *list = (*list)->next;
+
+  return item;
+}
+
+/*---------------------------------------------------------------------------*/
+void list_clear(cross_list_t **list, void (*free_func)(void *)) {
+  if (!*list) return;
+  while (*list) {
+	struct cross_list_s *next = (*list)->next;
+	if (free_func) (*free_func)(*list);
+	else free(*list);
+	*list = next;
+  }
+  *list = NULL;
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* Time, Clock & System													 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+uint32_t gettime_ms(void) {
+	return gettime_us() / 1000;
+}
+
+/*----------------------------------------------------------------------------*/
+uint64_t gettime_ms64(void) {
+	return gettime_us() / 1000;
+}
+
+/*----------------------------------------------------------------------------*/
+// this is EPOCH-based, so suitable for NTP
+uint64_t gettime_us(void) {
+#if WIN
+	FILETIME ft;
+	GetSystemTimeAsFileTime(&ft);
+	//@FIXME => check time and epoch vs 01/01/1601
+	return ((uint64_t) ft.dwHighDateTime << 32 | ft.dwLowDateTime) / 10 + 0x83AA7E80LL * 1000 * 1000;
+#else
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	return (uint64_t) tv.tv_sec * 1000*1000 + tv.tv_usec;
+#endif
+}
+
+/*----------------------------------------------------------------------------*/
+void touch_memory(uint8_t* buf, size_t size) {
+#if LINUX || FREEBSD || SUNOS
+	uint8_t* ptr;
+	for (ptr = buf; ptr < buf + size; ptr += sysconf(_SC_PAGESIZE)) {
+		*ptr = 0;
+	}
+#else
+#endif
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* String extensions													 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+char* strextract(char *s1, char *beg, char *end)
+{
+	char *p1, *p2, *res;
+
+	p1 = strcasestr(s1, beg);
+	if (!p1) return NULL;
+
+	p1 += strlen(beg);
+	p2 = strcasestr(p1, end);
+	if (!p2) return strdup(p1);
+
+	res = malloc(p2 - p1 + 1);
+	memcpy(res, p1, p2 - p1);
+	res[p2 - p1] = '\0';
+
+	return res;
+}
+
+/*---------------------------------------------------------------------------*/
+int strremovechar(char* str, char c)
+{
+	int i = 0, j = 0, len;
+	int num = 0;
+	len = strlen(str);
+	while (i < len) {
+		if (str[i] == c) {
+			for (j = i; j < len; j++) str[j] = str[j + 1];
+			len--;
+			num++;
+		}
+		else {
+			i++;
+		}
+	}
+	return num;
+}
+
+/*---------------------------------------------------------------------------*/
+int hex2bytes(char* hex, uint8_t** bytes) {
+	size_t len = strlen(hex) / 2;
+
+	if (!*bytes && (*bytes = malloc(len)) == NULL) return 0;
+
+	for (size_t i = 0; i < len; i++) {
+		sscanf(hex + i * 2, "%2hhx", *bytes + i);
+	}
+
+	return len;
+}
+
+/*---------------------------------------------------------------------------*/
+int bytes2hex(uint8_t* bytes, size_t len, char** hex) {
+	if (!*hex && (*hex = malloc(len*2)) == NULL) return 0;
+
+	for (size_t i = 0; i < len; i++) {
+		sprintf(*hex + i * 2, "%02hhx", bytes[i]);
+	}
+
+	return len * 2;
+}
+
+/*---------------------------------------------------------------------------*/
+uint32_t hash32(char *str)
+{
+	uint32_t hash = 5381;
+	int32_t c;
+
+	if (!str) return 0;
+
+	while ((c = *str++) != 0)
+		hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+
+	return hash;
+}
+
+/*---------------------------------------------------------------------------*/
+char* strltrim(char *s) {
+	while(isspace(*s)) s++;
+	return s;
+}
+
+/*---------------------------------------------------------------------------*/
+char* strrtrim(char *s) {
+	char* back = s + strlen(s);
+	while(isspace(*--back));
+	*(back+1) = '\0';
+	return s;
+}
+
+/*---------------------------------------------------------------------------*/
+char* strtrim(char *s) {
+	return strrtrim(strltrim(s));
+}
+
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* Key-Value															 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+char *kd_lookup(key_data_t *kd, char *key) {
+	int i = 0;
+	while (kd && kd[i].key){
+		if (!strcasecmp(kd[i].key, key)) return kd[i].data;
+		i++;
+	}
+	return NULL;
+}
+
+
+/*----------------------------------------------------------------------------*/
+bool kd_add(key_data_t *kd, const char *key, const char *data) {
+	int i = 0;
+	while (kd && kd[i].key) i++;
+
+	kd[i].key = strdup(key);
+	kd[i].data = strdup(data);
+	kd[i+1].key = NULL;
+
+	return true;
+}
+
+/*----------------------------------------------------------------------------*/
+bool kd_vadd(key_data_t *kd, const char *key, const char *fmt, ...) {
+	int i = 0;
+	va_list args;
+	while (kd && kd[i].key) i++;
+
+	va_start(args, fmt);
+
+	if (vasprintf(&kd[i].data, fmt, args)) {
+		kd[i].key = strdup(key);
+		kd[i+1].key = NULL;
+		va_end(args);
+		return true;
+	}
+
+	va_end(args);
+	return false;
+}
+
+/*----------------------------------------------------------------------------*/
+void kd_free(key_data_t *kd) {
+	int i = 0;
+	while (kd && kd[i].key){
+		free(kd[i].key);
+		if (kd[i].data) free(kd[i].data);
+		i++;
+	}
+
+	kd[0].key = NULL;
+}
+
+/*----------------------------------------------------------------------------*/
+char *kd_dump(key_data_t *kd) {
+	int i = 0;
+	int pos = 0, size = 0;
+	char *str = NULL;
+
+	if (!kd || !kd[0].key) return strdup("");
+
+	while (kd && kd[i].key) {
+		char *buf;
+		int len;
+
+		len = asprintf(&buf, "%s: %s\r\n", kd[i].key, kd[i].data);
+
+		while (pos + len >= size) {
+			void *p = realloc(str, size + 1024);
+			size += 1024;
+			if (!p) {
+				free(str);
+				return NULL;
+			}
+			str = p;
+		}
+
+		memcpy(str + pos, buf, len);
+
+		pos += len;
+		free(buf);
+		i++;
+	}
+
+	str[pos] = '\0';
+
+	return str;
+}
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* URL handling															 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* Converts a hex character to its integer value */
+static char from_hex(char ch) {
+	return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10;
+}
+
+/*---------------------------------------------------------------------------*/
+/* Converts an integer value to its hex character*/
+static char to_hex(char code) {
+	static char hex[] = "0123456789abcdef";
+	return hex[code & 15];
+}
+
+/*---------------------------------------------------------------------------*/
+/* Returns a url-encoded version of str */
+/* IMPORTANT: be sure to free() the returned string after use */
+char* url_encode(char* str) {
+	char* pstr = str, * buf = malloc(strlen(str) * 3 + 1), * pbuf = buf;
+	while (*pstr) {
+		if (isalnum(*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' || *pstr == '~')
+			*pbuf++ = *pstr;
+		else if (*pstr == ' ') {
+			*pbuf++ = '+';
+		}
+		else
+			*pbuf++ = '%', * pbuf++ = to_hex(*pstr >> 4), * pbuf++ = to_hex(*pstr & 15);
+		pstr++;
+	}
+	*pbuf = '\0';
+	return buf;
+}
+
+/*---------------------------------------------------------------------------*/
+/* Returns a url-decoded version of str */
+/* IMPORTANT: be sure to free() the returned string after use */
+char* url_decode(char* str) {
+	char* pstr = str, * buf = malloc(strlen(str) + 1), * pbuf = buf;
+	while (*pstr) {
+		if (*pstr == '%') {
+			if (pstr[1] && pstr[2]) {
+				*pbuf++ = from_hex(pstr[1]) << 4 | from_hex(pstr[2]);
+				pstr += 2;
+			}
+		}
+		else if (*pstr == '+') {
+			*pbuf++ = ' ';
+		}
+		else {
+			*pbuf++ = *pstr;
+		}
+		pstr++;
+	}
+	*pbuf = '\0';
+	return buf;
+}
+
+/*---------------------------------------------------------------------------*/
+/* IMPORTANT: be sure to free() the returned string after use */
+#define QUOT 	"&quot;"
+#define AMP	 	"&amp;"
+#define LT		"&lt;"
+#define GT		"&gt;"
+char* xml_encode(char* src)
+{
+	char* p, * q, * res;
+	int i;
+
+	for (i = 0, p = src; *p; p++) {
+		switch (*p) {
+		case '\"': i += strlen(QUOT); break;
+		case '&':  i += strlen(AMP); break;
+		case '<':  i += strlen(LT); break;
+		case '>':  i += strlen(GT); break;
+		}
+	}
+
+	res = malloc(strlen(src) + i + 1);
+	if (!res) return NULL;
+
+	for (q = res, p = src; *p; p++) {
+		char* rep = NULL;
+		switch (*p) {
+		case '\"': rep = QUOT; break;
+		case '&':  rep = AMP; break;
+		case '<':  rep = LT; break;
+		case '>':  rep = GT; break;
+		}
+		if (rep) {
+			memcpy(q, rep, strlen(rep));
+			q += strlen(rep);
+		}
+		else {
+			*q = *p;
+			q++;
+		}
+	}
+
+	return res;
+}
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* Base64 handling														 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+static char base64_chars[] =
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static int
+pos(char c)
+{
+	char* p;
+	for (p = base64_chars; *p; p++)
+		if (*p == c)
+			return p - base64_chars;
+	return -1;
+}
+
+int
+base64_encode(const void* data, int size, char** str)
+{
+	char* s, * p;
+	int i;
+	int c;
+	const unsigned char* q;
+
+	p = s = (char*)malloc(size * 4 / 3 + 4);
+	if (p == NULL) return -1;
+	q = (const unsigned char*)data;
+	i = 0;
+	for (i = 0; i < size;) {
+		c = q[i++];
+		c *= 256;
+		if (i < size) c += q[i];
+		i++;
+		c *= 256;
+		if (i < size) c += q[i];
+		i++;
+		p[0] = base64_chars[(c & 0x00fc0000) >> 18];
+		p[1] = base64_chars[(c & 0x0003f000) >> 12];
+		p[2] = base64_chars[(c & 0x00000fc0) >> 6];
+		p[3] = base64_chars[(c & 0x0000003f) >> 0];
+		if (i > size) p[3] = '=';
+		if (i > size + 1) p[2] = '=';
+		p += 4;
+	}
+	*p = 0;
+	*str = s;
+	return strlen(s);
+}
+
+#define DECODE_ERROR 0xffffffff
+
+static unsigned int
+token_decode(const char* token)
+{
+	int i;
+	unsigned int val = 0;
+	int marker = 0;
+	if (strlen(token) < 4)
+		return DECODE_ERROR;
+	for (i = 0; i < 4; i++) {
+		val *= 64;
+		if (token[i] == '=')
+			marker++;
+		else if (marker > 0)
+			return DECODE_ERROR;
+		else
+			val += pos(token[i]);
+	}
+	if (marker > 2)
+		return DECODE_ERROR;
+	return (marker << 24) | val;
+}
+
+int
+base64_decode(const char* str, void* data)
+{
+	const char* p;
+	unsigned char* q;
+
+	q = data;
+	for (p = str; *p && (*p == '=' || strchr(base64_chars, *p)); p += 4) {
+		unsigned int val = token_decode(p);
+		unsigned int marker = (val >> 24) & 0xff;
+		if (val == DECODE_ERROR)
+			return -1;
+		*q++ = (val >> 16) & 0xff;
+		if (marker < 2)
+			*q++ = (val >> 8) & 0xff;
+		if (marker < 1)
+			*q++ = val & 0xff;
+	}
+	return q - (unsigned char*)data;
+}
+