These is the beginning of a try to connect the pd to octave. Especially when using the iemmatrix features in pd, this feature becomes sensible. On the whole it shall enable the user to use the command line parser of octave.svn2git-root

The take-over strategy is bad at this starting point. No threading, no practical data transmission.
Perhaps the common work on it can help. (Franz)

svn path=/trunk/externals/iem/pdoctave/; revision=4611

1 files changed, 99 insertions, 0 deletions

diff --git a/read_shared_mem.cc b/read_shared_mem.cc
new file mode 100644
index 0000000..446ee0f
--- /dev/null
+++ b/read_shared_mem.cc
@@ -0,0 +1,99 @@
+#include <octave/oct.h>
+
+#include <unistd.h>
+#include <string.h>
+#include "pdoctave_dataframe.h"
+
+Matrix writeFloatIntoOctMatrix (int n, int m, float *f)
+{
+   int i;
+   int j;
+   Matrix mtx = Matrix(n,m);
+   for (j = 0; j < n; j++)
+      for (i=0; i < m; i++)
+	 mtx(j,i) = (double)*f++;
+   return mtx;
+}
+
+double writeFloatIntoDouble (float f)
+{
+   return (double) f;
+}
+
+RowVector writeFloatIntoRowVector (int n, float *f)
+{
+   RowVector rv = RowVector(n);
+   int i;
+   for (i = 0; i<n; i++)
+      rv(i) = (double) *f++;
+   return rv;
+}
+	 
+ColumnVector writeFloatIntoColumnVector (int n, float *f)
+{
+   ColumnVector cv = ColumnVector(n);
+   int i;
+   for (i = 0; i<n; i++)
+      cv(i) = (double) *f++;
+   return cv;
+}
+
+DEFUN_DLD (read_shared_mem, args, , "reading and returning a pd-value in octave")
+{
+   SharedDataFrame *sdf;
+   void *data;
+   octave_value convert_result;
+   int shmem_id = args(0).int_value();
+   float *f;
+   std::string str;
+   std::string quote_sign = "\"";
+   
+   if (shmem_id == -1) {
+      error("failed to get valid id\n");
+      return octave_value();
+   }
+   sdf = getSharedDataFrame (shmem_id);
+   
+   if (!sdf) {
+      error("failed to attach memory!\n");
+      return octave_value();
+   }
+   sleepUntilWriteBlocked (sdf,STD_USLEEP_TIME);
+   sleepUntilReadBlocked (sdf, STD_USLEEP_TIME);
+   
+   data = getSharedData (sdf);
+   if (!data) {
+     error("failed to attach data!\n");
+     freeSharedDataFrame (&sdf);
+     unBlockForReading (sdf);
+     return octave_value();
+   }
+
+   f = (float*) data;
+ 
+   switch (getSharedDataType (sdf)) {
+      case FLOAT: 
+	 convert_result = octave_value(writeFloatIntoDouble (*f));
+	 break;
+      case LIST:
+	 convert_result = octave_value( 
+	       writeFloatIntoRowVector (getSharedDataVecLength(sdf), f));
+	 break;
+      case SYMBOL:
+	 str = (std::string) (char *) data;
+	 convert_result = octave_value(quote_sign+str+quote_sign);
+	 break;
+      case MATRIX:
+	 convert_result = octave_value(writeFloatIntoOctMatrix ((int)f[0],(int)f[1],f+2));
+	 break;
+      case UNKNOWN:
+	 error("unknown pdoctave type");
+	 convert_result = octave_value ();
+   }
+   unBlockForReading (sdf);
+   removeSharedData (sdf, &data);
+   freeSharedDataFrame (&sdf);
+   return (convert_result);
+}
+
+