camera_cnn

util.c (9814B)

---

 /* See LICENSE for license details. */
 #define zero_struct(s) mem_clear(s, 0, sizeof(*s))
 function void *
 mem_clear(void *restrict p_, u8 c, uz size)
 {
 	u8 *p = p_;
 	while (size) p[--size] = c;
 	return p;
 }
 
 function void
 mem_copy(void *restrict dest, void *restrict src, uz n)
 {
 	u8 *s = src, *d = dest;
 	for (; n; n--) *d++ = *s++;
 }
 
 function u8 *
 arena_aligned_start(Arena a, uz alignment)
 {
 	uz padding = -(uintptr_t)a.beg & (alignment - 1);
 	u8 *result = a.beg + padding;
 	return result;
 }
 
 function u8 *
 arena_commit(Arena *a, sz size)
 {
 	assert(a->end - a->beg >= size);
 	u8 *result = a->beg;
 	a->beg += size;
 	return result;
 }
 
 function void
 arena_pop(Arena *a, sz length)
 {
 	a->beg -= length;
 }
 
 #define push_array(a, t, n) (t *)arena_alloc(a, sizeof(t), _Alignof(t), n)
 #define push_struct(a, t)   (t *)arena_alloc(a, sizeof(t), _Alignof(t), 1)
 function void *
 arena_alloc(Arena *a, uz len, uz align, uz count)
 {
 	void *result = 0;
 	if (a->beg) {
 		u8 *start = arena_aligned_start(*a, align);
 		sz available = a->end - start;
 		assert((available >= 0 && count <= (uz)available / len));
 		a->beg = start + count * len;
 		/* TODO: Performance? */
 		result = mem_clear(start, 0, count * len);
 	}
 	return result;
 }
 
 enum { DA_INITIAL_CAP = 4 };
 #define da_reserve(a, s, n) \
   (s)->data = da_reserve_((a), (s)->data, &(s)->capacity, (s)->count + n, \
                           _Alignof(typeof(*(s)->data)), sizeof(*(s)->data))
 
 #define da_push(a, s) \
   ((s)->count == (s)->capacity  \
     ? da_reserve(a, s, 1u),     \
       (s)->data + (s)->count++  \
     : (s)->data + (s)->count++)
 
 function void *
 da_reserve_(Arena *a, void *data, sz *capacity, sz needed, uz align, uz size)
 {
 	uz cap = (uz)*capacity;
 
 	/* NOTE(rnp): handle both 0 initialized DAs and DAs that need to be moved (they started
 	 * on the stack or someone allocated something in the middle of the arena during usage) */
 	if (!data || a->beg != (u8 *)data + cap * size) {
 		void *copy = arena_alloc(a, size, align, cap);
 		if (data) mem_copy(copy, data, cap * size);
 		data = copy;
 	}
 
 	if (!cap) cap = DA_INITIAL_CAP;
 	while (cap < needed) cap *= 2;
 	arena_alloc(a, size, align, cap - (uz)*capacity);
 	*capacity = (sz)cap;
 	return data;
 }
 
 function u32
 utf8_encode(u8 *out, u32 cp)
 {
 	u32 result = 1;
 	if (cp <= 0x7F) {
 		out[0] = cp & 0x7F;
 	} else if (cp <= 0x7FF) {
 		result = 2;
 		out[0] = ((cp >>  6) & 0x1F) | 0xC0;
 		out[1] = ((cp >>  0) & 0x3F) | 0x80;
 	} else if (cp <= 0xFFFF) {
 		result = 3;
 		out[0] = ((cp >> 12) & 0x0F) | 0xE0;
 		out[1] = ((cp >>  6) & 0x3F) | 0x80;
 		out[2] = ((cp >>  0) & 0x3F) | 0x80;
 	} else if (cp <= 0x10FFFF) {
 		result = 4;
 		out[0] = ((cp >> 18) & 0x07) | 0xF0;
 		out[1] = ((cp >> 12) & 0x3F) | 0x80;
 		out[2] = ((cp >>  6) & 0x3F) | 0x80;
 		out[3] = ((cp >>  0) & 0x3F) | 0x80;
 	} else {
 		out[0] = '?';
 	}
 	return result;
 }
 
 function UnicodeDecode
 utf16_decode(u16 *data, sz length)
 {
 	UnicodeDecode result = {.cp = U32_MAX};
 	if (length) {
 		result.consumed = 1;
 		result.cp = data[0];
 		if (length > 1 && BETWEEN(data[0], 0xD800, 0xDBFF)
 		               && BETWEEN(data[1], 0xDC00, 0xDFFF))
 		{
 			result.consumed = 2;
 			result.cp = ((data[0] - 0xD800u) << 10) | ((data[1] - 0xDC00u) + 0x10000u);
 		}
 	}
 	return result;
 }
 
 function u32
 utf16_encode(u16 *out, u32 cp)
 {
 	u32 result = 1;
 	if (cp == U32_MAX) {
 		out[0] = '?';
 	} else if (cp < 0x10000) {
 		out[0] = (u16)cp;
 	} else {
 		u32 value = cp - 0x10000;
 		out[0] = (u16)(0xD800u + (value >> 10u));
 		out[1] = (u16)(0xDC00u + (value & 0x3FFu));
 		result = 2;
 	}
 	return result;
 }
 
 function Stream
 stream_alloc(Arena *a, u32 cap)
 {
 	Stream result = {.cap = cap};
 	result.data = push_array(a, u8, cap);
 	return result;
 }
 
 function str8
 stream_to_str8(Stream *s)
 {
 	str8 result = str8("");
 	if (!s->errors) result = (str8){.len = s->widx, .data = s->data};
 	return result;
 }
 
 function void
 stream_reset(Stream *s, u32 index)
 {
 	s->errors = s->cap <= index;
 	if (!s->errors)
 		s->widx = index;
 }
 
 function void
 stream_commit(Stream *s, sz count)
 {
 	s->errors |= !BETWEEN(s->widx + count, 0, s->cap);
 	if (!s->errors)
 		s->widx += count;
 }
 
 function void
 stream_append(Stream *s, void *data, sz count)
 {
 	s->errors |= (s->cap - s->widx) < count;
 	if (!s->errors) {
 		mem_copy(s->data + s->widx, data, (u32)count);
 		s->widx += count;
 	}
 }
 
 function void
 stream_append_byte(Stream *s, u8 b)
 {
 	stream_append(s, &b, 1);
 }
 
 function void
 stream_append_str8(Stream *s, str8 str)
 {
 	stream_append(s, str.data, (u32)str.len);
 }
 
 #define stream_append_str8s(s, ...) stream_append_str8s_(s, (str8 []){__VA_ARGS__}, \
                                                          sizeof((str8 []){__VA_ARGS__}) / sizeof(str8))
 function void
 stream_append_str8s_(Stream *s, str8 *strs, sz count)
 {
 	for (sz i = 0; i < count; i++)
 		stream_append(s, strs[i].data, (u32)strs[i].len);
 }
 
 function void
 stream_append_u64_width(Stream *s, u64 n, u64 min_width)
 {
 	u8 tmp[64];
 	u8 *end = tmp + sizeof(tmp);
 	u8 *beg = end;
 	min_width = MIN(sizeof(tmp), min_width);
 
 	do { *--beg = '0' + (n % 10); } while (n /= 10);
 	while (end - beg > 0 && end - beg < min_width)
 		*--beg = '0';
 
 	stream_append(s, beg, end - beg);
 }
 
 function void
 stream_append_u64(Stream *s, u64 n)
 {
 	stream_append_u64_width(s, n, 0);
 }
 
 function void
 stream_append_s64(Stream *s, s64 n)
 {
 	if (n < 0) {
 		stream_append_byte(s, '-');
 		n *= -1;
 	}
 	stream_append_u64(s, (u64)n);
 }
 
 function void
 stream_append_f64(Stream *s, f64 f, s64 prec)
 {
 	if (f < 0) {
 		stream_append_byte(s, '-');
 		f *= -1;
 	}
 
 	/* NOTE: round last digit */
 	f += 0.5f / (float)prec;
 
 	if (f >= (f64)(-1UL >> 1)) {
 		stream_append_str8(s, str8("inf"));
 	} else {
 		u64 integral = (u64)f;
 		u64 fraction = (u64)((f - (f64)integral) * (f64)prec);
 		stream_append_u64(s, integral);
 		stream_append_byte(s, '.');
 		for (s64 i = prec / 10; i > 1; i /= 10) {
 			if (i > fraction)
 				stream_append_byte(s, '0');
 		}
 		stream_append_u64(s, fraction);
 	}
 }
 
 function Stream
 arena_stream(Arena a)
 {
 	Stream result = {0};
 	result.data   = a.beg;
 	result.cap    = (u32)(a.end - a.beg);
 	return result;
 }
 
 function str8
 arena_stream_commit_zero(Arena *a, Stream *s)
 {
 	b32 error = s->errors || s->widx == s->cap;
 	if (!error)
 		s->data[s->widx] = 0;
 	str8 result = stream_to_str8(s);
 	arena_commit(a, result.len + 1);
 	return result;
 }
 
 function str8
 arena_stream_commit(Arena *a, Stream *s)
 {
 	assert(s->data == a->beg);
 	str8 result = stream_to_str8(s);
 	arena_commit(a, result.len);
 	return result;
 }
 
 /* NOTE(rnp): FNV-1a hash */
 function u64
 str8_hash(str8 v)
 {
 	u64 h = 0x3243f6a8885a308d; /* digits of pi */
 	for (; v.len; v.len--) {
 		h ^= v.data[v.len - 1] & 0xFF;
 		h *= 1111111111111111111; /* random prime */
 	}
 	return h;
 }
 
 function b32
 c_str_equal(const char *a, const char *b)
 {
 	b32 result = 0;
 	if (a && b) {
 		while (*a && *b && *a == *b) { a++, b++; }
 		result = *a == 0 && *b == 0;
 	}
 	return result;
 }
 
 
 function str8
 c_str_to_str8(char *cstr)
 {
 	str8 result = {.data = (u8 *)cstr};
 	if (cstr) while (*cstr) { cstr++; }
 	result.len = (u8 *)cstr - result.data;
 	return result;
 }
 
 /* NOTE(rnp): returns < 0 if byte is not found */
 function sz
 str8_scan_backwards(str8 s, u8 byte)
 {
 	sz result = s.len;
 	while (result && s.data[result - 1] != byte) result--;
 	result--;
 	return result;
 }
 
 function str8
 str8_trim_trailing(str8 s, u8 byte)
 {
 	str8 result = s;
 	while (result.len >= 1 && result.data[result.len - 1] == byte) result.len--;
 	return result;
 }
 
 function str8
 str8_cut_head(str8 s, sz cut)
 {
 	str8 result = s;
 	if (cut > 0) {
 		result.data += cut;
 		result.len  -= cut;
 	}
 	return result;
 }
 
 function str8
 str8_alloc(Arena *a, sz len)
 {
 	str8 result = {.data = push_array(a, u8, (uz)len), .len = len};
 	return result;
 }
 
 function str8
 str16_to_str8(Arena *a, str16 in)
 {
 	str8 result = str8("");
 	if (in.len) {
 		sz commit = in.len * 4;
 		sz length = 0;
 		u8 *data = arena_commit(a, commit + 1);
 		u16 *beg = in.data;
 		u16 *end = in.data + in.len;
 		while (beg < end) {
 			UnicodeDecode decode = utf16_decode(beg, end - beg);
 			length += utf8_encode(data + length, decode.cp);
 			beg    += decode.consumed;
 		}
 		data[length] = 0;
 		result = (str8){.len = length, .data = data};
 		arena_pop(a, commit - length);
 	}
 	return result;
 }
 
 function str16
 str8_to_str16(Arena *a, str8 in)
 {
 	str16 result = {0};
 	if (in.len) {
 		sz required = 2 * in.len + 1;
 		u16 *data   = push_array(a, u16, (uz)required);
 		sz length   = 0;
 		/* TODO(rnp): utf8_decode */
 		for (sz i = 0; i < in.len; i++) {
 			u32 cp  = in.data[i];
 			length += utf16_encode(data + length, cp);
 		}
 		result = (str16){.len = length, .data = data};
 		arena_pop(a, required - length);
 	}
 	return result;
 }
 
 function str8
 push_str8(Arena *a, str8 str)
 {
 	str8 result = str8_alloc(a, str.len);
 	mem_copy(result.data, str.data, (uz)result.len);
 	return result;
 }
 
 function str8
 push_str8_zero(Arena *a, str8 str)
 {
 	str8 result  = str8_alloc(a, str.len + 1);
 	result.len  -= 1;
 	mem_copy(result.data, str.data, (uz)result.len);
 	return result;
 }
 
 function f64
 parse_f64(str8 s)
 {
 	f64 integral = 0, fractional = 0, sign = 1;
 
 	if (s.len && *s.data == '-') {
 		sign = -1;
 		s.data++;
 		s.len--;
 	}
 
 	while (s.len && *s.data != '.') {
 		integral *= 10;
 		integral += *s.data - '0';
 		s.data++;
 		s.len--;
 	}
 
 	if (*s.data == '.') { s.data++; s.len--; }
 
 	while (s.len) {
 		assert(s.data[s.len - 1] != '.');
 		fractional /= 10;
 		fractional += (f64)(s.data[--s.len] - '0') / 10.0;
 	}
 	f64 result = sign * (integral + fractional);
 	return result;
 }
 
 function FileWatchDirectory *
 lookup_file_watch_directory(FileWatchContext *ctx, u64 hash)
 {
 	FileWatchDirectory *result = 0;
 	for (u32 i = 0; i < ctx->count; i++) {
 		FileWatchDirectory *test = ctx->data + i;
 		if (test->hash == hash) {
 			result = test;
 			break;
 		}
 	}
 	return result;
 }