// 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; }