mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-16 07:00:00 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

implement set_format

Browse source 
Serialize the formats
Use SpaMemoryRef where we can
Add more debug
This commit is contained in:
Wim Taymans 2016-08-04 17:33:49 +02:00
parent 98679cbd53
commit 8f9222bf9e
19 changed files with 611 additions and 399 deletions
Download patch file Download diff file Expand all files Collapse all files

227
spa/lib/control.c
View file

@ -26,6 +26,7 @@
#include <sys/socket.h>
#include <spa/control.h>
#include <spa/debug.h>
#if 0
#define SPA_DEBUG_CONTROL(format,args...) fprintf(stderr,format,##args)
@ -339,6 +340,50 @@ spa_control_iter_get_data (SpaControlIter *iter, size_t *size)
return si->data;
}
static void
iter_parse_set_format (struct stack_iter *si, SpaControlCmdSetFormat *cmd)
{
uint32_t *p = si->data;
SpaProps *tp;
unsigned int i, j;
SpaPropInfo *pi;
SpaPropRangeInfo *ri;
cmd->port_id = *p++;
cmd->format = malloc (si->size - 4);
memcpy (cmd->format, p, si->size - 4);
tp = (SpaProps *) &cmd->format->props;
tp->prop_info = SPA_MEMBER (tp, SPA_PTR_TO_INT (tp->prop_info), SpaPropInfo);
tp->set_prop = spa_props_generic_set_prop;
tp->get_prop = spa_props_generic_get_prop;
tp->priv = NULL;
/* now fix all the pointers */
for (i = 0; i < tp->n_prop_info; i++) {
pi = (SpaPropInfo *) &tp->prop_info[i];
if (pi->name)
pi->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->name), char);
if (pi->description)
pi->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->description), char);
if (pi->default_value)
pi->default_value = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->default_value), void);
if (pi->range_values)
pi->range_values = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->range_values), SpaPropRangeInfo);
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *) &pi->range_values[j];
if (ri->name)
ri->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->name), char);
if (ri->description)
ri->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->description), char);
if (ri->value)
ri->value = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->value), void);
}
}
}
SpaResult
spa_control_iter_parse_cmd (SpaControlIter *iter,
void *command)
@ -399,12 +444,7 @@ spa_control_iter_parse_cmd (SpaControlIter *iter,
case SPA_CONTROL_CMD_SET_FORMAT:
{
SpaControlCmdSetFormat *cmd;
uint32_t *p = si->data;
cmd = command;
cmd->port_id = *p++;
cmd->format = (const SpaFormat *)p;
iter_parse_set_format (si, command);
break;
}
@ -507,7 +547,7 @@ spa_control_builder_init_full (SpaControlBuilder *builder,
sb->control.max_size = sizeof (SpaStackHeader) + 128;
sb->control.data = malloc (sb->control.max_size);
sb->control.free_data = sb->control.data;
fprintf (stderr, "builder %p: realloc control memory %zd -> %zd\n",
fprintf (stderr, "builder %p: alloc control memory %zd -> %zd\n",
builder, max_data, sb->control.max_size);
} else {
sb->control.max_size = max_data;
@ -620,7 +660,12 @@ spa_control_builder_add_fd (SpaControlBuilder *builder,
fprintf (stderr, "builder %p: realloc control fds %d -> %d\n",
builder, sb->control.max_fds, new_size);
sb->control.max_fds = new_size;
sb->control.free_fds = realloc (sb->control.free_fds, new_size * sizeof (int));
if (sb->control.free_fds == NULL) {
sb->control.free_fds = malloc (new_size * sizeof (int));
memcpy (sb->control.free_fds, sb->control.fds, sb->control.n_fds * sizeof (int));
} else {
sb->control.free_fds = realloc (sb->control.free_fds, new_size * sizeof (int));
}
sb->control.fds = sb->control.free_fds;
}
index = sb->control.n_fds;
@ -639,7 +684,12 @@ builder_ensure_size (struct stack_builder *sb, size_t size)
fprintf (stderr, "builder %p: realloc control memory %zd -> %zd\n",
sb, sb->control.max_size, new_size);
sb->control.max_size = new_size;
sb->control.free_data = realloc (sb->control.free_data, new_size);
if (sb->control.free_data == NULL) {
sb->control.free_data = malloc (new_size);
memcpy (sb->control.free_data, sb->control.data, sb->control.size);
} else {
sb->control.free_data = realloc (sb->control.free_data, new_size);
}
sb->sh = sb->control.data = sb->control.free_data;
}
return (uint8_t *) sb->control.data + sb->control.size;
@ -671,6 +721,143 @@ builder_add_cmd (struct stack_builder *sb, SpaControlCmd cmd, size_t size)
return p;
}
static void
builder_add_set_format (struct stack_builder *sb, SpaControlCmdSetFormat *sf)
{
size_t len, slen;
unsigned int i, j;
void *p, *base;
SpaFormat *tf;
SpaProps *tp;
const SpaProps *sp;
SpaPropInfo *pi, *bpi;
SpaPropRangeInfo *ri, *bri;
sp = &sf->format->props;
/* calculate length */
/* port_id + format + mask */
len = sizeof (uint32_t) + sizeof (SpaFormat) + sizeof (uint32_t);
for (i = 0; i < sp->n_prop_info; i++) {
pi = (SpaPropInfo *) &sp->prop_info[i];
len += sizeof (SpaPropInfo);
len += pi->name ? strlen (pi->name) + 1 : 0;
len += pi->description ? strlen (pi->description) + 1 : 0;
/* for the value and the default value */
len += pi->maxsize + pi->default_size;
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *)&pi->range_values[j];
len += sizeof (SpaPropRangeInfo);
len += ri->name ? strlen (ri->name) + 1 : 0;
len += ri->description ? strlen (ri->description) + 1 : 0;
/* the size of the range value */
len += ri->size;
}
}
base = builder_add_cmd (sb, SPA_CONTROL_CMD_SET_FORMAT, len);
memcpy (base, &sf->port_id, sizeof (uint32_t));
tf = SPA_MEMBER (base, sizeof (uint32_t), SpaFormat);
tf->media_type = sf->format->media_type;
tf->media_subtype = sf->format->media_subtype;
tp = SPA_MEMBER (tf, offsetof (SpaFormat, props), SpaProps);
tp->n_prop_info = sp->n_prop_info;
tp->prop_info = SPA_INT_TO_PTR (sizeof (SpaFormat) + sizeof (uint32_t));
tp->set_prop = NULL;
tp->get_prop = NULL;
tp->priv = NULL;
/* write propinfo array, adjust offset of mask */
bpi = pi = (SpaPropInfo *) ((uint8_t *)tp + sizeof (SpaFormat) + sizeof (uint32_t));
for (i = 0; i < tp->n_prop_info; i++) {
memcpy (pi, &sp->prop_info[i], sizeof (SpaPropInfo));
pi->mask_offset = sizeof (SpaFormat);
pi->priv = NULL;
pi++;
}
bri = ri = (SpaPropRangeInfo *) pi;
pi = bpi;
/* write range info arrays, adjust offset to it */
for (i = 0; i < tp->n_prop_info; i++) {
pi->range_values = SPA_INT_TO_PTR (SPA_PTRDIFF (ri, tf));
for (j = 0; j < pi->n_range_values; j++) {
memcpy (ri, &sp->prop_info[i].range_values[j], sizeof (SpaPropRangeInfo));
ri++;
}
pi++;
}
p = ri;
pi = bpi;
ri = bri;
/* strings and default values from props and ranges */
for (i = 0; i < tp->n_prop_info; i++) {
if (pi->name) {
slen = strlen (pi->name) + 1;
memcpy (p, pi->name, slen);
pi->name = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += slen;
} else {
pi->name = 0;
}
if (pi->description) {
slen = strlen (pi->description) + 1;
memcpy (p, pi->description, slen);
pi->description = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += slen;
} else {
pi->description = 0;
}
if (pi->default_value) {
memcpy (p, pi->default_value, pi->default_size);
pi->default_value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += pi->default_size;
} else {
pi->default_value = 0;
}
for (j = 0; j < pi->n_range_values; j++) {
if (ri->name) {
slen = strlen (ri->name) + 1;
memcpy (p, ri->name, slen);
ri->name = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += slen;
} else {
ri->name = 0;
}
if (ri->description) {
slen = strlen (ri->description) + 1;
memcpy (p, ri->description, slen);
ri->description = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += slen;
} else {
ri->description = 0;
}
if (ri->size) {
memcpy (p, ri->value, ri->size);
ri->value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += ri->size;
} else {
ri->value = 0;
}
ri++;
}
pi++;
}
/* and the actual values */
pi = bpi;
for (i = 0; i < tp->n_prop_info; i++) {
if (pi->offset) {
memcpy (p, SPA_MEMBER (sp, pi->offset, void), pi->maxsize);
pi->offset = SPA_PTRDIFF (p, tf);
p += pi->maxsize;
} else {
pi->offset = 0;
}
pi++;
}
}
/**
* spa_control_builder_add_cmd:
* @builder: a #SpaControlBuilder
@ -736,20 +923,8 @@ spa_control_builder_add_cmd (SpaControlBuilder *builder,
break;
case SPA_CONTROL_CMD_SET_FORMAT:
{
size_t len, slen;
SpaControlCmdSetFormat *sf = command;
uint32_t *p;
slen = strlen ("")+1;
/* port + string */
len = 4 + slen;
p = builder_add_cmd (sb, cmd, len);
*p++ = sf->port_id;
memcpy ((char*)p, sf->format, slen);
builder_add_set_format (sb, command);
break;
}
case SPA_CONTROL_CMD_SET_PROPERTY:
fprintf (stderr, "implement builder of %d\n", cmd);
@ -854,7 +1029,13 @@ spa_control_read (SpaControl *control,
if (sc->max_size < need) {
fprintf (stderr, "control: realloc receive memory %zd -> %zd\n", sc->max_size, need);
sc->max_size = need;
hdr = sc->data = sc->free_data = realloc (sc->free_data, need);
if (sc->free_data == NULL) {
sc->free_data = malloc (need);
memcpy (sc->free_data, sc->data, len);
} else {
sc->free_data = realloc (sc->free_data, need);
}
hdr = sc->data = sc->free_data;
}
sc->size = need;

299
spa/lib/debug.c
View file

@ -21,6 +21,8 @@
#include "spa/debug.h"
#include "spa/memory.h"
#include "spa/props.h"
#include "spa/format.h"
SpaResult
spa_debug_port_info (const SpaPortInfo *info)
@ -90,7 +92,8 @@ spa_debug_buffer (const SpaBuffer *buffer)
fprintf (stderr, "SpaBuffer %p:\n", buffer);
fprintf (stderr, " id: %08X\n", buffer->id);
fprintf (stderr, " mem_id: %08X\n", buffer->mem_id);
fprintf (stderr, " pool_id: %08X\n", buffer->mem.pool_id);
fprintf (stderr, " mem_id: %08X\n", buffer->mem.id);
fprintf (stderr, " offset: %zd\n", buffer->offset);
fprintf (stderr, " size: %zd\n", buffer->size);
fprintf (stderr, " n_metas: %u (offset %zd)\n", buffer->n_metas, buffer->metas);
@ -126,11 +129,11 @@ spa_debug_buffer (const SpaBuffer *buffer)
SpaData *d = &SPA_BUFFER_DATAS (buffer)[i];
SpaMemory *mem;
mem = spa_memory_find (0, d->mem_id);
mem = spa_memory_find (&d->mem);
fprintf (stderr, " data %d: (memory %p)\n", i, mem);
if (mem) {
fprintf (stderr, " pool_id: %u\n", mem->pool_id);
fprintf (stderr, " id: %u\n", mem->id);
fprintf (stderr, " pool_id: %u\n", mem->mem.pool_id);
fprintf (stderr, " id: %u\n", mem->mem.id);
fprintf (stderr, " flags: %08x\n", mem->flags);
fprintf (stderr, " type: %s\n", mem->type ? mem->type : "*unknown*");
fprintf (stderr, " fd: %d\n", mem->fd);
@ -147,9 +150,9 @@ spa_debug_buffer (const SpaBuffer *buffer)
}
SpaResult
spa_debug_dump_mem (void *mem, size_t size)
spa_debug_dump_mem (const void *mem, size_t size)
{
uint8_t *t = mem;
const uint8_t *t = mem;
int i;
if (mem == NULL)
@ -162,3 +165,287 @@ spa_debug_dump_mem (void *mem, size_t size)
}
return SPA_RESULT_OK;
}
struct media_type_name {
const char *name;
} media_type_names[] = {
{ "unknown" },
{ "audio" },
{ "video" },
};
struct media_subtype_name {
const char *name;
} media_subtype_names[] = {
{ "unknown" },
{ "raw" },
{ "h264" },
{ "mjpg" },
};
struct prop_type_name {
const char *name;
const char *CCName;
} prop_type_names[] = {
{ "invalid", "*Invalid*" },
{ "bool", "Boolean" },
{ "int8", "Int8" },
{ "uint8", "UInt8" },
{ "int16", "Int16" },
{ "uint16", "UInt16" },
{ "int32", "Int32" },
{ "uint32", "UInt32" },
{ "int64", "Int64" },
{ "uint64", "UInt64" },
{ "int", "Int" },
{ "uint", "UInt" },
{ "float", "Float" },
{ "double", "Double" },
{ "string", "String" },
{ "rectangle", "Rectangle" },
{ "fraction", "Fraction" },
{ "bitmask", "Bitmask" },
{ "pointer", "Pointer" },
};
static void
print_value (const SpaPropInfo *info, int size, const void *value)
{
SpaPropType type = info->type;
bool enum_string = false;
if (info->range_type == SPA_PROP_RANGE_TYPE_ENUM) {
int i;
for (i = 0; i < info->n_range_values; i++) {
if (memcmp (info->range_values[i].value, value, size) == 0) {
if (info->range_values[i].name) {
type = SPA_PROP_TYPE_STRING;
value = info->range_values[i].name;
enum_string = true;
}
}
}
}
switch (type) {
case SPA_PROP_TYPE_INVALID:
fprintf (stderr, "invalid");
break;
case SPA_PROP_TYPE_BOOL:
fprintf (stderr, "%s", *(bool *)value ? "true" : "false");
break;
case SPA_PROP_TYPE_INT8:
fprintf (stderr, "%" PRIi8, *(int8_t *)value);
break;
case SPA_PROP_TYPE_UINT8:
fprintf (stderr, "%" PRIu8, *(uint8_t *)value);
break;
case SPA_PROP_TYPE_INT16:
fprintf (stderr, "%" PRIi16, *(int16_t *)value);
break;
case SPA_PROP_TYPE_UINT16:
fprintf (stderr, "%" PRIu16, *(uint16_t *)value);
break;
case SPA_PROP_TYPE_INT32:
fprintf (stderr, stderr, "%" PRIi32, *(int32_t *)value);
break;
case SPA_PROP_TYPE_UINT32:
fprintf (stderr, "%" PRIu32, *(uint32_t *)value);
break;
case SPA_PROP_TYPE_INT64:
fprintf (stderr, "%" PRIi64 "\n", *(int64_t *)value);
break;
case SPA_PROP_TYPE_UINT64:
fprintf (stderr, "%" PRIu64 "\n", *(uint64_t *)value);
break;
case SPA_PROP_TYPE_INT:
fprintf (stderr, "%d", *(int *)value);
break;
case SPA_PROP_TYPE_UINT:
fprintf (stderr, "%u", *(unsigned int *)value);
break;
case SPA_PROP_TYPE_FLOAT:
fprintf (stderr, "%f", *(float *)value);
break;
case SPA_PROP_TYPE_DOUBLE:
fprintf (stderr, "%g", *(double *)value);
break;
case SPA_PROP_TYPE_STRING:
if (enum_string)
fprintf (stderr, "%s", (char *)value);
else
fprintf (stderr, "\"%s\"", (char *)value);
break;
case SPA_PROP_TYPE_RECTANGLE:
{
const SpaRectangle *r = value;
fprintf (stderr, "%"PRIu32"x%"PRIu32, r->width, r->height);
break;
}
case SPA_PROP_TYPE_FRACTION:
{
const SpaFraction *f = value;
fprintf (stderr, "%"PRIu32"/%"PRIu32, f->num, f->denom);
break;
}
case SPA_PROP_TYPE_BITMASK:
break;
case SPA_PROP_TYPE_POINTER:
fprintf (stderr, "%p", value);
break;
default:
break;
}
}
SpaResult
spa_debug_props (const SpaProps *props, bool print_ranges)
{
SpaResult res;
const SpaPropInfo *info;
int i, j;
if (props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
fprintf (stderr, "Properties (%d items):\n", props->n_prop_info);
for (i = 0; i < props->n_prop_info; i++) {
SpaPropValue value;
info = &props->prop_info[i];
fprintf (stderr, " %-20s: %s\n", info->name, info->description);
fprintf (stderr, "%-23.23s flags: ", "");
if (info->flags & SPA_PROP_FLAG_READABLE)
fprintf (stderr, "readable ");
if (info->flags & SPA_PROP_FLAG_WRITABLE)
fprintf (stderr, "writable ");
if (info->flags & SPA_PROP_FLAG_OPTIONAL)
fprintf (stderr, "optional ");
if (info->flags & SPA_PROP_FLAG_DEPRECATED)
fprintf (stderr, "deprecated ");
fprintf (stderr, "\n");
fprintf (stderr, "%-23.23s %s. ", "", prop_type_names[info->type].CCName);
fprintf (stderr, "Default: ");
if (info->default_value)
print_value (info, info->default_size, info->default_value);
else
fprintf (stderr, "None");
res = props->get_prop (props, i, &value);
fprintf (stderr, ". Current: ");
if (res == SPA_RESULT_OK)
print_value (info, value.size, value.value);
else if (res == SPA_RESULT_PROPERTY_UNSET)
fprintf (stderr, "Unset");
else
fprintf (stderr, "Error %d", res);
fprintf (stderr, ".\n");
if (!print_ranges)
continue;
if (info->range_type != SPA_PROP_RANGE_TYPE_NONE) {
fprintf (stderr, "%-23.23s ", "");
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
fprintf (stderr, "Range");
break;
case SPA_PROP_RANGE_TYPE_STEP:
fprintf (stderr, "Step");
break;
case SPA_PROP_RANGE_TYPE_ENUM:
fprintf (stderr, "Enum");
break;
case SPA_PROP_RANGE_TYPE_FLAGS:
fprintf (stderr, "Flags");
break;
default:
fprintf (stderr, "Unknown");
break;
}
fprintf (stderr, ".\n");
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
fprintf (stderr, "%-23.23s ", "");
print_value (info, rinfo->size, rinfo->value);
fprintf (stderr, "\t: %-12s - %s \n", rinfo->name, rinfo->description);
}
}
if (info->tags) {
fprintf (stderr, "Tags: ");
for (j = 0; info->tags[j]; j++) {
fprintf (stderr, "\"%s\" ", info->tags[j]);
}
fprintf (stderr, "\n");
}
}
return SPA_RESULT_OK;
}
SpaResult
spa_debug_format (const SpaFormat *format)
{
const SpaProps *props;
int i;
if (format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
props = &format->props;
fprintf (stderr, "%-6s %s/%s\n", "", media_type_names[format->media_type].name,
media_subtype_names[format->media_subtype].name);
for (i = 0; i < props->n_prop_info; i++) {
const SpaPropInfo *info = &props->prop_info[i];
SpaPropValue value;
SpaResult res;
res = props->get_prop (props, i, &value);
if (res == SPA_RESULT_PROPERTY_UNSET && info->flags & SPA_PROP_FLAG_OPTIONAL)
continue;
fprintf (stderr, " %20s : (%s) ", info->name, prop_type_names[info->type].name);
if (res == SPA_RESULT_OK) {
print_value (info, value.size, value.value);
} else if (res == SPA_RESULT_PROPERTY_UNSET) {
int j;
const char *ssep, *esep, *sep;
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
case SPA_PROP_RANGE_TYPE_STEP:
ssep = "[ ";
sep = ", ";
esep = " ]";
break;
default:
case SPA_PROP_RANGE_TYPE_ENUM:
case SPA_PROP_RANGE_TYPE_FLAGS:
ssep = "{ ";
sep = ", ";
esep = " }";
break;
}
fprintf (stderr, ssep);
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
print_value (info, rinfo->size, rinfo->value);
fprintf (stderr, "%s", j + 1 < info->n_range_values ? sep : "");
}
fprintf (stderr, esep);
} else {
fprintf (stderr, "*Error*");
}
fprintf (stderr, "\n");
}
return SPA_RESULT_OK;
}

