// pickle / unpickle
u8* param_pickle(pnode_t* pnode, u8* dst) {
u32 val;
/// wasting some space to preserve 4-byte alignment
// store idx
//// TEST: don't
//dst = pickle_32((u32)pnode->idx, dst);
//// TEST: keep as dummy for compatibility
dst = pickle_32(0, dst);
////
// print_dbg("\r\n pickling param node, value: 0x");
// print_dbg_hex(pnode->data.value.asUint);
// store value
val = (u32)(pnode->data.value);
dst = pickle_32(val, dst);
// store play-inclusion
dst = pickle_32((u32)(pnode->play), dst);
// store descriptor
dst = pdesc_pickle(&(pnode->desc), dst);
return dst;
}
// pickle the network!
u8* net_pickle(u8* dst) {
u32 i;
op_t* op;
u32 val = 0;
// store count of operators
// (use 4 bytes for alignment)
dst = pickle_32((u32)(net->numOps), dst);
// loop over operators
for(i=0; i<net->numOps; ++i) {
op = net->ops[i];
// store type id
dst = pickle_32(op->type, dst);
// pickle the operator state (if needed)
if(op->pickle != NULL) {
dst = (*(op->pickle))(op, dst);
}
}
// write input nodes
// for(i=0; i < (net->numIns + net->numParams); ++i) {
/// FIXME: doing params is breaking stuff, somehow...!! arg
#if 1
for(i=0; i < (NET_INS_MAX); ++i) {
dst = inode_pickle(&(net->ins[i]), dst);
}
// write output nodes
for(i=0; i < NET_OUTS_MAX; ++i) {
dst = onode_pickle(&(net->outs[i]), dst);
}
#else
for(i=0; i < (net->numIns); ++i) {
dst = inode_pickle(&(net->ins[i]), dst);
}
// write output nodes
for(i=0; i < net->numOuts; ++i) {
dst = onode_pickle(&(net->outs[i]), dst);
}
#endif
// write count of parameters
val = (u32)(net->numParams);
dst = pickle_32(val, dst);
// write parameter nodes (includes value and descriptor)
for(i=0; i<net->numParams; ++i) {
dst = param_pickle(&(net->params[i]), dst);
}
return dst;
}
static u8* onode_pickle(onode_t* out, u8* dst) {
// operator output index
dst = pickle_32((u32)(out->opOutIdx), dst);
// target
dst = pickle_32((u32)(out->target), dst);
// parent op's index in net list
dst = pickle_32((u32)(out->opIdx), dst);
// preset inclusion flag ; cast to 4 bytes for alignment
// dst = pickle_32((u32)(out->preset), dst);
return dst;
}
// pickle the network!
u8* net_pickle(u8* dst) {
u32 i;
op_t* op;
u32 val = 0;
// write count of operators
// ( 4 bytes for alignment)
dst = pickle_32((u32)(net->numOps), dst);
// loop over operators
for(i=0; i<net->numOps; ++i) {
op = net->ops[i];
// store type id
dst = pickle_32(op->type, dst);
// pickle the operator state (if needed)
if(op->pickle != NULL) {
dst = (*(op->pickle))(op, dst);
}
}
// write input nodes
#if 1
//// all nodes, even unused
for(i=0; i < (NET_INS_MAX); ++i) {
dst = inode_pickle(&(net->ins[i]), dst);
}
// write output nodes
for(i=0; i < NET_OUTS_MAX; ++i) {
dst = onode_pickle(&(net->outs[i]), dst);
}
#else
/* for(i=0; i < (net->numIns); ++i) { */
/* dst = inode_pickle(&(net->ins[i]), dst); */
/* } */
/* // write output nodes */
/* for(i=0; i < net->numOuts; ++i) { */
/* dst = onode_pickle(&(net->outs[i]), dst); */
/* } */
#endif
// write count of parameters
// 4 bytes for alignment
val = (u32)(net->numParams);
dst = pickle_32(val, dst);
// write parameter nodes (includes value and descriptor)
for(i=0; i<net->numParams; ++i) {
dst = param_pickle(&(net->params[i]), dst);
}
return dst;
}
// pickle/unpickle for param descriptors
// (struct definition in param_common.h
u8* pdesc_pickle(ParamDesc* pdesc, u8* dst) {
u8 i;
// store label string
for(i=0; i<PARAM_LABEL_LEN; ++i) {
*dst = pdesc->label[i];
++dst;
}
// store type
*dst = pdesc->type;
++dst;
// store min
dst = pickle_32(pdesc->min, dst);
// store max
dst = pickle_32(pdesc->max, dst);
// store radix
dst = pickle_32(pdesc->radix, dst);
return dst;
}
// pickle/unpickle for param descriptors
// (struct definition in param_common.h
u8* pdesc_pickle(ParamDesc* pdesc, u8* dst) {
u32 i;
// store label string
for(i=0; i<PARAM_LABEL_LEN; ++i) {
*dst = pdesc->label[i];
++dst;
}
// store type
// pad for alignment
// store type (pad for alignment)
dst = pickle_32((u32)(pdesc->type), dst);
// store min
dst = pickle_32(pdesc->min, dst);
// store max
dst = pickle_32(pdesc->max, dst);
// store radix (pad for alignment)
dst = pickle_32((u32)(pdesc->radix), dst);
return dst;
}
// pickle / unpickle
u8* param_pickle(pnode_t* pnode, u8* dst) {
u32 val;
/// wasting some space to preserve 4-byte alignment
// store idx
dst = pickle_32((u32)pnode->idx, dst);
// print_dbg("\r\n pickling param node, value: 0x");
// print_dbg_hex(pnode->data.value.asUint);
// store value
val = (u32)(pnode->data.value);
dst = pickle_32(val, dst);
// store preset-inclusion
// dst = pickle_32((u32)(pnode->preset), dst);
// store descriptor
dst = pdesc_pickle(&(pnode->desc), dst);
return dst;
}
// pickle presets
u8* presets_pickle(u8* dst) {
u32 i, j;
for(i=0; i<NET_PRESETS_MAX; i++) {
// pickle inputs
// for(j=0; j<NET_INS_MAX; j++) {
for(j=0; j < PRESET_INODES_COUNT; ++j) {
// waste some space for 4-byte alignment
dst = pickle_32(presets[i].ins[j].value, dst);
///////////////
/////////////////
/// NOTE: not storing idx for now.
/// this could change if we switch to conditional storage
// dst = pickle_32(presets[i].ins[j].idx, dst);
dst = pickle_32(presets[i].ins[j].enabled, dst);
}
// pickle output
for(j=0; j<NET_OUTS_MAX; j++) {
// waste some space for 4-byte alignment
dst = pickle_32(presets[i].outs[j].target, dst);
///////////////
/////////////////
/// NOTE: not storing idx for now.
/// this could change if we switch to conditional storage
// dst = pickle_32(presets[i].outs[j].outIdx, dst);
dst = pickle_32(presets[i].outs[j].enabled, dst);
}
/* // pickle params */
/* for(j=0; j<NET_PARAMS_MAX; j++) { */
/* // waste some space for 4-byte alignment */
/* dst = pickle_32(presets[i].params[j].value, dst); */
/* dst = pickle_32(presets[i].params[j].idx, dst); */
/* dst = pickle_32(presets[i].params[j].enabled, dst); */
/* } */
// read name!
for(j=0; j<PRESET_NAME_LEN; j++) {
*dst++ = presets[i].name[j];
}
}
return dst;
}
u8* pdesc_pickle(ParamDesc* pdesc, u8* dst) {
u32 i;
printf("\r\n pickling descriptor; index: %d, name: %s,\ttype: %d, min: 0x%08x, max:0x%08x, radix:%d",
idesc, pdesc->label, pdesc->type, pdesc->min, pdesc->max, pdesc->radix );
// store label string
for(i=0; i<PARAM_LABEL_LEN; ++i) {
*dst = pdesc->label[i];
++dst;
}
// store type
// pad for alignment
dst = pickle_32((u32)(pdesc->type), dst);
// store min
dst = pickle_32(pdesc->min, dst);
// store max
dst = pickle_32(pdesc->max, dst);
// store radix
// pad for alignment
dst = pickle_32((u32)(pdesc->radix), dst);
++idesc;
return dst;
}
//---- main function
int main() {
FILE* out;
int i, j;
// write pointer
u8* pwr;
// data.paramDesc = desc;
strcat(str, NAME);
strcat(str, ".dsc");
fill_param_desc(desc);
printf("\r\n %s_desc_build ... ", NAME);
printf("\r\n filled param descripor table... \r\n");
out = fopen(str, "w");
pwr = buf;
// pack the count of parameters
pwr = pickle_32(eParamNumParams, pwr);
// serialize the descriptors
for(i=0; i<eParamNumParams; i++) {
pwr = pdesc_pickle(&(desc[i]), pwr);
}
// write to file
fwrite(buf, 1, (size_t)((size_t)pwr - (size_t)&buf), out);
printf("\r\n wrote %d bytes... \r\n", (int) ((size_t)pwr - (size_t)&buf));
fclose(out);
printf("\r\n done. \r\n");
return 0;
}
static u8* onode_pickle(onode_t* out, u8* dst) {
// target
dst = pickle_32((u32)(out->target), dst);
return dst;
}
