|
|
@@ -0,0 +1,247 @@
|
|
|
+
|
|
|
+#define PY_SSIZE_T_CLEAN
|
|
|
+#include "Python.h"
|
|
|
+#include <stdio.h>
|
|
|
+#include <stdint.h>
|
|
|
+
|
|
|
+#define FLUXOP_INDEX 1
|
|
|
+#define FLUXOP_SPACE 2
|
|
|
+#define FLUXOP_ASTABLE 3
|
|
|
+
|
|
|
+/* bitarray.append(value) */
|
|
|
+static PyObject *append_s;
|
|
|
+static int bitarray_append(PyObject *bitarray, PyObject *value)
|
|
|
+{
|
|
|
+ PyObject *res = PyObject_CallMethodObjArgs(
|
|
|
+ bitarray, append_s, value, NULL);
|
|
|
+ if (res == NULL)
|
|
|
+ return 0;
|
|
|
+ Py_DECREF(res);
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+static PyObject *
|
|
|
+flux_to_bitcells(PyObject *self, PyObject *args)
|
|
|
+{
|
|
|
+ /* Parameters */
|
|
|
+ PyObject *bit_array, *time_array, *revolutions;
|
|
|
+ PyObject *index_iter, *flux_iter;
|
|
|
+ double freq, clock_centre, clock_min, clock_max;
|
|
|
+ double pll_period_adj, pll_phase_adj;
|
|
|
+
|
|
|
+ /* Local variables */
|
|
|
+ PyObject *item;
|
|
|
+ double clock, new_ticks, ticks, to_index;
|
|
|
+ int zeros, nbits;
|
|
|
+
|
|
|
+ if (!PyArg_ParseTuple(args, "OOOOOdddddd",
|
|
|
+ &bit_array, &time_array, &revolutions,
|
|
|
+ &index_iter, &flux_iter,
|
|
|
+ &freq, &clock_centre, &clock_min, &clock_max,
|
|
|
+ &pll_period_adj, &pll_phase_adj))
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ nbits = 0;
|
|
|
+ ticks = 0.0;
|
|
|
+ clock = clock_centre;
|
|
|
+
|
|
|
+ /* to_index = next(index_iter) */
|
|
|
+ item = PyIter_Next(index_iter);
|
|
|
+ to_index = PyFloat_AsDouble(item);
|
|
|
+ Py_DECREF(item);
|
|
|
+ if (PyErr_Occurred())
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ /* for x in flux_iter: */
|
|
|
+ assert(PyIter_Check(flux_iter));
|
|
|
+ while ((item = PyIter_Next(flux_iter)) != NULL) {
|
|
|
+
|
|
|
+ double x = PyFloat_AsDouble(item);
|
|
|
+ Py_DECREF(item);
|
|
|
+ if (PyErr_Occurred())
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ /* Gather enough ticks to generate at least one bitcell. */
|
|
|
+ ticks += x / freq;
|
|
|
+ if (ticks < clock/2)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ /* Clock out zero or more 0s, followed by a 1. */
|
|
|
+ for (zeros = 0; ; zeros++) {
|
|
|
+
|
|
|
+ /* Check if we cross the index mark. */
|
|
|
+ to_index -= clock;
|
|
|
+ if (to_index < 0) {
|
|
|
+ if (PyList_Append(revolutions, PyLong_FromLong(nbits)) < 0)
|
|
|
+ return NULL;
|
|
|
+ nbits = 0;
|
|
|
+ item = PyIter_Next(index_iter);
|
|
|
+ to_index += PyFloat_AsDouble(item);
|
|
|
+ Py_DECREF(item);
|
|
|
+ if (PyErr_Occurred())
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ nbits += 1;
|
|
|
+ ticks -= clock;
|
|
|
+ if (PyList_Append(time_array, PyFloat_FromDouble(clock)) < 0)
|
|
|
+ return NULL;
|
|
|
+ if (ticks < clock/2) {
|
|
|
+ if (!bitarray_append(bit_array, Py_True))
|
|
|
+ return NULL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!bitarray_append(bit_array, Py_False))
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /* PLL: Adjust clock frequency according to phase mismatch. */
|
|
|
+ if (zeros <= 3) {
|
|
|
+ /* In sync: adjust clock by a fraction of the phase mismatch. */
|
|
|
+ clock += ticks * pll_period_adj;
|
|
|
+ } else {
|
|
|
+ /* Out of sync: adjust clock towards centre. */
|
|
|
+ clock += (clock_centre - clock) * pll_period_adj;
|
|
|
+ }
|
|
|
+ /* Clamp the clock's adjustment range. */
|
|
|
+ if (clock < clock_min)
|
|
|
+ clock = clock_min;
|
|
|
+ else if (clock > clock_max)
|
|
|
+ clock = clock_max;
|
|
|
+ /* PLL: Adjust clock phase according to mismatch. */
|
|
|
+ new_ticks = ticks * (1.0 - pll_phase_adj);
|
|
|
+ if (PyList_SetItem(time_array, PyList_Size(time_array)-1,
|
|
|
+ PyFloat_FromDouble(ticks - new_ticks)) < 0)
|
|
|
+ return NULL;
|
|
|
+ ticks = new_ticks;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ Py_RETURN_NONE;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+static int _read_28bit(uint8_t *p)
|
|
|
+{
|
|
|
+ int x;
|
|
|
+ x = (p[0] ) >> 1;
|
|
|
+ x |= (p[1] & 0xfe) << 6;
|
|
|
+ x |= (p[2] & 0xfe) << 13;
|
|
|
+ x |= (p[3] & 0xfe) << 20;
|
|
|
+ return x;
|
|
|
+}
|
|
|
+
|
|
|
+static PyObject *
|
|
|
+decode_flux(PyObject *self, PyObject *args)
|
|
|
+{
|
|
|
+ /* Parameters */
|
|
|
+ Py_buffer bytearray;
|
|
|
+ PyObject *res = NULL;
|
|
|
+
|
|
|
+ /* bytearray buffer */
|
|
|
+ uint8_t *p;
|
|
|
+ Py_ssize_t l;
|
|
|
+
|
|
|
+ /* Local variables */
|
|
|
+ PyObject *flux, *index;
|
|
|
+ long val, ticks, ticks_since_index;
|
|
|
+ int i, opcode;
|
|
|
+
|
|
|
+ if (!PyArg_ParseTuple(args, "y*", &bytearray))
|
|
|
+ return NULL;
|
|
|
+ p = bytearray.buf;
|
|
|
+ l = bytearray.len;
|
|
|
+
|
|
|
+ /* assert dat[-1] == 0 */
|
|
|
+ if ((l == 0) || (p[l-1] != 0)) {
|
|
|
+ PyErr_SetString(PyExc_ValueError, "Flux is not NUL-terminated");
|
|
|
+ PyBuffer_Release(&bytearray);
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+ /* len(dat) -= 1 */
|
|
|
+ l -= 1;
|
|
|
+
|
|
|
+ /* flux, index = [], [] */
|
|
|
+ flux = PyList_New(0);
|
|
|
+ index = PyList_New(0);
|
|
|
+ /* ticks, ticks_since_index = 0, 0 */
|
|
|
+ ticks = 0;
|
|
|
+ ticks_since_index = 0;
|
|
|
+
|
|
|
+ while (l != 0) {
|
|
|
+ i = *p++;
|
|
|
+ if (i == 255) {
|
|
|
+ if ((l -= 2) < 0)
|
|
|
+ goto oos;
|
|
|
+ opcode = *p++;
|
|
|
+ switch (opcode) {
|
|
|
+ case FLUXOP_INDEX:
|
|
|
+ if ((l -= 4) < 0)
|
|
|
+ goto oos;
|
|
|
+ val = _read_28bit(p);
|
|
|
+ p += 4;
|
|
|
+ if (PyList_Append(index, PyLong_FromLong(
|
|
|
+ ticks_since_index + ticks + val)) < 0)
|
|
|
+ goto out;
|
|
|
+ ticks_since_index = -(ticks + val);
|
|
|
+ break;
|
|
|
+ case FLUXOP_SPACE:
|
|
|
+ if ((l -= 4) < 0)
|
|
|
+ goto oos;
|
|
|
+ ticks += _read_28bit(p);
|
|
|
+ p += 4;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ PyErr_Format(PyExc_ValueError,
|
|
|
+ "Bad opcode in flux stream (%d)", opcode);
|
|
|
+ goto out;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (i < 250) {
|
|
|
+ l -= 1;
|
|
|
+ val = i;
|
|
|
+ } else {
|
|
|
+ if ((l -= 2) < 0)
|
|
|
+ goto oos;
|
|
|
+ val = 250 + (i - 250) * 255;
|
|
|
+ val += *p++ - 1;
|
|
|
+ }
|
|
|
+ ticks += val;
|
|
|
+ if (PyList_Append(flux, PyLong_FromLong(ticks)) < 0)
|
|
|
+ goto out;
|
|
|
+ ticks_since_index += ticks;
|
|
|
+ ticks = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ res = Py_BuildValue("OO", flux, index);
|
|
|
+
|
|
|
+out:
|
|
|
+ PyBuffer_Release(&bytearray);
|
|
|
+ Py_DECREF(flux);
|
|
|
+ Py_DECREF(index);
|
|
|
+ return res;
|
|
|
+
|
|
|
+oos:
|
|
|
+ PyErr_SetString(PyExc_ValueError, "Unexpected end of flux");
|
|
|
+ goto out;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+static PyMethodDef modulefuncs[] = {
|
|
|
+ { "flux_to_bitcells", flux_to_bitcells, METH_VARARGS, NULL },
|
|
|
+ { "decode_flux", decode_flux, METH_VARARGS, NULL },
|
|
|
+ { NULL }
|
|
|
+};
|
|
|
+
|
|
|
+static PyModuleDef moduledef = {
|
|
|
+ PyModuleDef_HEAD_INIT, "optimised", 0, -1, modulefuncs,
|
|
|
+};
|
|
|
+
|
|
|
+PyMODINIT_FUNC PyInit_optimised(void)
|
|
|
+{
|
|
|
+ append_s = Py_BuildValue("s", "append");
|
|
|
+ return PyModule_Create(&moduledef);
|
|
|
+}
|
Keir Fraser