33
spa/lib/memory.c
View file

@ -114,8 +114,8 @@ spa_memory_alloc (uint32_t pool_id)
mem = &pool->memories[id];
mem->refcount = 1;
mem->notify = NULL;
mem->pool_id = pool_id;
mem->id = id;
mem->mem.pool_id = pool_id;
mem->mem.id = id;
return mem;
}
@ -159,16 +159,20 @@ spa_memory_alloc_with_fd (uint32_t pool_id, void *data, size_t size)
SpaMemory *
spa_memory_import (uint32_t pool_id, uint32_t id)
spa_memory_import (SpaMemoryRef *ref)
{
SpaMemory *mem = NULL;
SpaMemoryPool *pool;
int i;
bool init = false;
uint32_t id, pool_id;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return NULL;
id = ref->id;
pool_id = ref->pool_id;
pool = &pools[pool_id];
for (i = 0; i < pool->n_free; i++) {
@ -184,42 +188,41 @@ spa_memory_import (uint32_t pool_id, uint32_t id)
if (init) {
mem->refcount = 1;
mem->notify = NULL;
mem->pool_id = pool_id;
mem->id = id;
mem->mem = *ref;
}
return mem;
}
SpaResult
spa_memory_free (uint32_t pool_id, uint32_t id)
spa_memory_free (SpaMemoryRef *ref)
{
SpaMemoryPool *pool;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return SPA_RESULT_INVALID_ARGUMENTS;
pool = &pools[pool_id];
pool->free_mem[pool->n_free] = id;
pool = &pools[ref->pool_id];
pool->free_mem[pool->n_free] = ref->id;
pool->n_free++;
return SPA_RESULT_OK;
}
SpaMemory *
spa_memory_find (uint32_t pool_id, uint32_t id)
spa_memory_find (SpaMemoryRef *ref)
{
SpaMemoryPool *pool;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return NULL;
pool = &pools[pool_id];
pool = &pools[ref->pool_id];
if (id >= MAX_MEMORIES || pool->memories[id].refcount <= 0)
if (ref->id >= MAX_MEMORIES || pool->memories[ref->id].refcount <= 0)
return NULL;
return &pool->memories[id];
return &pool->memories[ref->id];
}
void *